Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 8f256622 authored by Pablo Neira Ayuso's avatar Pablo Neira Ayuso Committed by David S. Miller
Browse files

flow_offload: add flow_rule and flow_match structures and use them 



This patch wraps the dissector key and mask - that flower uses to
represent the matching side - around the flow_match structure.

To avoid a follow up patch that would edit the same LoCs in the drivers,
this patch also wraps this new flow match structure around the flow rule
object. This new structure will also contain the flow actions in follow
up patches.

This introduces two new interfaces:

	bool flow_rule_match_key(rule, dissector_id)

that returns true if a given matching key is set on, and:

	flow_rule_match_XYZ(rule, &match);

To fetch the matching side XYZ into the match container structure, to
retrieve the key and the mask with one single call.

Signed-off-by: default avatarPablo Neira Ayuso <pablo@netfilter.org>
Acked-by: default avatarJiri Pirko <jiri@mellanox.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent d9b5a675

drivers/net/ethernet/broadcom/bnxt/bnxt_tc.c

+74 −100
Original line number Diff line number Diff line
@@ -177,18 +177,12 @@ static int bnxt_tc_parse_actions(struct bnxt *bp, 
	return 0;

}



#define GET_KEY(flow_cmd, key_type)					\

		skb_flow_dissector_target((flow_cmd)->dissector, key_type,\

					  (flow_cmd)->key)

#define GET_MASK(flow_cmd, key_type)					\

		skb_flow_dissector_target((flow_cmd)->dissector, key_type,\

					  (flow_cmd)->mask)



static int bnxt_tc_parse_flow(struct bnxt *bp,

			      struct tc_cls_flower_offload *tc_flow_cmd,

			      struct bnxt_tc_flow *flow)

{

	struct flow_dissector *dissector = tc_flow_cmd->dissector;

	struct flow_rule *rule = tc_cls_flower_offload_flow_rule(tc_flow_cmd);

	struct flow_dissector *dissector = rule->match.dissector;



	/* KEY_CONTROL and KEY_BASIC are needed for forming a meaningful key */

	if ((dissector->used_keys & BIT(FLOW_DISSECTOR_KEY_CONTROL)) == 0 ||
@@ -198,140 +192,120 @@ static int bnxt_tc_parse_flow(struct bnxt *bp, 
		return -EOPNOTSUPP;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_dissector_key_basic *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);

		struct flow_dissector_key_basic *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_BASIC);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_match_basic match;



		flow->l2_key.ether_type = key->n_proto;

		flow->l2_mask.ether_type = mask->n_proto;

		flow_rule_match_basic(rule, &match);

		flow->l2_key.ether_type = match.key->n_proto;

		flow->l2_mask.ether_type = match.mask->n_proto;



		if (key->n_proto == htons(ETH_P_IP) ||

		    key->n_proto == htons(ETH_P_IPV6)) {

			flow->l4_key.ip_proto = key->ip_proto;

			flow->l4_mask.ip_proto = mask->ip_proto;

		if (match.key->n_proto == htons(ETH_P_IP) ||

		    match.key->n_proto == htons(ETH_P_IPV6)) {

			flow->l4_key.ip_proto = match.key->ip_proto;

			flow->l4_mask.ip_proto = match.mask->ip_proto;

		}

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {

		struct flow_dissector_key_eth_addrs *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);

		struct flow_dissector_key_eth_addrs *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ETH_ADDRS);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {

		struct flow_match_eth_addrs match;



		flow_rule_match_eth_addrs(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_ETH_ADDRS;

		ether_addr_copy(flow->l2_key.dmac, key->dst);

		ether_addr_copy(flow->l2_mask.dmac, mask->dst);

		ether_addr_copy(flow->l2_key.smac, key->src);

		ether_addr_copy(flow->l2_mask.smac, mask->src);

		ether_addr_copy(flow->l2_key.dmac, match.key->dst);

		ether_addr_copy(flow->l2_mask.dmac, match.mask->dst);

		ether_addr_copy(flow->l2_key.smac, match.key->src);

		ether_addr_copy(flow->l2_mask.smac, match.mask->src);

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_dissector_key_vlan *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);

		struct flow_dissector_key_vlan *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_VLAN);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_match_vlan match;



		flow_rule_match_vlan(rule, &match);

		flow->l2_key.inner_vlan_tci =

		   cpu_to_be16(VLAN_TCI(key->vlan_id, key->vlan_priority));

