net: Add full IPv6 addresses to flow_keys

This patch adds full IPv6 addresses into flow_keys and uses them as
input to the flow hash function. The implementation supports either
IPv4 or IPv6 addresses in a union, and selector is used to determine
how may words to input to jhash2.

We also add flow_get_u32_dst and flow_get_u32_src functions which are
used to get a u32 representation of the source and destination
addresses. For IPv6, ipv6_addr_hash is called. These functions retain
getting the legacy values of src and dst in flow_keys.

With this patch, Ethertype and IP protocol are now included in the
flow hash input.

Signed-off-by: Tom Herbert <tom@herbertland.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

4 files changed, 114 insertions, 29 deletions

diff --git a/net/core/flow_dissector.c b/net/core/flow_dissector.c
index 55b5f2962afa..ca9d22488cfb 100644
--- a/net/core/flow_dissector.c
+++ b/net/core/flow_dissector.c
@@ -178,10 +178,12 @@ ip:
                 if (!skb_flow_dissector_uses_key(flow_dissector,
                                                  FLOW_DISSECTOR_KEY_IPV4_ADDRS))
                         break;
+
                 key_addrs = skb_flow_dissector_target(flow_dissector,
-                                                      FLOW_DISSECTOR_KEY_IPV4_ADDRS,
-                                                      target_container);
-                memcpy(key_addrs, &iph->saddr, sizeof(*key_addrs));
+                              FLOW_DISSECTOR_KEY_IPV4_ADDRS, target_container);
+                memcpy(&key_addrs->v4addrs, &iph->saddr,
+                       sizeof(key_addrs->v4addrs));
+                key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
                 break;
         }
         case htons(ETH_P_IPV6): {
@@ -203,8 +205,11 @@ ipv6:
                                                               FLOW_DISSECTOR_KEY_IPV6_HASH_ADDRS,
                                                               target_container);
 
-                        key_addrs->src = (__force __be32)ipv6_addr_hash(&iph->saddr);
-                        key_addrs->dst = (__force __be32)ipv6_addr_hash(&iph->daddr);
+                        key_addrs->v4addrs.src =
+                                (__force __be32)ipv6_addr_hash(&iph->saddr);
+                        key_addrs->v4addrs.dst =
+                                (__force __be32)ipv6_addr_hash(&iph->daddr);
+                        key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
                         goto flow_label;
                 }
                 if (skb_flow_dissector_uses_key(flow_dissector,
@@ -216,6 +221,7 @@ ipv6:
                                                                    target_container);
 
                         memcpy(key_ipv6_addrs, &iph->saddr, sizeof(*key_ipv6_addrs));
+                        key_control->addr_type = FLOW_DISSECTOR_KEY_IPV6_ADDRS;
                         goto flow_label;
                 }
                 break;
@@ -292,8 +298,9 @@ flow_label:
                         key_addrs = skb_flow_dissector_target(flow_dissector,
                                                               FLOW_DISSECTOR_KEY_IPV6_HASH_ADDRS,
                                                               target_container);
-                        key_addrs->src = hdr->srcnode;
-                        key_addrs->dst = 0;
+                        key_addrs->v4addrs.src = hdr->srcnode;
+                        key_addrs->v4addrs.dst = 0;
+                        key_control->addr_type = FLOW_DISSECTOR_KEY_IPV4_ADDRS;
                 }
                 return true;
         }
