From mboxrd@z Thu Jan 1 00:00:00 1970 From: Pablo Neira Ayuso Subject: [PATCH RFC,net-next 09/10] flow_dissector: add basic ethtool_rx_flow_spec to flow_rule structure translator Date: Tue, 25 Sep 2018 21:20:00 +0200 Message-ID: <20180925192001.2482-10-pablo@netfilter.org> References: <20180925192001.2482-1-pablo@netfilter.org> Cc: davem@davemloft.net, thomas.lendacky@amd.com, f.fainelli@gmail.com, ariel.elior@cavium.com, michael.chan@broadcom.com, santosh@chelsio.com, madalin.bucur@nxp.com, yisen.zhuang@huawei.com, salil.mehta@huawei.com, jeffrey.t.kirsher@intel.com, tariqt@mellanox.com, saeedm@mellanox.com, jiri@mellanox.com, idosch@mellanox.com, ganeshgr@chelsio.com, jakub.kicinski@netronome.com, linux-net-drivers@solarflare.com, peppe.cavallaro@st.com, alexandre.torgue@st.com, joabreu@synopsys.com, grygorii.strashko@ti.com, andrew@lunn.ch, vivien.didelot@savoirfairelinux.com To: netdev@vger.kernel.org Return-path: Received: from mail.us.es ([193.147.175.20]:49740 "EHLO mail.us.es" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727616AbeIZB3j (ORCPT ); Tue, 25 Sep 2018 21:29:39 -0400 Received: from antivirus1-rhel7.int (unknown [192.168.2.11]) by mail.us.es (Postfix) with ESMTP id 050D5190F83 for ; Tue, 25 Sep 2018 21:20:36 +0200 (CEST) Received: from antivirus1-rhel7.int (localhost [127.0.0.1]) by antivirus1-rhel7.int (Postfix) with ESMTP id D8436DA90B for ; Tue, 25 Sep 2018 21:20:35 +0200 (CEST) In-Reply-To: <20180925192001.2482-1-pablo@netfilter.org> Sender: netdev-owner@vger.kernel.org List-ID: This patch adds a function to translate the ethtool_rx_flow_spec structure to the flow_rule representation. This allows us to reuse code from the driver side given the flower and the ethtool_rx_flow interface use the same representation. Signed-off-by: Pablo Neira Ayuso --- include/net/flow_dissector.h | 5 ++ net/core/flow_dissector.c | 190 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 195 insertions(+) diff --git a/include/net/flow_dissector.h b/include/net/flow_dissector.h index 7a4683646d5a..ec9036232538 100644 --- a/include/net/flow_dissector.h +++ b/include/net/flow_dissector.h @@ -485,4 +485,9 @@ static inline bool flow_rule_match_key(const struct flow_rule *rule, return dissector_uses_key(rule->match.dissector, key); } +struct ethtool_rx_flow_spec; + +struct flow_rule *ethtool_rx_flow_rule(const struct ethtool_rx_flow_spec *fs); +void ethtool_rx_flow_rule_free(struct flow_rule *rule); + #endif diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c index e25b235a8e10..73c9c7d29cd3 100644 --- a/net/core/flow_dissector.c +++ b/net/core/flow_dissector.c @@ -25,6 +25,7 @@ #include #include #include +#include static void dissector_set_key(struct flow_dissector *flow_dissector, enum flow_dissector_key_id key_id) @@ -213,6 +214,195 @@ void flow_action_free(struct flow_action *flow_action) } EXPORT_SYMBOL(flow_action_free); +struct ethtool_rx_flow_key { + struct flow_dissector_key_basic basic; + union { + struct flow_dissector_key_ipv4_addrs ipv4; + struct flow_dissector_key_ipv6_addrs ipv6; + }; + struct flow_dissector_key_ports tp; + struct flow_dissector_key_ip ip; +} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */ + +struct ethtool_rx_flow_match { + struct flow_dissector dissector; + struct ethtool_rx_flow_key key; + struct ethtool_rx_flow_key mask; +}; + +struct flow_rule *ethtool_rx_flow_rule(const struct ethtool_rx_flow_spec *fs) +{ + static struct in6_addr zero_addr = {}; + struct ethtool_rx_flow_match *match; + struct flow_action_key *act; + struct flow_rule *rule; + + rule = kmalloc(sizeof(struct flow_rule), GFP_KERNEL); + if (!rule) + return NULL; + + match = kzalloc(sizeof(struct ethtool_rx_flow_match), GFP_KERNEL); + if (!match) + goto err_match; + + rule->match.dissector = &match->dissector; + rule->match.mask = &match->mask; + rule->match.key = &match->key; + + match->mask.basic.n_proto = 0xffff; + + switch (fs->flow_type & ~FLOW_EXT) { + case TCP_V4_FLOW: + case UDP_V4_FLOW: { + const struct ethtool_tcpip4_spec *v4_spec, *v4_m_spec; + + match->key.basic.n_proto = htons(ETH_P_IP); + + v4_spec = &fs->h_u.tcp_ip4_spec; + v4_m_spec = &fs->m_u.tcp_ip4_spec; + + if (v4_m_spec->ip4src) { + match->key.ipv4.src = v4_spec->ip4src; + match->mask.ipv4.src = v4_m_spec->ip4src; + } + if (v4_m_spec->ip4dst) { + match->key.ipv4.dst = v4_spec->ip4dst; + match->mask.ipv4.dst = v4_m_spec->ip4dst; + } + if (v4_m_spec->ip4src || + v4_m_spec->ip4dst) { + match->dissector.used_keys |= + FLOW_DISSECTOR_KEY_IPV4_ADDRS; + match->dissector.offset[FLOW_DISSECTOR_KEY_IPV4_ADDRS] = + offsetof(struct ethtool_rx_flow_key, ipv4); + } + if (v4_m_spec->psrc) { + match->key.tp.src = v4_spec->psrc; + match->mask.tp.src = v4_m_spec->psrc; + } + if (v4_m_spec->pdst) { + match->key.tp.dst = v4_spec->pdst; + match->mask.tp.dst = v4_m_spec->pdst; + } + if (v4_m_spec->psrc || + v4_m_spec->pdst) { + match->dissector.used_keys |= FLOW_DISSECTOR_KEY_PORTS; + match->dissector.offset[FLOW_DISSECTOR_KEY_PORTS] = + offsetof(struct ethtool_rx_flow_key, tp); + } + if (v4_m_spec->tos) { + match->key.ip.tos = v4_spec->pdst; + match->mask.ip.tos = v4_m_spec->pdst; + match->dissector.used_keys |= FLOW_DISSECTOR_KEY_IP; + match->dissector.offset[FLOW_DISSECTOR_KEY_IP] = + offsetof(struct ethtool_rx_flow_key, ip); + } + } + break; + case TCP_V6_FLOW: + case UDP_V6_FLOW: { + const struct ethtool_tcpip6_spec *v6_spec, *v6_m_spec; + + match->key.basic.n_proto = htons(ETH_P_IPV6); + + v6_spec = &fs->h_u.tcp_ip6_spec; + v6_m_spec = &fs->m_u.tcp_ip6_spec; + if (memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr))) { + memcpy(&match->key.ipv6.src, v6_spec->ip6src, + sizeof(match->key.ipv6.src)); + memcpy(&match->mask.ipv6.src, v6_m_spec->ip6src, + sizeof(match->mask.ipv6.src)); + } + if (memcmp(v6_m_spec->ip6dst, &zero_addr, sizeof(zero_addr))) { + memcpy(&match->key.ipv6.dst, v6_spec->ip6dst, + sizeof(match->key.ipv6.dst)); + memcpy(&match->mask.ipv6.dst, v6_m_spec->ip6dst, + sizeof(match->mask.ipv6.dst)); + } + if (memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr)) || + memcmp(v6_m_spec->ip6src, &zero_addr, sizeof(zero_addr))) { + match->dissector.used_keys |= + FLOW_DISSECTOR_KEY_IPV6_ADDRS; + match->dissector.offset[FLOW_DISSECTOR_KEY_IPV6_ADDRS] = + offsetof(struct ethtool_rx_flow_key, ipv6); + } + if (v6_m_spec->psrc) { + match->key.tp.src = v6_spec->psrc; + match->mask.tp.src = v6_m_spec->psrc; + } + if (v6_m_spec->pdst) { + match->key.tp.dst = v6_spec->pdst; + match->mask.tp.dst = v6_m_spec->pdst; + } + if (v6_m_spec->psrc || + v6_m_spec->pdst) { + match->dissector.used_keys |= FLOW_DISSECTOR_KEY_PORTS; + match->dissector.offset[FLOW_DISSECTOR_KEY_PORTS] = + offsetof(struct ethtool_rx_flow_key, tp); + } + if (v6_m_spec->tclass) { + match->key.ip.tos = v6_spec->tclass; + match->mask.ip.tos = v6_m_spec->tclass; + match->dissector.used_keys |= FLOW_DISSECTOR_KEY_IP; + match->dissector.offset[FLOW_DISSECTOR_KEY_IP] = + offsetof(struct ethtool_rx_flow_key, ip); + } + } + break; + } + + switch (fs->flow_type & ~FLOW_EXT) { + case TCP_V4_FLOW: + case TCP_V6_FLOW: + match->key.basic.ip_proto = IPPROTO_TCP; + break; + case UDP_V4_FLOW: + case UDP_V6_FLOW: + match->key.basic.ip_proto = IPPROTO_UDP; + break; + } + match->mask.basic.ip_proto = 0xff; + + match->dissector.used_keys |= FLOW_DISSECTOR_KEY_BASIC; + match->dissector.offset[FLOW_DISSECTOR_KEY_BASIC] = + offsetof(struct ethtool_rx_flow_key, basic); + + /* ethtool_rx supports only one single action per rule. */ + if (flow_action_init(&rule->action, 1) < 0) + goto err_action; + + act = &rule->action.keys[0]; + switch (fs->ring_cookie) { + case RX_CLS_FLOW_DISC: + act->id = FLOW_ACTION_KEY_DROP; + break; + case RX_CLS_FLOW_WAKE: + act->id = FLOW_ACTION_KEY_WAKE; + break; + default: + act->id = FLOW_ACTION_KEY_QUEUE; + act->queue_index = fs->ring_cookie; + break; + } + + return rule; + +err_action: + kfree(match); +err_match: + kfree(rule); + return NULL; +} +EXPORT_SYMBOL(ethtool_rx_flow_rule); + +void ethtool_rx_flow_rule_free(struct flow_rule *rule) +{ + kfree((struct flow_match *)rule->match.dissector); + flow_action_free(&rule->action); + kfree(rule); +} +EXPORT_SYMBOL(ethtool_rx_flow_rule_free); + /** * skb_flow_get_be16 - extract be16 entity * @skb: sk_buff to extract from -- 2.11.0