			cpu_to_be16(VLAN_TCI(match.key->vlan_id,

					     match.key->vlan_priority));

		flow->l2_mask.inner_vlan_tci =

		   cpu_to_be16((VLAN_TCI(mask->vlan_id, mask->vlan_priority)));

			cpu_to_be16((VLAN_TCI(match.mask->vlan_id,

					      match.mask->vlan_priority)));

		flow->l2_key.inner_vlan_tpid = htons(ETH_P_8021Q);

		flow->l2_mask.inner_vlan_tpid = htons(0xffff);

		flow->l2_key.num_vlans = 1;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {

		struct flow_dissector_key_ipv4_addrs *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);

		struct flow_dissector_key_ipv4_addrs *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV4_ADDRS);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV4_ADDRS)) {

		struct flow_match_ipv4_addrs match;



		flow_rule_match_ipv4_addrs(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_IPV4_ADDRS;

		flow->l3_key.ipv4.daddr.s_addr = key->dst;

		flow->l3_mask.ipv4.daddr.s_addr = mask->dst;

		flow->l3_key.ipv4.saddr.s_addr = key->src;

		flow->l3_mask.ipv4.saddr.s_addr = mask->src;

	} else if (dissector_uses_key(dissector,

				      FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {

		struct flow_dissector_key_ipv6_addrs *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);

		struct flow_dissector_key_ipv6_addrs *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_IPV6_ADDRS);



		flow->l3_key.ipv4.daddr.s_addr = match.key->dst;

		flow->l3_mask.ipv4.daddr.s_addr = match.mask->dst;

		flow->l3_key.ipv4.saddr.s_addr = match.key->src;

		flow->l3_mask.ipv4.saddr.s_addr = match.mask->src;

	} else if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IPV6_ADDRS)) {

		struct flow_match_ipv6_addrs match;



		flow_rule_match_ipv6_addrs(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_IPV6_ADDRS;

		flow->l3_key.ipv6.daddr = key->dst;

		flow->l3_mask.ipv6.daddr = mask->dst;

		flow->l3_key.ipv6.saddr = key->src;

		flow->l3_mask.ipv6.saddr = mask->src;

		flow->l3_key.ipv6.daddr = match.key->dst;

		flow->l3_mask.ipv6.daddr = match.mask->dst;

		flow->l3_key.ipv6.saddr = match.key->src;

		flow->l3_mask.ipv6.saddr = match.mask->src;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_dissector_key_ports *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);

		struct flow_dissector_key_ports *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_PORTS);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_match_ports match;



		flow_rule_match_ports(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_PORTS;

		flow->l4_key.ports.dport = key->dst;

		flow->l4_mask.ports.dport = mask->dst;

		flow->l4_key.ports.sport = key->src;

		flow->l4_mask.ports.sport = mask->src;

		flow->l4_key.ports.dport = match.key->dst;

		flow->l4_mask.ports.dport = match.mask->dst;

		flow->l4_key.ports.sport = match.key->src;

		flow->l4_mask.ports.sport = match.mask->src;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ICMP)) {

		struct flow_dissector_key_icmp *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);

		struct flow_dissector_key_icmp *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ICMP);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ICMP)) {

		struct flow_match_icmp match;



		flow_rule_match_icmp(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_ICMP;

		flow->l4_key.icmp.type = key->type;

		flow->l4_key.icmp.code = key->code;

		flow->l4_mask.icmp.type = mask->type;

		flow->l4_mask.icmp.code = mask->code;

		flow->l4_key.icmp.type = match.key->type;

		flow->l4_key.icmp.code = match.key->code;

		flow->l4_mask.icmp.type = match.mask->type;

		flow->l4_mask.icmp.code = match.mask->code;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) {

		struct flow_dissector_key_ipv4_addrs *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS);

		struct flow_dissector_key_ipv4_addrs *mask =

				GET_MASK(tc_flow_cmd,

					 FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS)) {

		struct flow_match_ipv4_addrs match;



		flow_rule_match_enc_ipv4_addrs(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_IPV4_ADDRS;

		flow->tun_key.u.ipv4.dst = key->dst;

		flow->tun_mask.u.ipv4.dst = mask->dst;

		flow->tun_key.u.ipv4.src = key->src;

		flow->tun_mask.u.ipv4.src = mask->src;

	} else if (dissector_uses_key(dissector,

		flow->tun_key.u.ipv4.dst = match.key->dst;

		flow->tun_mask.u.ipv4.dst = match.mask->dst;

		flow->tun_key.u.ipv4.src = match.key->src;

		flow->tun_mask.u.ipv4.src = match.mask->src;

	} else if (flow_rule_match_key(rule,

				      FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS)) {

		return -EOPNOTSUPP;

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) {

		struct flow_dissector_key_keyid *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ENC_KEYID);

		struct flow_dissector_key_keyid *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ENC_KEYID);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {

		struct flow_match_enc_keyid match;



		flow_rule_match_enc_keyid(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_ID;

		flow->tun_key.tun_id = key32_to_tunnel_id(key->keyid);

		flow->tun_mask.tun_id = key32_to_tunnel_id(mask->keyid);

		flow->tun_key.tun_id = key32_to_tunnel_id(match.key->keyid);

		flow->tun_mask.tun_id = key32_to_tunnel_id(match.mask->keyid);

	}



	if (dissector_uses_key(dissector, FLOW_DISSECTOR_KEY_ENC_PORTS)) {

		struct flow_dissector_key_ports *key =

			GET_KEY(tc_flow_cmd, FLOW_DISSECTOR_KEY_ENC_PORTS);

		struct flow_dissector_key_ports *mask =

			GET_MASK(tc_flow_cmd, FLOW_DISSECTOR_KEY_ENC_PORTS);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS)) {

		struct flow_match_ports match;



		flow_rule_match_enc_ports(rule, &match);

		flow->flags |= BNXT_TC_FLOW_FLAGS_TUNL_PORTS;

		flow->tun_key.tp_dst = key->dst;

		flow->tun_mask.tp_dst = mask->dst;

		flow->tun_key.tp_src = key->src;

		flow->tun_mask.tp_src = mask->src;

		flow->tun_key.tp_dst = match.key->dst;

		flow->tun_mask.tp_dst = match.mask->dst;

		flow->tun_key.tp_src = match.key->src;

		flow->tun_mask.tp_src = match.mask->src;

	}



	return bnxt_tc_parse_actions(bp, &flow->actions, tc_flow_cmd->exts);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_tc_flower.c

+79 −115
Original line number Diff line number Diff line
@@ -83,28 +83,23 @@ static void cxgb4_process_flow_match(struct net_device *dev, 
				     struct tc_cls_flower_offload *cls,

				     struct ch_filter_specification *fs)

{

	struct flow_rule *rule = tc_cls_flower_offload_flow_rule(cls);

	u16 addr_type = 0;



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_CONTROL)) {

		struct flow_dissector_key_control *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_CONTROL,

						  cls->key);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_CONTROL)) {

		struct flow_match_control match;



		addr_type = key->addr_type;

		flow_rule_match_control(rule, &match);

		addr_type = match.key->addr_type;

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_dissector_key_basic *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->key);

		struct flow_dissector_key_basic *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->mask);

		u16 ethtype_key = ntohs(key->n_proto);

		u16 ethtype_mask = ntohs(mask->n_proto);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_match_basic match;

		u16 ethtype_key, ethtype_mask;



		flow_rule_match_basic(rule, &match);

		ethtype_key = ntohs(match.key->n_proto);

		ethtype_mask = ntohs(match.mask->n_proto);



		if (ethtype_key == ETH_P_ALL) {

			ethtype_key = 0;
@@ -116,114 +111,88 @@ static void cxgb4_process_flow_match(struct net_device *dev, 


		fs->val.ethtype = ethtype_key;

		fs->mask.ethtype = ethtype_mask;

		fs->val.proto = key->ip_proto;

		fs->mask.proto = mask->ip_proto;

		fs->val.proto = match.key->ip_proto;

		fs->mask.proto = match.mask->ip_proto;

	}



	if (addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {

		struct flow_dissector_key_ipv4_addrs *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV4_ADDRS,

						  cls->key);

		struct flow_dissector_key_ipv4_addrs *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV4_ADDRS,

						  cls->mask);

		struct flow_match_ipv4_addrs match;



		flow_rule_match_ipv4_addrs(rule, &match);

		fs->type = 0;

		memcpy(&fs->val.lip[0], &key->dst, sizeof(key->dst));

		memcpy(&fs->val.fip[0], &key->src, sizeof(key->src));

		memcpy(&fs->mask.lip[0], &mask->dst, sizeof(mask->dst));

		memcpy(&fs->mask.fip[0], &mask->src, sizeof(mask->src));

		memcpy(&fs->val.lip[0], &match.key->dst, sizeof(match.key->dst));

		memcpy(&fs->val.fip[0], &match.key->src, sizeof(match.key->src));

		memcpy(&fs->mask.lip[0], &match.mask->dst, sizeof(match.mask->dst));

		memcpy(&fs->mask.fip[0], &match.mask->src, sizeof(match.mask->src));



		/* also initialize nat_lip/fip to same values */

		memcpy(&fs->nat_lip[0], &key->dst, sizeof(key->dst));

		memcpy(&fs->nat_fip[0], &key->src, sizeof(key->src));



		memcpy(&fs->nat_lip[0], &match.key->dst, sizeof(match.key->dst));

		memcpy(&fs->nat_fip[0], &match.key->src, sizeof(match.key->src));

	}



	if (addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {

		struct flow_dissector_key_ipv6_addrs *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV6_ADDRS,

						  cls->key);

		struct flow_dissector_key_ipv6_addrs *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_IPV6_ADDRS,

						  cls->mask);

		struct flow_match_ipv6_addrs match;



		flow_rule_match_ipv6_addrs(rule, &match);

		fs->type = 1;

		memcpy(&fs->val.lip[0], key->dst.s6_addr, sizeof(key->dst));

		memcpy(&fs->val.fip[0], key->src.s6_addr, sizeof(key->src));

		memcpy(&fs->mask.lip[0], mask->dst.s6_addr, sizeof(mask->dst));

		memcpy(&fs->mask.fip[0], mask->src.s6_addr, sizeof(mask->src));

		memcpy(&fs->val.lip[0], match.key->dst.s6_addr,

		       sizeof(match.key->dst));

		memcpy(&fs->val.fip[0], match.key->src.s6_addr,

		       sizeof(match.key->src));

		memcpy(&fs->mask.lip[0], match.mask->dst.s6_addr,

		       sizeof(match.mask->dst));

		memcpy(&fs->mask.fip[0], match.mask->src.s6_addr,

		       sizeof(match.mask->src));



		/* also initialize nat_lip/fip to same values */

		memcpy(&fs->nat_lip[0], key->dst.s6_addr, sizeof(key->dst));

		memcpy(&fs->nat_fip[0], key->src.s6_addr, sizeof(key->src));

		memcpy(&fs->nat_lip[0], match.key->dst.s6_addr,

		       sizeof(match.key->dst));

		memcpy(&fs->nat_fip[0], match.key->src.s6_addr,

		       sizeof(match.key->src));

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_dissector_key_ports *key, *mask;

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_PORTS)) {

		struct flow_match_ports match;



		key = skb_flow_dissector_target(cls->dissector,

						FLOW_DISSECTOR_KEY_PORTS,

						cls->key);

		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_PORTS,

						 cls->mask);

		fs->val.lport = cpu_to_be16(key->dst);

		fs->mask.lport = cpu_to_be16(mask->dst);

		fs->val.fport = cpu_to_be16(key->src);

		fs->mask.fport = cpu_to_be16(mask->src);

		flow_rule_match_ports(rule, &match);

		fs->val.lport = cpu_to_be16(match.key->dst);

		fs->mask.lport = cpu_to_be16(match.mask->dst);

		fs->val.fport = cpu_to_be16(match.key->src);

		fs->mask.fport = cpu_to_be16(match.mask->src);



		/* also initialize nat_lport/fport to same values */

		fs->nat_lport = cpu_to_be16(key->dst);

		fs->nat_fport = cpu_to_be16(key->src);

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_IP)) {

		struct flow_dissector_key_ip *key, *mask;



		key = skb_flow_dissector_target(cls->dissector,

						FLOW_DISSECTOR_KEY_IP,

						cls->key);

		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_IP,

						 cls->mask);

		fs->val.tos = key->tos;

		fs->mask.tos = mask->tos;

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_ENC_KEYID)) {

		struct flow_dissector_key_keyid *key, *mask;



		key = skb_flow_dissector_target(cls->dissector,

						FLOW_DISSECTOR_KEY_ENC_KEYID,

						cls->key);

		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_ENC_KEYID,

						 cls->mask);

		fs->val.vni = be32_to_cpu(key->keyid);

		fs->mask.vni = be32_to_cpu(mask->keyid);

		fs->nat_lport = cpu_to_be16(match.key->dst);

		fs->nat_fport = cpu_to_be16(match.key->src);

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {

		struct flow_match_ip match;



		flow_rule_match_ip(rule, &match);

		fs->val.tos = match.key->tos;

		fs->mask.tos = match.mask->tos;

	}



	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_KEYID)) {

		struct flow_match_enc_keyid match;



		flow_rule_match_enc_keyid(rule, &match);

		fs->val.vni = be32_to_cpu(match.key->keyid);

		fs->mask.vni = be32_to_cpu(match.mask->keyid);

		if (fs->mask.vni) {

			fs->val.encap_vld = 1;

			fs->mask.encap_vld = 1;

		}

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_dissector_key_vlan *key, *mask;

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_match_vlan match;

		u16 vlan_tci, vlan_tci_mask;



		key = skb_flow_dissector_target(cls->dissector,

						FLOW_DISSECTOR_KEY_VLAN,

						cls->key);

		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_VLAN,

						 cls->mask);

		vlan_tci = key->vlan_id | (key->vlan_priority <<

		flow_rule_match_vlan(rule, &match);

		vlan_tci = match.key->vlan_id | (match.key->vlan_priority <<

					       VLAN_PRIO_SHIFT);

		vlan_tci_mask = mask->vlan_id | (mask->vlan_priority <<

		vlan_tci_mask = match.mask->vlan_id | (match.mask->vlan_priority <<

						     VLAN_PRIO_SHIFT);

		fs->val.ivlan = vlan_tci;

		fs->mask.ivlan = vlan_tci_mask;
@@ -255,10 +224,12 @@ static void cxgb4_process_flow_match(struct net_device *dev, 
static int cxgb4_validate_flow_match(struct net_device *dev,

				     struct tc_cls_flower_offload *cls)

{

	struct flow_rule *rule = tc_cls_flower_offload_flow_rule(cls);

	struct flow_dissector *dissector = rule->match.dissector;

	u16 ethtype_mask = 0;

	u16 ethtype_key = 0;



	if (cls->dissector->used_keys &

	if (dissector->used_keys &

	    ~(BIT(FLOW_DISSECTOR_KEY_CONTROL) |

	      BIT(FLOW_DISSECTOR_KEY_BASIC) |

	      BIT(FLOW_DISSECTOR_KEY_IPV4_ADDRS) |
@@ -268,36 +239,29 @@ static int cxgb4_validate_flow_match(struct net_device *dev, 
	      BIT(FLOW_DISSECTOR_KEY_VLAN) |

	      BIT(FLOW_DISSECTOR_KEY_IP))) {

		netdev_warn(dev, "Unsupported key used: 0x%x\n",

			    cls->dissector->used_keys);

			    dissector->used_keys);

		return -EOPNOTSUPP;

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_dissector_key_basic *key =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->key);

		struct flow_dissector_key_basic *mask =

			skb_flow_dissector_target(cls->dissector,

						  FLOW_DISSECTOR_KEY_BASIC,

						  cls->mask);

		ethtype_key = ntohs(key->n_proto);

		ethtype_mask = ntohs(mask->n_proto);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_match_basic match;



		flow_rule_match_basic(rule, &match);

		ethtype_key = ntohs(match.key->n_proto);

		ethtype_mask = ntohs(match.mask->n_proto);

	}



	if (dissector_uses_key(cls->dissector, FLOW_DISSECTOR_KEY_IP)) {

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_IP)) {

		u16 eth_ip_type = ethtype_key & ethtype_mask;

		struct flow_dissector_key_ip *mask;

		struct flow_match_ip match;



		if (eth_ip_type != ETH_P_IP && eth_ip_type != ETH_P_IPV6) {

			netdev_err(dev, "IP Key supported only with IPv4/v6");

			return -EINVAL;

		}



		mask = skb_flow_dissector_target(cls->dissector,

						 FLOW_DISSECTOR_KEY_IP,

						 cls->mask);

		if (mask->ttl) {

		flow_rule_match_ip(rule, &match);

		if (match.mask->ttl) {

			netdev_warn(dev, "ttl match unsupported for offload");

			return -EOPNOTSUPP;

		}

drivers/net/ethernet/intel/i40e/i40e_main.c

+68 −110

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/intel/iavf/iavf_main.c

+80 −115

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/intel/igb/igb_main.c

+24 −40
Original line number Diff line number Diff line
@@ -2581,9 +2581,11 @@ static int igb_parse_cls_flower(struct igb_adapter *adapter, 
				int traffic_class,

				struct igb_nfc_filter *input)

{

	struct flow_rule *rule = tc_cls_flower_offload_flow_rule(f);

	struct flow_dissector *dissector = rule->match.dissector;

	struct netlink_ext_ack *extack = f->common.extack;



	if (f->dissector->used_keys &

	if (dissector->used_keys &

	    ~(BIT(FLOW_DISSECTOR_KEY_BASIC) |

	      BIT(FLOW_DISSECTOR_KEY_CONTROL) |

	      BIT(FLOW_DISSECTOR_KEY_ETH_ADDRS) |
@@ -2593,78 +2595,60 @@ static int igb_parse_cls_flower(struct igb_adapter *adapter, 
		return -EOPNOTSUPP;

	}



	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {

		struct flow_dissector_key_eth_addrs *key, *mask;

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {

		struct flow_match_eth_addrs match;



		key = skb_flow_dissector_target(f->dissector,

						FLOW_DISSECTOR_KEY_ETH_ADDRS,

						f->key);

		mask = skb_flow_dissector_target(f->dissector,

						 FLOW_DISSECTOR_KEY_ETH_ADDRS,

						 f->mask);



		if (!is_zero_ether_addr(mask->dst)) {

			if (!is_broadcast_ether_addr(mask->dst)) {

		flow_rule_match_eth_addrs(rule, &match);

		if (!is_zero_ether_addr(match.mask->dst)) {

			if (!is_broadcast_ether_addr(match.mask->dst)) {

				NL_SET_ERR_MSG_MOD(extack, "Only full masks are supported for destination MAC address");

				return -EINVAL;

			}



			input->filter.match_flags |=

				IGB_FILTER_FLAG_DST_MAC_ADDR;

			ether_addr_copy(input->filter.dst_addr, key->dst);

			ether_addr_copy(input->filter.dst_addr, match.key->dst);

		}



		if (!is_zero_ether_addr(mask->src)) {

			if (!is_broadcast_ether_addr(mask->src)) {

		if (!is_zero_ether_addr(match.mask->src)) {

			if (!is_broadcast_ether_addr(match.mask->src)) {

				NL_SET_ERR_MSG_MOD(extack, "Only full masks are supported for source MAC address");

				return -EINVAL;

			}



			input->filter.match_flags |=

				IGB_FILTER_FLAG_SRC_MAC_ADDR;

			ether_addr_copy(input->filter.src_addr, key->src);

			ether_addr_copy(input->filter.src_addr, match.key->src);

		}

	}



	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_dissector_key_basic *key, *mask;



		key = skb_flow_dissector_target(f->dissector,

						FLOW_DISSECTOR_KEY_BASIC,

						f->key);

		mask = skb_flow_dissector_target(f->dissector,

						 FLOW_DISSECTOR_KEY_BASIC,

						 f->mask);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_BASIC)) {

		struct flow_match_basic match;



		if (mask->n_proto) {

			if (mask->n_proto != ETHER_TYPE_FULL_MASK) {

		flow_rule_match_basic(rule, &match);

		if (match.mask->n_proto) {

			if (match.mask->n_proto != ETHER_TYPE_FULL_MASK) {

				NL_SET_ERR_MSG_MOD(extack, "Only full mask is supported for EtherType filter");

				return -EINVAL;

			}



			input->filter.match_flags |= IGB_FILTER_FLAG_ETHER_TYPE;

			input->filter.etype = key->n_proto;

			input->filter.etype = match.key->n_proto;

		}

	}



	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_dissector_key_vlan *key, *mask;



		key = skb_flow_dissector_target(f->dissector,

						FLOW_DISSECTOR_KEY_VLAN,

						f->key);

		mask = skb_flow_dissector_target(f->dissector,

						 FLOW_DISSECTOR_KEY_VLAN,

						 f->mask);

	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_VLAN)) {

		struct flow_match_vlan match;



		if (mask->vlan_priority) {

			if (mask->vlan_priority != VLAN_PRIO_FULL_MASK) {

		flow_rule_match_vlan(rule, &match);

		if (match.mask->vlan_priority) {

			if (match.mask->vlan_priority != VLAN_PRIO_FULL_MASK) {

				NL_SET_ERR_MSG_MOD(extack, "Only full mask is supported for VLAN priority");

				return -EINVAL;

			}



			input->filter.match_flags |= IGB_FILTER_FLAG_VLAN_TCI;

			input->filter.vlan_tci = key->vlan_priority;

			input->filter.vlan_tci = match.key->vlan_priority;

		}

	}