@@ -389,21 +396,88 @@ static inline void *flow_keys_hash_start(struct flow_keys *flow)
 
 static inline size_t flow_keys_hash_length(struct flow_keys *flow)
 {
+        size_t diff = FLOW_KEYS_HASH_OFFSET + sizeof(flow->addrs);
         BUILD_BUG_ON((sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) % sizeof(u32));
-        return (sizeof(*flow) - FLOW_KEYS_HASH_OFFSET) / sizeof(u32);
+        BUILD_BUG_ON(offsetof(typeof(*flow), addrs) !=
+                     sizeof(*flow) - sizeof(flow->addrs));
+
+        switch (flow->control.addr_type) {
+        case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
+                diff -= sizeof(flow->addrs.v4addrs);
+                break;
+        case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
+                diff -= sizeof(flow->addrs.v6addrs);
+                break;
+        }
+        return (sizeof(*flow) - diff) / sizeof(u32);
+}
+
+__be32 flow_get_u32_src(const struct flow_keys *flow)
+{
+        switch (flow->control.addr_type) {
+        case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
+                return flow->addrs.v4addrs.src;
+        case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
+                return (__force __be32)ipv6_addr_hash(
+                        &flow->addrs.v6addrs.src);
+        default:
+                return 0;
+        }
+}
+EXPORT_SYMBOL(flow_get_u32_src);
+
+__be32 flow_get_u32_dst(const struct flow_keys *flow)
+{
+        switch (flow->control.addr_type) {
+        case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
+                return flow->addrs.v4addrs.dst;
+        case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
+                return (__force __be32)ipv6_addr_hash(
+                        &flow->addrs.v6addrs.dst);
+        default:
+                return 0;
+        }
+}
+EXPORT_SYMBOL(flow_get_u32_dst);
+
+static inline void __flow_hash_consistentify(struct flow_keys *keys)
+{
+        int addr_diff, i;
+
+        switch (keys->control.addr_type) {
+        case FLOW_DISSECTOR_KEY_IPV4_ADDRS:
+                addr_diff = (__force u32)keys->addrs.v4addrs.dst -
+                            (__force u32)keys->addrs.v4addrs.src;
+                if ((addr_diff < 0) ||
+                    (addr_diff == 0 &&
+                     ((__force u16)keys->ports.dst <
+                      (__force u16)keys->ports.src))) {
+                        swap(keys->addrs.v4addrs.src, keys->addrs.v4addrs.dst);
+                        swap(keys->ports.src, keys->ports.dst);
+                }
+                break;
+        case FLOW_DISSECTOR_KEY_IPV6_ADDRS:
+                addr_diff = memcmp(&keys->addrs.v6addrs.dst,
+                                   &keys->addrs.v6addrs.src,
+                                   sizeof(keys->addrs.v6addrs.dst));
+                if ((addr_diff < 0) ||
+                    (addr_diff == 0 &&
+                     ((__force u16)keys->ports.dst <
+                      (__force u16)keys->ports.src))) {
+                        for (i = 0; i < 4; i++)
+                                swap(keys->addrs.v6addrs.src.s6_addr32[i],
+                                     keys->addrs.v6addrs.dst.s6_addr32[i]);
+                        swap(keys->ports.src, keys->ports.dst);
+                }
+                break;
+        }
 }
 
 static inline u32 __flow_hash_from_keys(struct flow_keys *keys, u32 keyval)
 {
         u32 hash;
 
-        /* get a consistent hash (same value on both flow directions) */
-        if (((__force u32)keys->addrs.dst < (__force u32)keys->addrs.src) ||
-            (((__force u32)keys->addrs.dst == (__force u32)keys->addrs.src) &&
-             ((__force u16)keys->ports.dst < (__force u16)keys->ports.src))) {
-                swap(keys->addrs.dst, keys->addrs.src);
-                swap(keys->ports.src, keys->ports.dst);
-        }
+        __flow_hash_consistentify(keys);
 
         hash = __flow_hash_words((u32 *)flow_keys_hash_start(keys),
                                  flow_keys_hash_length(keys), keyval);
@@ -451,8 +525,8 @@ void make_flow_keys_digest(struct flow_keys_digest *digest,
         data->n_proto = flow->basic.n_proto;
         data->ip_proto = flow->basic.ip_proto;
         data->ports = flow->ports.ports;
-        data->src = flow->addrs.src;
-        data->dst = flow->addrs.dst;
+        data->src = flow->addrs.v4addrs.src;
+        data->dst = flow->addrs.v4addrs.dst;
 }
 EXPORT_SYMBOL(make_flow_keys_digest);
 
@@ -566,11 +640,15 @@ static const struct flow_dissector_key flow_keys_dissector_keys[] = {
         },
         {
                 .key_id = FLOW_DISSECTOR_KEY_IPV4_ADDRS,
-                .offset = offsetof(struct flow_keys, addrs),
+                .offset = offsetof(struct flow_keys, addrs.v4addrs),
+        },
+        {
+                .key_id = FLOW_DISSECTOR_KEY_IPV6_ADDRS,
+                .offset = offsetof(struct flow_keys, addrs.v6addrs),
         },
         {
                 .key_id = FLOW_DISSECTOR_KEY_IPV6_HASH_ADDRS,
-                .offset = offsetof(struct flow_keys, addrs),
+                .offset = offsetof(struct flow_keys, addrs.v4addrs),
         },
         {
                 .key_id = FLOW_DISSECTOR_KEY_PORTS,
diff --git a/net/ethernet/eth.c b/net/ethernet/eth.c
index 7d0e239a6755..77e0f0e7a88e 100644
--- a/net/ethernet/eth.c
+++ b/net/ethernet/eth.c
@@ -133,7 +133,7 @@ u32 eth_get_headlen(void *data, unsigned int len)
         /* parse any remaining L2/L3 headers, check for L4 */
         if (!skb_flow_dissect_flow_keys_buf(&keys, data, eth->h_proto,
                                             sizeof(*eth), len))
-                return max_t(u32, keys.basic.thoff, sizeof(*eth));
+                return max_t(u32, keys.control.thoff, sizeof(*eth));
 
         /* parse for any L4 headers */
         return min_t(u32, __skb_get_poff(NULL, data, &keys, len), len);
diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index b4359924846c..76bc3a20ffdb 100644
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -68,15 +68,21 @@ static inline u32 addr_fold(void *addr)
 
 static u32 flow_get_src(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-        if (flow->addrs.src)
-                return ntohl(flow->addrs.src);
+        __be32 src = flow_get_u32_src(flow);
+
+        if (src)
+                return ntohl(src);
+
         return addr_fold(skb->sk);
 }
 
 static u32 flow_get_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-        if (flow->addrs.dst)
-                return ntohl(flow->addrs.dst);
+        __be32 dst = flow_get_u32_dst(flow);
+
+        if (dst)
+                return ntohl(dst);
+
         return addr_fold(skb_dst(skb)) ^ (__force u16) tc_skb_protocol(skb);
 }
 
diff --git a/net/sched/cls_flower.c b/net/sched/cls_flower.c
index 5a7d66c59684..b92d3f49c23e 100644
--- a/net/sched/cls_flower.c
+++ b/net/sched/cls_flower.c
@@ -28,8 +28,9 @@ struct fl_flow_key {
         struct flow_dissector_key_control control;
         struct flow_dissector_key_basic basic;
         struct flow_dissector_key_eth_addrs eth;
+        struct flow_dissector_key_addrs ipaddrs;
         union {
-                struct flow_dissector_key_addrs ipv4;
+                struct flow_dissector_key_ipv4_addrs ipv4;
                 struct flow_dissector_key_ipv6_addrs ipv6;
         };
         struct flow_dissector_key_ports tp;
@@ -260,14 +261,14 @@ static int fl_set_key(struct net *net, struct nlattr **tb,
                                &mask->basic.ip_proto, TCA_FLOWER_UNSPEC,
                                sizeof(key->basic.ip_proto));
         }
-        if (key->basic.n_proto == htons(ETH_P_IP)) {
+        if (key->control.addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS) {
                 fl_set_key_val(tb, &key->ipv4.src, TCA_FLOWER_KEY_IPV4_SRC,
                                &mask->ipv4.src, TCA_FLOWER_KEY_IPV4_SRC_MASK,
                                sizeof(key->ipv4.src));
                 fl_set_key_val(tb, &key->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST,
                                &mask->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST_MASK,
                                sizeof(key->ipv4.dst));
-        } else if (key->basic.n_proto == htons(ETH_P_IPV6)) {
+        } else if (key->control.addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS) {
                 fl_set_key_val(tb, &key->ipv6.src, TCA_FLOWER_KEY_IPV6_SRC,
                                &mask->ipv6.src, TCA_FLOWER_KEY_IPV6_SRC_MASK,
                                sizeof(key->ipv6.src));
@@ -610,7 +611,7 @@ static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
                             sizeof(key->basic.ip_proto)))
                 goto nla_put_failure;
 
-        if (key->basic.n_proto == htons(ETH_P_IP) &&
+        if (key->control.addr_type == FLOW_DISSECTOR_KEY_IPV4_ADDRS &&
             (fl_dump_key_val(skb, &key->ipv4.src, TCA_FLOWER_KEY_IPV4_SRC,
                              &mask->ipv4.src, TCA_FLOWER_KEY_IPV4_SRC_MASK,
                              sizeof(key->ipv4.src)) ||
@@ -618,7 +619,7 @@ static int fl_dump(struct net *net, struct tcf_proto *tp, unsigned long fh,
                              &mask->ipv4.dst, TCA_FLOWER_KEY_IPV4_DST_MASK,
                              sizeof(key->ipv4.dst))))
                 goto nla_put_failure;
-        else if (key->basic.n_proto == htons(ETH_P_IPV6) &&
+        else if (key->control.addr_type == FLOW_DISSECTOR_KEY_IPV6_ADDRS &&
                  (fl_dump_key_val(skb, &key->ipv6.src, TCA_FLOWER_KEY_IPV6_SRC,
                                   &mask->ipv6.src, TCA_FLOWER_KEY_IPV6_SRC_MASK,
                                   sizeof(key->ipv6.src)) ||