openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

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>
This commit is contained in:
Eric Dumazet 2011-11-28 05:24:18 +00:00 committed by David S. Miller
parent 4504b8613b
commit 6bd2a9af17
1 changed files with 48 additions and 132 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
net/sched/cls_flow.c
View File

@ -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)