cls_flow: use skb_flow_dissect()

Instead of using a custom flow dissector, use skb_flow_dissect() and
benefit from tunnelling support.

This lack of tunnelling support was mentioned by Dan Siemon.

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/sched/cls_flow.c b/net/sched/cls_flow.c
index 7b58230..51ff194 100644 (file)
--- a/net/sched/cls_flow.c
+++ b/net/sched/cls_flow.c
@@ -26,6 +26,8 @@
 #include <net/pkt_cls.h>
 #include <net/ip.h>
 #include <net/route.h>
+#include <net/flow_keys.h>
+
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 #include <net/netfilter/nf_conntrack.h>
 #endif
@@ -66,134 +68,37 @@ static inline u32 addr_fold(void *addr)
        return (a & 0xFFFFFFFF) ^ (BITS_PER_LONG > 32 ? a >> 32 : 0);
 }
 
-static u32 flow_get_src(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_src(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-       __be32 *data = NULL, hdata;
-
-       switch (skb->protocol) {
-       case htons(ETH_P_IP):
-               data = skb_header_pointer(skb,
-                                         nhoff + offsetof(struct iphdr,
-                                                          saddr),
-                                         4, &hdata);
-               break;
-       case htons(ETH_P_IPV6):
-               data = skb_header_pointer(skb,
-                                        nhoff + offsetof(struct ipv6hdr,
-                                                         saddr.s6_addr32[3]),
-                                        4, &hdata);
-               break;
-       }
-
-       if (data)
-               return ntohl(*data);
+       if (flow->src)
+               return ntohl(flow->src);
        return addr_fold(skb->sk);
 }
 
-static u32 flow_get_dst(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-       __be32 *data = NULL, hdata;
-
-       switch (skb->protocol) {
-       case htons(ETH_P_IP):
-               data = skb_header_pointer(skb,
-                                         nhoff + offsetof(struct iphdr,
-                                                          daddr),
-                                         4, &hdata);
-               break;
-       case htons(ETH_P_IPV6):
-               data = skb_header_pointer(skb,
-                                        nhoff + offsetof(struct ipv6hdr,
-                                                         daddr.s6_addr32[3]),
-                                        4, &hdata);
-               break;
-       }
-
-       if (data)
-               return ntohl(*data);
+       if (flow->dst)
+               return ntohl(flow->dst);
        return addr_fold(skb_dst(skb)) ^ (__force u16)skb->protocol;
 }
 
-static u32 flow_get_proto(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_proto(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-       __u8 *data = NULL, hdata;
-
-       switch (skb->protocol) {
-       case htons(ETH_P_IP):
-               data = skb_header_pointer(skb,
-                                         nhoff + offsetof(struct iphdr,
-                                                          protocol),
-                                         1, &hdata);
-               break;
-       case htons(ETH_P_IPV6):
-               data = skb_header_pointer(skb,
-                                        nhoff + offsetof(struct ipv6hdr,
-                                                         nexthdr),
-                                        1, &hdata);
-               break;
-       }
-       if (data)
-               return *data;
-       return 0;
+       return flow->ip_proto;
 }
 
-/* helper function to get either src or dst port */
-static __be16 *flow_get_proto_common(const struct sk_buff *skb, int nhoff,
-                                    __be16 *_port, int dst)
+static u32 flow_get_proto_src(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-       __be16 *port = NULL;
-       int poff;
-
-       switch (skb->protocol) {
-       case htons(ETH_P_IP): {
-               struct iphdr *iph, _iph;
-
-               iph = skb_header_pointer(skb, nhoff, sizeof(_iph), &_iph);
-               if (!iph)
-                       break;
-               if (ip_is_fragment(iph))
-                       break;
-               poff = proto_ports_offset(iph->protocol);
-               if (poff >= 0)
-                       port = skb_header_pointer(skb,
-                                       nhoff + iph->ihl * 4 + poff + dst,
-                                       sizeof(*_port), _port);
-               break;
-       }
-       case htons(ETH_P_IPV6): {
-               struct ipv6hdr *iph, _iph;
-
-               iph = skb_header_pointer(skb, nhoff, sizeof(_iph), &_iph);
-               if (!iph)
-                       break;
-               poff = proto_ports_offset(iph->nexthdr);
-               if (poff >= 0)
-                       port = skb_header_pointer(skb,
-                                       nhoff + sizeof(*iph) + poff + dst,
-                                       sizeof(*_port), _port);
-               break;
-       }
-       }
-
-       return port;
-}
-
-static u32 flow_get_proto_src(const struct sk_buff *skb, int nhoff)
-{
-       __be16 _port, *port = flow_get_proto_common(skb, nhoff, &_port, 0);
-
-       if (port)
-               return ntohs(*port);
+       if (flow->ports)
+               return ntohs(flow->port16[0]);
 
        return addr_fold(skb->sk);
 }
 
-static u32 flow_get_proto_dst(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_proto_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 {
-       __be16 _port, *port = flow_get_proto_common(skb, nhoff, &_port, 2);
-
-       if (port)
-               return ntohs(*port);
+       if (flow->ports)
+               return ntohs(flow->port16[1]);
 
        return addr_fold(skb_dst(skb)) ^ (__force u16)skb->protocol;
 }
@@ -239,7 +144,7 @@ static u32 flow_get_nfct(const struct sk_buff *skb)
 })
 #endif
 
-static u32 flow_get_nfct_src(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_nfct_src(const struct sk_buff *skb, const struct flow_keys *flow)
 {
        switch (skb->protocol) {
        case htons(ETH_P_IP):
@@ -248,10 +153,10 @@ static u32 flow_get_nfct_src(const struct sk_buff *skb, int nhoff)
                return ntohl(CTTUPLE(skb, src.u3.ip6[3]));
        }
 fallback:
-       return flow_get_src(skb, nhoff);
+       return flow_get_src(skb, flow);
 }
 
-static u32 flow_get_nfct_dst(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_nfct_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 {
        switch (skb->protocol) {
        case htons(ETH_P_IP):
@@ -260,21 +165,21 @@ static u32 flow_get_nfct_dst(const struct sk_buff *skb, int nhoff)
                return ntohl(CTTUPLE(skb, dst.u3.ip6[3]));
        }
 fallback:
-       return flow_get_dst(skb, nhoff);
+       return flow_get_dst(skb, flow);
 }
 
-static u32 flow_get_nfct_proto_src(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_nfct_proto_src(const struct sk_buff *skb, const struct flow_keys *flow)
 {
        return ntohs(CTTUPLE(skb, src.u.all));
 fallback:
-       return flow_get_proto_src(skb, nhoff);
+       return flow_get_proto_src(skb, flow);
 }
 
-static u32 flow_get_nfct_proto_dst(const struct sk_buff *skb, int nhoff)
+static u32 flow_get_nfct_proto_dst(const struct sk_buff *skb, const struct flow_keys *flow)
 {
        return ntohs(CTTUPLE(skb, dst.u.all));
 fallback:
-       return flow_get_proto_dst(skb, nhoff);
+       return flow_get_proto_dst(skb, flow);
 }
 
 static u32 flow_get_rtclassid(const struct sk_buff *skb)
@@ -314,21 +219,19 @@ static u32 flow_get_rxhash(struct sk_buff *skb)
        return skb_get_rxhash(skb);
 }
 
-static u32 flow_key_get(struct sk_buff *skb, int key)
+static u32 flow_key_get(struct sk_buff *skb, int key, struct flow_keys *flow)
 {
-       int nhoff = skb_network_offset(skb);
-
        switch (key) {
        case FLOW_KEY_SRC:
-               return flow_get_src(skb, nhoff);
+               return flow_get_src(skb, flow);
        case FLOW_KEY_DST:
-               return flow_get_dst(skb, nhoff);
+               return flow_get_dst(skb, flow);
        case FLOW_KEY_PROTO:
-               return flow_get_proto(skb, nhoff);
+               return flow_get_proto(skb, flow);
        case FLOW_KEY_PROTO_SRC:
-               return flow_get_proto_src(skb, nhoff);
+               return flow_get_proto_src(skb, flow);
        case FLOW_KEY_PROTO_DST:
-               return flow_get_proto_dst(skb, nhoff);
+               return flow_get_proto_dst(skb, flow);
        case FLOW_KEY_IIF:
                return flow_get_iif(skb);
        case FLOW_KEY_PRIORITY:
@@ -338,13 +241,13 @@ static u32 flow_key_get(struct sk_buff *skb, int key)
        case FLOW_KEY_NFCT:
                return flow_get_nfct(skb);
        case FLOW_KEY_NFCT_SRC:
-               return flow_get_nfct_src(skb, nhoff);
+               return flow_get_nfct_src(skb, flow);
        case FLOW_KEY_NFCT_DST:
-               return flow_get_nfct_dst(skb, nhoff);
+               return flow_get_nfct_dst(skb, flow);
        case FLOW_KEY_NFCT_PROTO_SRC:
-               return flow_get_nfct_proto_src(skb, nhoff);
+               return flow_get_nfct_proto_src(skb, flow);
        case FLOW_KEY_NFCT_PROTO_DST:
-               return flow_get_nfct_proto_dst(skb, nhoff);
+               return flow_get_nfct_proto_dst(skb, flow);
        case FLOW_KEY_RTCLASSID:
                return flow_get_rtclassid(skb);
        case FLOW_KEY_SKUID:
@@ -361,6 +264,16 @@ static u32 flow_key_get(struct sk_buff *skb, int key)
        }
 }
 
+#define FLOW_KEYS_NEEDED ((1 << FLOW_KEY_SRC) |                \
+                         (1 << FLOW_KEY_DST) |                 \
+                         (1 << FLOW_KEY_PROTO) |               \
+                         (1 << FLOW_KEY_PROTO_SRC) |           \
+                         (1 << FLOW_KEY_PROTO_DST) |           \
+                         (1 << FLOW_KEY_NFCT_SRC) |            \
+                         (1 << FLOW_KEY_NFCT_DST) |            \
+                         (1 << FLOW_KEY_NFCT_PROTO_SRC) |      \
+                         (1 << FLOW_KEY_NFCT_PROTO_DST))
+
 static int flow_classify(struct sk_buff *skb, const struct tcf_proto *tp,
                         struct tcf_result *res)
 {
@@ -373,16 +286,19 @@ static int flow_classify(struct sk_buff *skb, const struct tcf_proto *tp,
 
        list_for_each_entry(f, &head->filters, list) {
                u32 keys[f->nkeys];
+               struct flow_keys flow_keys;
 
                if (!tcf_em_tree_match(skb, &f->ematches, NULL))
                        continue;
 
                keymask = f->keymask;
+               if (keymask & FLOW_KEYS_NEEDED)
+                       skb_flow_dissect(skb, &flow_keys);
 
                for (n = 0; n < f->nkeys; n++) {
                        key = ffs(keymask) - 1;
                        keymask &= ~(1 << key);
-                       keys[n] = flow_key_get(skb, key);
+                       keys[n] = flow_key_get(skb, key, &flow_keys);
                }
 
                if (f->mode == FLOW_MODE_HASH)