Merge branch 'flow-dissector-features'

Tom Herbert says:

====================
flow_dissector: Paramterize dissection and other features

This patch set adds some new capabilities to flow_dissector:

- Add flags to flow dissector functions to control dissection
  - Flag to stop dissection when L3 header is seen (don't
    dissect L4)
  - Flag to stop dissection when encapsulation is detected
  - Flag to parse first fragment of fragmented packet. This
    may provide L4 ports
- Added new reporting in key_control
  - Packet is a fragment
  - Packet is a first fragment
  - Packet has encapsulation

Also:
  - Make __skb_set_sw_hash a general function
  - Create functions to get a flow hash based on flowi4 or flowi6
    structures without an reference to an skbuff
  - Ignore flow dissector return value from ___skb_get_hash. Just
    use whatever key fields are found to make a hash

Tested:

Ran 200 netperf TCP_RR instances for IPv6 and IPv4. Did not see any
regression. Ran UDP_RR with 10000 byte request and response size
for IPv4 and IPv6, no regression observed however I did see better
performance with IPv6 flow labels due to use of flow labels for L4
hash.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

12 files changed, 267 insertions, 128 deletions

diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 06e2d01f0b4e..771a449d2f56 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3095,7 +3095,7 @@ static bool bond_flow_dissect(struct bonding *bond, struct sk_buff *skb,
         int noff, proto = -1;
 
         if (bond->params.xmit_policy > BOND_XMIT_POLICY_LAYER23)
-                return skb_flow_dissect_flow_keys(skb, fk);
+                return skb_flow_dissect_flow_keys(skb, fk, 0);
 
         fk->ports.ports = 0;
         noff = skb_network_offset(skb);
diff --git a/drivers/net/ethernet/cisco/enic/enic_clsf.c b/drivers/net/ethernet/cisco/enic/enic_clsf.c
index d106186f4f4a..3c677ed3c29e 100644
--- a/drivers/net/ethernet/cisco/enic/enic_clsf.c
+++ b/drivers/net/ethernet/cisco/enic/enic_clsf.c
@@ -177,7 +177,7 @@ int enic_rx_flow_steer(struct net_device *dev, const struct sk_buff *skb,
         int res, i;
 
         enic = netdev_priv(dev);
-        res = skb_flow_dissect_flow_keys(skb, &keys);
+        res = skb_flow_dissect_flow_keys(skb, &keys, 0);
         if (!res || keys.basic.n_proto != htons(ETH_P_IP) ||
             (keys.basic.ip_proto != IPPROTO_TCP &&
              keys.basic.ip_proto != IPPROTO_UDP))
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 2990024b90f9..409b48e1e589 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -239,7 +239,7 @@ static bool netvsc_set_hash(u32 *hash, struct sk_buff *skb)
         struct flow_keys flow;
         int data_len;
 
-        if (!skb_flow_dissect_flow_keys(skb, &flow) ||
+        if (!skb_flow_dissect_flow_keys(skb, &flow, 0) ||
             !(flow.basic.n_proto == htons(ETH_P_IP) ||
               flow.basic.n_proto == htons(ETH_P_IPV6)))
                 return false;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 989307f991db..9e62687c70f3 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -937,14 +937,90 @@ enum pkt_hash_types {
         PKT_HASH_TYPE_L4,       /* Input: src_IP, dst_IP, src_port, dst_port */
 };
 
-static inline void
-skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
+static inline void skb_clear_hash(struct sk_buff *skb)
 {
-        skb->l4_hash = (type == PKT_HASH_TYPE_L4);
+        skb->hash = 0;
         skb->sw_hash = 0;
+        skb->l4_hash = 0;
+}
+
+static inline void skb_clear_hash_if_not_l4(struct sk_buff *skb)
+{
+        if (!skb->l4_hash)
+                skb_clear_hash(skb);
+}
+
+static inline void
+__skb_set_hash(struct sk_buff *skb, __u32 hash, bool is_sw, bool is_l4)
+{
+        skb->l4_hash = is_l4;
+        skb->sw_hash = is_sw;
         skb->hash = hash;
 }
 
+static inline void
+skb_set_hash(struct sk_buff *skb, __u32 hash, enum pkt_hash_types type)
+{
+        /* Used by drivers to set hash from HW */
+        __skb_set_hash(skb, hash, false, type == PKT_HASH_TYPE_L4);
+}
+
+static inline void
+__skb_set_sw_hash(struct sk_buff *skb, __u32 hash, bool is_l4)
+{
+        __skb_set_hash(skb, hash, true, is_l4);
+}
+
+void __skb_get_hash(struct sk_buff *skb);
+u32 skb_get_poff(const struct sk_buff *skb);
+u32 __skb_get_poff(const struct sk_buff *skb, void *data,
+                   const struct flow_keys *keys, int hlen);
+__be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
+                            void *data, int hlen_proto);
+
+static inline __be32 skb_flow_get_ports(const struct sk_buff *skb,
+                                        int thoff, u8 ip_proto)
+{
+        return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);
+}
+
+void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
+                             const struct flow_dissector_key *key,
+                             unsigned int key_count);
+
+bool __skb_flow_dissect(const struct sk_buff *skb,
+                        struct flow_dissector *flow_dissector,
+                        void *target_container,
+                        void *data, __be16 proto, int nhoff, int hlen,
+                        unsigned int flags);
+
+static inline bool skb_flow_dissect(const struct sk_buff *skb,
+                                    struct flow_dissector *flow_dissector,
+                                    void *target_container, unsigned int flags)
+{
+        return __skb_flow_dissect(skb, flow_dissector, target_container,
+                                  NULL, 0, 0, 0, flags);
+}
+
+static inline bool skb_flow_dissect_flow_keys(const struct sk_buff *skb,
+                                              struct flow_keys *flow,
+                                              unsigned int flags)
+{
+        memset(flow, 0, sizeof(*flow));
+        return __skb_flow_dissect(skb, &flow_keys_dissector, flow,
+                                  NULL, 0, 0, 0, flags);
+}
+
+static inline bool skb_flow_dissect_flow_keys_buf(struct flow_keys *flow,
+                                                  void *data, __be16 proto,
+                                                  int nhoff, int hlen,
+                                                  unsigned int flags)
+{
+        memset(flow, 0, sizeof(*flow));
+        return __skb_flow_dissect(NULL, &flow_keys_buf_dissector, flow,
+                                  data, proto, nhoff, hlen, flags);
+}
+
 static inline __u32 skb_get_hash(struct sk_buff *skb)
 {
         if (!skb->l4_hash && !skb->sw_hash)
@@ -957,8 +1033,12 @@ __u32 __skb_get_hash_flowi6(struct sk_buff *skb, struct flowi6 *fl6);
 
 static inline __u32 skb_get_hash_flowi6(struct sk_buff *skb, struct flowi6 *fl6)
 {
-        if (!skb->l4_hash && !skb->sw_hash)
-                __skb_get_hash_flowi6(skb, fl6);
+        if (!skb->l4_hash && !skb->sw_hash) {
+                struct flow_keys keys;
+
+                __skb_set_sw_hash(skb, __get_hash_from_flowi6(fl6, &keys),
+                                  flow_keys_have_l4(&keys));
+        }
 
         return skb->hash;
 }
@@ -967,8 +1047,12 @@ __u32 __skb_get_hash_flowi4(struct sk_buff *skb, struct flowi4 *fl);
 
 static inline __u32 skb_get_hash_flowi4(struct sk_buff *skb, struct flowi4 *fl4)
 {
-        if (!skb->l4_hash && !skb->sw_hash)
-                __skb_get_hash_flowi4(skb, fl4);
+        if (!skb->l4_hash && !skb->sw_hash) {
+                struct flow_keys keys;
+
+                __skb_set_sw_hash(skb, __get_hash_from_flowi4(fl4, &keys),
+                                  flow_keys_have_l4(&keys));
+        }
 
         return skb->hash;
 }
@@ -980,19 +1064,6 @@ static inline __u32 skb_get_hash_raw(const struct sk_buff *skb)
         return skb->hash;
 }
 
-static inline void skb_clear_hash(struct sk_buff *skb)
-{
-        skb->hash = 0;
-        skb->sw_hash = 0;
-        skb->l4_hash = 0;
-}
-
-static inline void skb_clear_hash_if_not_l4(struct sk_buff *skb)