netfilter: flowtable bridge and vlan enhancements
Subsystems (5)
Pablo Neira Ayuso
maintainerv4 cover netfilter: flowtable bridge and vlan enhancements
Hi,
The following patchset augments the Netfilter flowtable fastpath [1] to support for network topologies that combine IP forwarding, bridge and VLAN devices.
This v4 includes updates for Patches:
- Patch #3 Check for possible device stack overflow in dev_fill_forward_path(), per Jakub Kicinski.
- Patch #3 Remove memset for the net_device_path_ctx structure in dev_fill_forward_path() and avoid full memset of struct net_device_path_stack.
- Patch #5 Check for valid bridge dst pointer after READ_ONCE, per Nikolay Aleksandrov.
- Patch #6 remove initialization of the net_device_path_ctx structure, already done from patch #3.
A typical scenario that can benefit from this infrastructure is composed of several VMs connected to bridge ports where the bridge master device 'br0' has an IP address. A DHCP server is also assumed to be running to provide connectivity to the VMs. The VMs reach the Internet through 'br0' as default gateway, which makes the packet enter the IP forwarding path. Then, netfilter is used to NAT the packets before they leave through the wan device.
Something like this:
fast path
.------------------------.
/ \
| IP forwarding |
| / \ .
| br0 eth0
. / \
-- veth1 veth2
.
.
.
eth0
ab:cd:ef:ab:cd:ef
VMThe idea is to accelerate forwarding by building a fast path that takes packets from the ingress path of the bridge port and place them in the egress path of the wan device (and vice versa). Hence, skipping the classic bridge and IP stack paths.
This patchset is composed of:
Patch #1 adds a placeholder for the hash calculation, instead of using
the dir field.
Patch #2 adds the transmit path type field to the flow tuple. Two transmit
paths are supported so far: the neighbour and the xfrm transmit paths. This patch comes in preparation to add a new direct ethernet transmit path (see patch #7).
Patch #3 adds dev_fill_forward_path() and .ndo_fill_forward_path() to
netdev_ops. This new function describes the list of netdevice hops
to reach a given destination MAC address in the local network topology,
e.g.
IP forwarding
/ \
br0 eth0
/ \
veth1 veth2
.
.
.
eth0
ab:cd:ef:ab:cd:ef
where veth1 and veth2 are bridge ports and eth0 provides Internet
connectivity. eth0 is the interface in the VM which is connected to
the veth1 bridge port. Then, for packets going to br0 whose
destination MAC address is ab:cd:ef:ab:cd:ef, dev_fill_forward_path()
provides the following path: br0 -> veth1.Patch #4 adds .ndo_fill_forward_path for VLAN devices, which provides the next
device hop via vlan->real_dev. This annotates the VLAN id and protocol. This is useful to know what VLAN headers are expected from the ingress device. This also provides information regarding the VLAN headers to be pushed in the egress path.
Patch #5 adds .ndo_fill_forward_path for bridge devices, which allows to make
lookups to the FDB to locate the next device hop (bridge port) in the forwarding path.
Patch #6 updates the flowtable to use the dev_fill_forward_path()
infrastructure to obtain the ingress device in the fastpath.
Patch #7 updates the flowtable to use dev_fill_forward_path() to obtain the
egress device in the forwarding path. This also adds the direct ethernet transmit path, which pushes the ethernet header to the packet and send it through dev_queue_xmit(). This patch adds support for the bridge, so bridge ports use this direct xmit path.
Patch #8 adds ingress VLAN support (up to 2 VLAN tags, QinQ). The VLAN
information is also provided by dev_fill_forward_path(). Store the VLAN id and protocol in the flow tuple for hash lookups. The VLAN support in the xmit path is achieved by annotating the first vlan device found in the xmit path and by calling dev_hard_header() (previous patch #7) before dev_queue_xmit().
Patch #9 extends nft_flowtable.sh selftest: This is adding a test to
cover bridge and vlan support coming in this patchset.
= Performance numbers
My testbed environment consists of three containers:
192.168.20.2 .20.1 .10.1 10.141.10.2
veth0 veth0 veth1 veth0
ns1 <---------> nsr1 <--------> ns2
SNAT
iperf -c iperf -s
where nsr1 is used for forwarding. There is a bridge device br0 in nsr1, veth0 is a port of br0. SNAT is performed on the veth1 device of nsr1.
- ns2 runs iperf -s
- ns1 runs iperf -c 10.141.10.2 -n 100G
My results are:
- Baseline (no flowtable, classic forwarding path + netfilter): ~16 Gbit/s
- Fastpath (with flowtable, this patchset): ~25 Gbit/s
This is an improvement of ~50% compared to baseline.
Please, apply this patchset.
Thank you.
Pablo Neira Ayuso (9):
netfilter: flowtable: add hash offset field to tuple
netfilter: flowtable: add xmit path types
net: resolve forwarding path from virtual netdevice and HW destination address
net: 8021q: resolve forwarding path for vlan devices
bridge: resolve forwarding path for bridge devices
netfilter: flowtable: use dev_fill_forward_path() to obtain ingress device
netfilter: flowtable: use dev_fill_forward_path() to obtain egress device
netfilter: flowtable: add vlan support
selftests: netfilter: flowtable bridge and VLAN support
include/linux/netdevice.h | 35 +++ include/net/netfilter/nf_flow_table.h | 43 +++- net/8021q/vlan_dev.c | 15 ++ net/bridge/br_device.c | 27 +++ net/core/dev.c | 36 ++++ net/netfilter/nf_flow_table_core.c | 51 +++-- net/netfilter/nf_flow_table_ip.c | 200 ++++++++++++++---- net/netfilter/nft_flow_offload.c | 159 +++++++++++++- .../selftests/netfilter/nft_flowtable.sh | 82 +++++++ 9 files changed, 588 insertions(+), 60 deletions(-)
--
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 1/9 netfilter: flowtable: add hash offset field to tuple
Add a placeholder field to calculate hash tuple offset. Similar to 2c407aca6497 ("netfilter: conntrack: avoid gcc-10 zero-length-bounds warning").
---
v4: no changes
include/net/netfilter/nf_flow_table.h | 4 ++++ net/netfilter/nf_flow_table_core.c | 6 +++--- 2 files changed, 7 insertions(+), 3 deletions(-)
include/net/netfilter/nf_flow_table.h +4 -0
@@ -107,6 +107,10 @@ struct flow_offload_tuple {u8 l3proto;u8 l4proto; + +/* All members above are keys for lookups, see flow_offload_hash(). */ +struct { } __hash; +u8 dir;u16 mtu;
net/netfilter/nf_flow_table_core.c +3 -3
@@ -191,14 +191,14 @@ static u32 flow_offload_hash(const void *data, u32 len, u32 seed) {const struct flow_offload_tuple *tuple = data; -return jhash (tuple, offsetof(struct flow_offload_tuple , dir), seed); +return jhash (tuple, offsetof(struct flow_offload_tuple , __hash), seed); }static u32 flow_offload_hash_obj (const void *data,u32 len,u32 seed) {const struct flow_offload_tuple_rhash *tuplehash = data; -return jhash (&tuplehash->tuple, offsetof(struct flow_offload_tuple , dir), seed); +return jhash (&tuplehash->tuple, offsetof(struct flow_offload_tuple , __hash), seed); } static int flow_offload_hash_cmp(struct rhashtable_compare_arg *arg,
@@ -207,7 +207,7 @@ static int flow_offload_hash_cmp(struct rhashtable_compare_arg *arg,const struct flow_offload_tuple *tuple = arg->key;const struct flow_offload_tuple_rhash *x = ptr; -if (memcmp (&x->tuple, tuple, offsetof(struct flow_offload_tuple , dir))) +if (memcmp (&x->tuple, tuple, offsetof(struct flow_offload_tuple , __hash)))return 1 ;return 0 ;
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 2/9 netfilter: flowtable: add xmit path types
In reply to Pablo Neira AyusoAdd the xmit_type field that defines the two supported xmit paths in the flowtable data plane, which are the neighbour and the xfrm xmit paths. This patch prepares for new flowtable xmit path types to come.
---
v4: no changes
include/net/netfilter/nf_flow_table.h | 11 +++++++-- net/netfilter/nf_flow_table_core.c | 1 + net/netfilter/nf_flow_table_ip.c | 32 ++++++++++++++++++--------- net/netfilter/nft_flow_offload.c | 20 +++++++++++++++-- 4 files changed, 50 insertions(+), 14 deletions(-)
include/net/netfilter/nf_flow_table.h +9 -2
@@ -89,6 +89,11 @@ enum flow_offload_tuple_dir {FLOW_OFFLOAD_DIR_MAX =IP_CT_DIR_MAX }; +enum flow_offload_xmit_type { +FLOW_OFFLOAD_XMIT_NEIGH =0 , +FLOW_OFFLOAD_XMIT_XFRM , +}; + struct flow_offload_tuple { union { struct in_addr src_v4;
@@ -111,7 +116,8 @@ struct flow_offload_tuple {/* All members above are keys for lookups, see flow_offload_hash(). */ struct { } __hash; -u8 dir; + u8 dir:6, + xmit_type:2;u16 mtu;
@@ -158,7 +164,8 @@ static inline __s32 nf_flow_timeout_delta(unsigned int timeout)struct nf_flow_route {struct { -struct dst_entry *dst; +struct dst_entry *dst; +enum flow_offload_xmit_type xmit_type; } tuple[FLOW_OFFLOAD_DIR_MAX ]; };
net/netfilter/nf_flow_table_core.c +1 -0
@@ -95,6 +95,7 @@ static int flow_offload_fill_route(struct flow_offload *flow, } flow_tuple->iifidx = other_dst->dev->ifindex; + flow_tuple->xmit_type = route->tuple[dir].xmit_type; flow_tuple->dst_cache = dst;return 0 ;
net/netfilter/nf_flow_table_ip.c +22 -10
@@ -220,10 +220,20 @@ static bool nf_flow_exceeds_mtu(const struct sk_buff *skb, unsigned int mtu)return true; } -static int nf_flow_offload_dst_check (struct dst_entry *dst) +static inline struct dst_entry * +nft_flow_dst (struct flow_offload_tuple_rhash *tuplehash) { -if (unlikely (dst_xfrm (dst))) +return tuplehash->tuple.dst_cache; +} + +static int nf_flow_offload_dst_check (struct flow_offload_tuple_rhash *tuplehash) +{ +struct dst_entry *dst; + +if (unlikely (tuplehash->tuple.xmit_type ==FLOW_OFFLOAD_XMIT_XFRM )) { + dst =nft_flow_dst (tuplehash);return dst_check (dst,0 ) ?0 :-1 ; + }return 0 ; }
@@ -265,8 +275,6 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb, dir = tuplehash->tuple.dir; flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]); - rt = (struct rtable *)flow->tuplehash[dir].tuple.dst_cache; - outdev = rt->dst.dev;if (unlikely (nf_flow_exceeds_mtu (skb, flow->tuplehash[dir].tuple.mtu)))return NF_ACCEPT ;
@@ -280,7 +288,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,flow_offload_refresh (flow_table, flow); -if (nf_flow_offload_dst_check (&rt->dst)) { +if (nf_flow_offload_dst_check (tuplehash)) {flow_offload_teardown (flow);return NF_ACCEPT ; }
@@ -295,13 +303,16 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,if (flow_table->flags &NF_FLOWTABLE_COUNTER )nf_ct_acct_update (flow->ct, tuplehash->tuple.dir, skb->len); -if (unlikely (dst_xfrm (&rt->dst))) { + rt = (struct rtable *)tuplehash->tuple.dst_cache; + +if (unlikely (tuplehash->tuple.xmit_type ==FLOW_OFFLOAD_XMIT_XFRM )) {memset (skb->cb,0 ,sizeof (struct inet_skb_parm ));IPCB (skb)->iif = skb->dev->ifindex;IPCB (skb)->flags =IPSKB_FORWARDED ;return nf_flow_xmit_xfrm (skb, state, &rt->dst); } + outdev = rt->dst.dev; skb->dev = outdev; nexthop =rt_nexthop (rt, flow->tuplehash[!dir].tuple.src_v4.s_addr);skb_dst_set_noref (skb, &rt->dst);
@@ -506,8 +517,6 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb, dir = tuplehash->tuple.dir; flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]); - rt = (struct rt6_info *)flow->tuplehash[dir].tuple.dst_cache; - outdev = rt->dst.dev;if (unlikely (nf_flow_exceeds_mtu (skb, flow->tuplehash[dir].tuple.mtu)))return NF_ACCEPT ;
@@ -518,7 +527,7 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,flow_offload_refresh (flow_table, flow); -if (nf_flow_offload_dst_check (&rt->dst)) { +if (nf_flow_offload_dst_check (tuplehash)) {flow_offload_teardown (flow);return NF_ACCEPT ; }
@@ -536,13 +545,16 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,if (flow_table->flags &NF_FLOWTABLE_COUNTER )nf_ct_acct_update (flow->ct, tuplehash->tuple.dir, skb->len); -if (unlikely (dst_xfrm (&rt->dst))) { + rt = (struct rt6_info *)tuplehash->tuple.dst_cache; + +if (unlikely (tuplehash->tuple.xmit_type ==FLOW_OFFLOAD_XMIT_NEIGH )) {memset (skb->cb,0 ,sizeof (struct inet6_skb_parm ));IP6CB (skb)->iif = skb->dev->ifindex;IP6CB (skb)->flags =IP6SKB_FORWARDED ;return nf_flow_xmit_xfrm (skb, state, &rt->dst); } + outdev = rt->dst.dev; skb->dev = outdev; nexthop =rt6_nexthop (rt, &flow->tuplehash[!dir].tuple.src_v6);skb_dst_set_noref (skb, &rt->dst);
net/netfilter/nft_flow_offload.c +18 -2
@@ -19,6 +19,22 @@ struct nft_flow_offload {struct nft_flowtable *flowtable; }; +static enum flow_offload_xmit_type nft_xmit_type (struct dst_entry *dst) +{ +if (dst_xfrm (dst)) +return FLOW_OFFLOAD_XMIT_XFRM ; + +return FLOW_OFFLOAD_XMIT_NEIGH ; +} + +static void nft_default_forward_path (struct nf_flow_route *route, +struct dst_entry *dst_cache, +enum ip_conntrack_dir dir) +{ + route->tuple[dir].dst = dst_cache; + route->tuple[dir].xmit_type =nft_xmit_type (dst_cache); +} + static int nft_flow_route(const struct nft_pktinfo *pkt, const struct nf_conn *ct, struct nf_flow_route *route,
@@ -44,8 +60,8 @@ static int nft_flow_route(const struct nft_pktinfo *pkt,if (!other_dst)return -ENOENT ; - route->tuple[dir].dst = this_dst; - route->tuple[!dir].dst = other_dst; +nft_default_forward_path (route, this_dst, dir); +nft_default_forward_path (route, other_dst, !dir);return 0 ; }
Signature · 1 line
2.20.1
Florian Westphal
maintainerRe: [PATCH net-next,v4 2/9] netfilter: flowtable: add xmit path types
Quoted 9 lines · Pablo Neira Ayuso
net/netfilter/nf_flow_table_ip.c +3
-1-if (unlikely (dst_xfrm (&rt->dst))) { + rt = (struct rtable *)tuplehash->tuple.dst_cache; + +if (unlikely (tuplehash->tuple.xmit_type ==FLOW_OFFLOAD_XMIT_XFRM )) {memset (skb->cb,0 ,sizeof (struct inet_skb_parm ));IPCB (skb)->iif = skb->dev->ifindex;IPCB (skb)->flags =IPSKB_FORWARDED ;return nf_flow_xmit_xfrm (skb, state, &rt->dst); }
[..]
Review
Quoted 2 lines
(quoted diff) +2
-0+ + if (unlikely(tuplehash->tuple.xmit_type == FLOW_OFFLOAD_XMIT_NEIGH))
This needs to be XMIT_XFRM too.
Pablo Neira Ayuso
maintainerPATCH v4 3/9 net: resolve forwarding path from virtual netdevice and HW destination address
In reply to Pablo Neira AyusoThis patch adds dev_fill_forward_path() which resolves the path to reach the real netdevice from the IP forwarding side. This function takes as input the netdevice and the destination hardware address and it walks down the devices calling .ndo_fill_forward_path() for each device until the real device is found.
For instance, assuming the following topology:
IP forwarding
/ \
br0 eth0
/ \
eth1 eth2
.
.
.
ethXab:cd:ef:ab:cd:ef
where eth1 and eth2 are bridge ports and eth0 provides WAN connectivity. ethX is the interface in another box which is connected to the eth1 bridge port.
For packets going through IP forwarding to br0 whose destination MAC address is ab:cd:ef:ab:cd:ef, dev_fill_forward_path() provides the following path:
br0 -> eth1
.ndo_fill_forward_path for br0 looks up at the FDB for the bridge port from the destination MAC address to get the bridge port eth1.
This information allows to create a fast path that bypasses the classic bridge and IP forwarding paths, so packets go directly from the bridge port eth1 to eth0 (wan interface) and vice versa.
fast path
.------------------------.
/ \
| IP forwarding |
| / \ \/
| br0 eth0
. / \
-> eth1 eth2
.
.
.
ethXab:cd:ef:ab:cd:ef
---
v4: - Check for possible device stack overflow in dev_fill_forward_path(),
per Jakub Kicinski.
- Remove memset for the net_device_path_ctx structure in dev_fill_forward_path() and avoid full memset of struct net_device_path_stack.
include/linux/netdevice.h | 27 +++++++++++++++++++++++++++ net/core/dev.c | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 63 insertions(+)
include/linux/netdevice.h +27 -0
@@ -833,6 +833,27 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,struct sk_buff *skb, struct net_device *sb_dev); +enum net_device_path_type { +DEV_PATH_ETHERNET =0 , +}; + +struct net_device_path { +enum net_device_path_type type; +const struct net_device *dev; +}; + +#define NET_DEVICE_PATH_STACK_MAX 5 + +struct net_device_path_stack { +int num_paths; +struct net_device_path path[NET_DEVICE_PATH_STACK_MAX ]; +}; + +struct net_device_path_ctx { +const struct net_device *dev; +const u8 *daddr; +}; +enum tc_setup_type {TC_SETUP_QDISC_MQPRIO ,TC_SETUP_CLSU32 ,
@@ -1279,6 +1300,8 @@ struct netdev_net_notifier {* struct net_device *(*ndo_get_peer_dev)(struct net_device *dev); * If a device is paired with a peer device, return the peer instance. * The caller must be under RCU read context. +* int (*ndo_fill_forward_path)(struct net_device_path_ctx *ctx, struct net_device_path *path); +* Get the forwarding path to reach the real device from the HW destination address */ struct net_device_ops {int (*ndo_init)(struct net_device *dev);
@@ -1487,6 +1510,8 @@ struct net_device_ops {int (*ndo_tunnel_ctl)(struct net_device *dev,struct ip_tunnel_parm *p,int cmd);struct net_device * (*ndo_get_peer_dev)(struct net_device *dev); +int (*ndo_fill_forward_path)(struct net_device_path_ctx *ctx, +struct net_device_path *path); };/**
@@ -2824,6 +2849,8 @@ void dev_remove_offload(struct packet_offload *po);int dev_get_iflink (const struct net_device *dev);int dev_fill_metadata_dst (struct net_device *dev,struct sk_buff *skb); +int dev_fill_forward_path (const struct net_device *dev,const u8 *daddr, +struct net_device_path_stack *stack);struct net_device *__dev_get_by_flags (struct net *net,unsigned short flags,unsigned short mask);struct net_device *dev_get_by_name (struct net *net,const char *name);
net/core/dev.c +36 -0
@@ -846,6 +846,42 @@ int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) }EXPORT_SYMBOL_GPL (dev_fill_metadata_dst); +int dev_fill_forward_path (const struct net_device *dev,const u8 *daddr, +struct net_device_path_stack *stack) +{ +const struct net_device *last_dev; +struct net_device_path_ctx ctx = { + .dev = dev, + .daddr = daddr, + }; +struct net_device_path *path; +int ret =0 , k; + + stack->num_paths =0 ; +while (ctx.dev && ctx.dev->netdev_ops->ndo_fill_forward_path) { + last_dev = ctx.dev; + k = stack->num_paths++; +if (WARN_ON_ONCE (k >=NET_DEVICE_PATH_STACK_MAX )) +return -1 ; + + path = &stack->path[k]; +memset (path,0 ,sizeof (struct net_device_path )); + + ret = ctx.dev->netdev_ops->ndo_fill_forward_path (&ctx, path); +if (ret <0 ) +return -1 ; + +if (WARN_ON_ONCE (last_dev == ctx.dev)) +return -1 ; + } + path = &stack->path[stack->num_paths++]; + path->type =DEV_PATH_ETHERNET ; + path->dev = ctx.dev; + +return ret; +} +EXPORT_SYMBOL_GPL (dev_fill_forward_path); +/** * __dev_get_by_name - find a device by its name * @net: the applicable net namespace
Signature · 1 line
2.20.1
Florian Westphal
maintainerRe: [PATCH net-next,v4 3/9] net: resolve forwarding path from virtual netdevice and HW destination address
Quoted 6 lines · Pablo Neira Ayuso
include/linux/netdevice.h +6
-0+#define NET_DEVICE_PATH_STACK_MAX 5 + +struct net_device_path_stack { +int num_paths; +struct net_device_path path[NET_DEVICE_PATH_STACK_MAX ]; +};
[..]
Quoted 7 lines
net/core/dev.c +7
-0+int dev_fill_forward_path (const struct net_device *dev,const u8 *daddr, +struct net_device_path_stack *stack) +{ +const struct net_device *last_dev; +struct net_device_path_ctx ctx = { + .dev = dev, + .daddr = daddr,
net/core/dev.c int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) · line 865
Quoted 10 lines
net/core/dev.c +10
-0+ }; +struct net_device_path *path; +int ret =0 , k; + + stack->num_paths =0 ; +while (ctx.dev && ctx.dev->netdev_ops->ndo_fill_forward_path) { + last_dev = ctx.dev; + k = stack->num_paths++; +if (WARN_ON_ONCE (k >=NET_DEVICE_PATH_STACK_MAX )) +return -1 ;
This guarantees k < NET_DEVICE_PATH_STACK_MAX, so we can fill entire path[].
net/core/dev.c int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) · line 876
Quoted 10 lines
net/core/dev.c +10
-0+ path = &stack->path[k]; +memset (path,0 ,sizeof (struct net_device_path )); + + ret = ctx.dev->netdev_ops->ndo_fill_forward_path (&ctx, path); +if (ret <0 ) +return -1 ; + +if (WARN_ON_ONCE (last_dev == ctx.dev)) +return -1 ; + }
... but this means that stack->num_paths == NET_DEVICE_PATH_STACK_MAX is possible, with k being last element.
net/core/dev.c int dev_fill_metadata_dst(struct net_device *dev, struct sk_buff *skb) · line 877
Quoted 1 line
net/core/dev.c +1
-0+ path = &stack->path[stack->num_paths++];
... so this may result in a off by one?
Pablo Neira Ayuso
maintainerPATCH v4 4/9 net: 8021q: resolve forwarding path for vlan devices
In reply to Pablo Neira AyusoAdd .ndo_fill_forward_path for vlan devices.
For instance, assuming the following topology:
IP forwarding
/ \
eth0.100 eth0
|
eth0
.
.
.
ethX
ab:cd:ef:ab:cd:efFor packets going through IP forwarding to eth0.100 whose destination MAC address is ab:cd:ef:ab:cd:ef, dev_fill_forward_path() provides the following path:
eth0.100 -> eth0
---
v4: no changes
include/linux/netdevice.h | 7 +++++++ net/8021q/vlan_dev.c | 15 +++++++++++++++ 2 files changed, 22 insertions(+)
include/linux/netdevice.h +7 -0
@@ -835,11 +835,18 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,enum net_device_path_type {DEV_PATH_ETHERNET =0 , +DEV_PATH_VLAN , };struct net_device_path {enum net_device_path_type type;const struct net_device *dev; +union { +struct { +u16 id; +__be16 proto; + } vlan; + }; };#define NET_DEVICE_PATH_STACK_MAX 5
net/8021q/vlan_dev.c +15 -0
@@ -767,6 +767,20 @@ static int vlan_dev_get_iflink(const struct net_device *dev)return real_dev->ifindex; } +static int vlan_dev_fill_forward_path (struct net_device_path_ctx *ctx, +struct net_device_path *path) +{ +struct vlan_dev_priv *vlan =vlan_dev_priv (ctx->dev); + + path->type =DEV_PATH_VLAN ; + path->vlan.id = vlan->vlan_id; + path->vlan.proto = vlan->vlan_proto; + path->dev = ctx->dev; + ctx->dev = vlan->real_dev; + +return 0 ; +} +static const struct ethtool_ops vlan_ethtool_ops = { .get_link_ksettings = vlan_ethtool_get_link_ksettings, .get_drvinfo = vlan_ethtool_get_drvinfo,
@@ -805,6 +819,7 @@ static const struct net_device_ops vlan_netdev_ops = {#endif .ndo_fix_features = vlan_dev_fix_features, .ndo_get_iflink = vlan_dev_get_iflink, + .ndo_fill_forward_path = vlan_dev_fill_forward_path, };static void vlan_dev_free (struct net_device *dev)
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 5/9 bridge: resolve forwarding path for bridge devices
In reply to Pablo Neira AyusoAdd .ndo_fill_forward_path for bridge devices.
---
v4: - Check for valid bridge dst pointer after READ_ONCE, per Nikolay
Aleksandrov.
include/linux/netdevice.h | 1 + net/bridge/br_device.c | 27 +++++++++++++++++++++++++++ 2 files changed, 28 insertions(+)
include/linux/netdevice.h +1 -0
@@ -836,6 +836,7 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,enum net_device_path_type {DEV_PATH_ETHERNET =0 ,DEV_PATH_VLAN , +DEV_PATH_BRIDGE , };struct net_device_path {
net/bridge/br_device.c +27 -0
@@ -391,6 +391,32 @@ static int br_del_slave(struct net_device *dev, struct net_device *slave_dev)return br_del_if (br, slave_dev); } +static int br_fill_forward_path (struct net_device_path_ctx *ctx, +struct net_device_path *path) +{ +struct net_bridge_fdb_entry *f; +struct net_bridge_port *dst; +struct net_bridge *br; + +if (netif_is_bridge_port (ctx->dev)) +return -1 ; + + br =netdev_priv (ctx->dev); + f =br_fdb_find_rcu (br, ctx->daddr,0 ); +if (!f || !f->dst) +return -1 ; + + dst =READ_ONCE (f->dst); +if (!dst) +return -1 ; + + path->type =DEV_PATH_BRIDGE ; + path->dev = dst->br->dev; + ctx->dev = dst->dev; + +return 0 ; +} +static const struct ethtool_ops br_ethtool_ops = { .get_drvinfo = br_getinfo, .get_link = ethtool_op_get_link,
@@ -425,6 +451,7 @@ static const struct net_device_ops br_netdev_ops = { .ndo_bridge_setlink = br_setlink, .ndo_bridge_dellink = br_dellink, .ndo_features_check = passthru_features_check, + .ndo_fill_forward_path = br_fill_forward_path, };static struct device_type br_type = {
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 6/9 netfilter: flowtable: use dev_fill_forward_path() to obtain ingress device
In reply to Pablo Neira AyusoObtain the ingress device in the tuple from the route in the reply direction. Use dev_fill_forward_path() instead to get the real ingress device for this flow.
Fall back to use the ingress device that the IP forwarding route provides if:
- dev_fill_forward_path() finds no real ingress device.
- the ingress device that is obtained is not part of the flowtable devices.
- this route has a xfrm policy.
---
v4: skip initialization of net_device_path_stack in nft_dev_forward_path(),
already done in patch #3.
include/net/netfilter/nf_flow_table.h | 3 + net/netfilter/nf_flow_table_core.c | 3 +- net/netfilter/nft_flow_offload.c | 101 +++++++++++++++++++++++++- 3 files changed, 102 insertions(+), 5 deletions(-)
include/net/netfilter/nf_flow_table.h +3 -0
@@ -165,6 +165,9 @@ static inline __s32 nf_flow_timeout_delta(unsigned int timeout)struct nf_flow_route {struct {struct dst_entry *dst; +struct { +u32 ifindex; + } in;enum flow_offload_xmit_type xmit_type; } tuple[FLOW_OFFLOAD_DIR_MAX ]; };
net/netfilter/nf_flow_table_core.c +1 -2
@@ -79,7 +79,6 @@ static int flow_offload_fill_route(struct flow_offload *flow, enum flow_offload_tuple_dir dir) {struct flow_offload_tuple *flow_tuple = &flow->tuplehash[dir].tuple; -struct dst_entry *other_dst = route->tuple[!dir].dst;struct dst_entry *dst = route->tuple[dir].dst;if (!dst_hold_safe (route->tuple[dir].dst))
@@ -94,7 +93,7 @@ static int flow_offload_fill_route(struct flow_offload *flow,break ; } - flow_tuple->iifidx = other_dst->dev->ifindex; + flow_tuple->iifidx = route->tuple[dir].in.ifindex; flow_tuple->xmit_type = route->tuple[dir].xmit_type; flow_tuple->dst_cache = dst;
net/netfilter/nft_flow_offload.c +98 -3
133 lines not on this page · raw message
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 7/9 netfilter: flowtable: use dev_fill_forward_path() to obtain egress device
In reply to Pablo Neira AyusoThe egress device in the tuple is obtained from route. Use dev_fill_forward_path() instead to provide the real egress device for this flow whenever this is available.
The new FLOW_OFFLOAD_XMIT_DIRECT type uses dev_queue_xmit() to transmit ethernet frames. Cache the source and destination hardware address to use dev_queue_xmit() to transfer packets.
The FLOW_OFFLOAD_XMIT_DIRECT replaces FLOW_OFFLOAD_XMIT_NEIGH if dev_fill_forward_path() finds a direct transmit path.
---
v4: no changes.
include/net/netfilter/nf_flow_table.h | 16 +++++- net/netfilter/nf_flow_table_core.c | 35 ++++++++++--- net/netfilter/nf_flow_table_ip.c | 72 +++++++++++++++++++++------ net/netfilter/nft_flow_offload.c | 25 ++++++++-- 4 files changed, 118 insertions(+), 30 deletions(-)
include/net/netfilter/nf_flow_table.h +14 -2
@@ -92,6 +92,7 @@ enum flow_offload_tuple_dir {enum flow_offload_xmit_type {FLOW_OFFLOAD_XMIT_NEIGH =0 ,FLOW_OFFLOAD_XMIT_XFRM , +FLOW_OFFLOAD_XMIT_DIRECT , };struct flow_offload_tuple {
@@ -120,8 +121,14 @@ struct flow_offload_tuple { xmit_type:2 ;u16 mtu; - -struct dst_entry *dst_cache; +union { +struct dst_entry *dst_cache; +struct { +u32 ifidx; +u8 h_source[ETH_ALEN ]; +u8 h_dest[ETH_ALEN ]; + } out; + }; };struct flow_offload_tuple_rhash {
@@ -168,6 +175,11 @@ struct nf_flow_route {struct {u32 ifindex; } in; +struct { +u32 ifindex; +u8 h_source[ETH_ALEN ]; +u8 h_dest[ETH_ALEN ]; + } out;enum flow_offload_xmit_type xmit_type; } tuple[FLOW_OFFLOAD_DIR_MAX ]; };
net/netfilter/nf_flow_table_core.c +28 -7
@@ -81,9 +81,6 @@ static int flow_offload_fill_route(struct flow_offload *flow,struct flow_offload_tuple *flow_tuple = &flow->tuplehash[dir].tuple;struct dst_entry *dst = route->tuple[dir].dst; -if (!dst_hold_safe (route->tuple[dir].dst)) -return -1 ; -switch (flow_tuple->l3proto) {case NFPROTO_IPV4 : flow_tuple->mtu =ip_dst_mtu_maybe_forward (dst, true);
@@ -94,12 +91,36 @@ static int flow_offload_fill_route(struct flow_offload *flow, } flow_tuple->iifidx = route->tuple[dir].in.ifindex; + +switch (route->tuple[dir].xmit_type) { +case FLOW_OFFLOAD_XMIT_DIRECT : +memcpy (flow_tuple->out.h_dest, route->tuple[dir].out.h_dest, +ETH_ALEN ); +memcpy (flow_tuple->out.h_source, route->tuple[dir].out.h_source, +ETH_ALEN ); + flow_tuple->out.ifidx = route->tuple[dir].out.ifindex; +break ; +case FLOW_OFFLOAD_XMIT_XFRM : +case FLOW_OFFLOAD_XMIT_NEIGH : +if (!dst_hold_safe (route->tuple[dir].dst)) +return -1 ; + + flow_tuple->dst_cache = dst; +break ; + } flow_tuple->xmit_type = route->tuple[dir].xmit_type; - flow_tuple->dst_cache = dst;return 0 ; } +static void nft_flow_dst_release (struct flow_offload *flow, +enum flow_offload_tuple_dir dir) +{ +if (flow->tuplehash[dir].tuple.xmit_type ==FLOW_OFFLOAD_XMIT_NEIGH || + flow->tuplehash[dir].tuple.xmit_type ==FLOW_OFFLOAD_XMIT_XFRM ) +dst_release (flow->tuplehash[dir].tuple.dst_cache); +} +int flow_offload_route_init (struct flow_offload *flow,const struct nf_flow_route *route) {
@@ -118,7 +139,7 @@ int flow_offload_route_init(struct flow_offload *flow,return 0 ; err_route_reply: -dst_release (route->tuple[FLOW_OFFLOAD_DIR_ORIGINAL ].dst); +nft_flow_dst_release (flow,FLOW_OFFLOAD_DIR_ORIGINAL );return err; }
@@ -169,8 +190,8 @@ static void flow_offload_fixup_ct(struct nf_conn *ct)static void flow_offload_route_release (struct flow_offload *flow) { -dst_release (flow->tuplehash[FLOW_OFFLOAD_DIR_ORIGINAL ].tuple.dst_cache); -dst_release (flow->tuplehash[FLOW_OFFLOAD_DIR_REPLY ].tuple.dst_cache); +nft_flow_dst_release (flow,FLOW_OFFLOAD_DIR_ORIGINAL ); +nft_flow_dst_release (flow,FLOW_OFFLOAD_DIR_REPLY ); }void flow_offload_free (struct flow_offload *flow)
net/netfilter/nf_flow_table_ip.c +56 -16
117 lines not on this page · raw message
net/netfilter/nft_flow_offload.c +20 -5
@@ -39,12 +39,11 @@ static void nft_default_forward_path(struct nf_flow_route *route,static int nft_dev_fill_forward_path (const struct nf_flow_route *route,const struct dst_entry *dst_cache,const struct nf_conn *ct, -enum ip_conntrack_dir dir, +enum ip_conntrack_dir dir,u8 *ha,struct net_device_path_stack *stack) {const void *daddr = &ct->tuplehash[!dir].tuple.src.u3;struct net_device *dev = dst_cache->dev; -unsigned char ha[ETH_ALEN ];struct neighbour *n;u8 nud_state;
@@ -66,10 +65,14 @@ static int nft_dev_fill_forward_path(const struct nf_flow_route *route,struct nft_forward_info {const struct net_device *indev; +u8 h_source[ETH_ALEN ]; +u8 h_dest[ETH_ALEN ]; +enum flow_offload_xmit_type xmit_type; };static void nft_dev_path_info (const struct net_device_path_stack *stack, -struct nft_forward_info *info) +struct nft_forward_info *info, +unsigned char *ha) {const struct net_device_path *path;int i;
@@ -79,10 +82,14 @@ static void nft_dev_path_info(const struct net_device_path_stack *stack,switch (path->type) {case DEV_PATH_ETHERNET : info->indev = path->dev; +memcpy (info->h_dest, path->dev->dev_addr,ETH_ALEN ); +memcpy (info->h_source, ha,ETH_ALEN );break ;case DEV_PATH_VLAN :break ;case DEV_PATH_BRIDGE : +memcpy (info->h_dest, path->dev->dev_addr,ETH_ALEN ); + info->xmit_type =FLOW_OFFLOAD_XMIT_DIRECT ;break ; } }
@@ -113,14 +120,22 @@ static void nft_dev_forward_path(struct nf_flow_route *route,const struct dst_entry *dst = route->tuple[dir].dst;struct net_device_path_stack stack;struct nft_forward_info info = {}; +unsigned char ha[ETH_ALEN ]; -if (nft_dev_fill_forward_path (route, dst, ct, dir, &stack) >=0 ) -nft_dev_path_info (&stack, &info); +if (nft_dev_fill_forward_path (route, dst, ct, dir, ha, &stack) >=0 ) +nft_dev_path_info (&stack, &info, ha);if (!info.indev || !nft_flowtable_find_dev (info.indev, ft))return ; route->tuple[!dir].in.ifindex = info.indev->ifindex; + +if (info.xmit_type ==FLOW_OFFLOAD_XMIT_DIRECT ) { +memcpy (route->tuple[dir].out.h_dest, info.h_source,ETH_ALEN ); +memcpy (route->tuple[dir].out.h_source, info.h_dest,ETH_ALEN ); + route->tuple[dir].out.ifindex = info.indev->ifindex; + route->tuple[dir].xmit_type = info.xmit_type; + } } static int nft_flow_route(const struct nft_pktinfo *pkt,
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 8/9 netfilter: flowtable: add vlan support
In reply to Pablo Neira AyusoAdd the vlan id and protocol to the flow tuple to uniquely identify flows from the receive path. For the transmit path, dev_hard_header() on the vlan device push the headers. This patch includes support for two VLAN headers (QinQ) from the ingress path.
---
v4: no changes.
include/net/netfilter/nf_flow_table.h | 15 +++- net/netfilter/nf_flow_table_core.c | 6 ++ net/netfilter/nf_flow_table_ip.c | 108 +++++++++++++++++++++----- net/netfilter/nft_flow_offload.c | 25 +++++- 4 files changed, 131 insertions(+), 23 deletions(-)
include/net/netfilter/nf_flow_table.h +12 -3
@@ -95,6 +95,8 @@ enum flow_offload_xmit_type { FLOW_OFFLOAD_XMIT_DIRECT, }; +#define NF_FLOW_TABLE_VLAN_MAX 2 + struct flow_offload_tuple { union { struct in_addr src_v4;
@@ -113,13 +115,17 @@ struct flow_offload_tuple {u8 l3proto;u8 l4proto; +struct { +u16 id; +__be16 proto; + } in_vlan[NF_FLOW_TABLE_VLAN_MAX ];/* All members above are keys for lookups, see flow_offload_hash(). */ struct { } __hash; - u8 dir:6, - xmit_type:2; - + u8 dir:4, + xmit_type:2, + in_vlan_num:2;u16 mtu;union {struct dst_entry *dst_cache;
@@ -174,6 +180,9 @@ struct nf_flow_route {struct dst_entry *dst;struct {u32 ifindex; +u16 vid[NF_FLOW_TABLE_VLAN_MAX ]; +__be16 vproto[NF_FLOW_TABLE_VLAN_MAX ]; +u8 num_vlans; } in;struct {u32 ifindex;
net/netfilter/nf_flow_table_core.c +6 -0
@@ -80,6 +80,7 @@ static int flow_offload_fill_route(struct flow_offload *flow, {struct flow_offload_tuple *flow_tuple = &flow->tuplehash[dir].tuple;struct dst_entry *dst = route->tuple[dir].dst; +int i;switch (flow_tuple->l3proto) {case NFPROTO_IPV4 :
@@ -91,6 +92,11 @@ static int flow_offload_fill_route(struct flow_offload *flow, } flow_tuple->iifidx = route->tuple[dir].in.ifindex; +for (i =0 ; i < route->tuple[dir].in.num_vlans; i++) { + flow_tuple->in_vlan[i].id = route->tuple[dir].in.vid[i]; + flow_tuple->in_vlan[i].proto = route->tuple[dir].in.vproto[i]; + } + flow_tuple->in_vlan_num = route->tuple[dir].in.num_vlans;switch (route->tuple[dir].xmit_type) {case FLOW_OFFLOAD_XMIT_DIRECT :
net/netfilter/nf_flow_table_ip.c +89 -19
209 lines not on this page · raw message
net/netfilter/nft_flow_offload.c +24 -1
@@ -65,6 +65,10 @@ static int nft_dev_fill_forward_path(const struct nf_flow_route *route,struct nft_forward_info {const struct net_device *indev; +const struct net_device *vlandev; +__u16 vid[NF_FLOW_TABLE_VLAN_MAX ]; +__be16 vproto[NF_FLOW_TABLE_VLAN_MAX ]; +u8 num_vlans;u8 h_source[ETH_ALEN ];u8 h_dest[ETH_ALEN ];enum flow_offload_xmit_type xmit_type;
@@ -86,6 +90,16 @@ static void nft_dev_path_info(const struct net_device_path_stack *stack,memcpy (info->h_source, ha,ETH_ALEN );break ;case DEV_PATH_VLAN : +if (info->num_vlans >=NF_FLOW_TABLE_VLAN_MAX ) { + info->indev =NULL ; +break ; + } +if (!info->vlandev) + info->vlandev = path->dev; + + info->vid[info->num_vlans] = path->vlan.id; + info->vproto[info->num_vlans] = path->vlan.proto; + info->num_vlans++;break ;case DEV_PATH_BRIDGE :memcpy (info->h_dest, path->dev->dev_addr,ETH_ALEN );
@@ -121,6 +135,7 @@ static void nft_dev_forward_path(struct nf_flow_route *route,struct net_device_path_stack stack;struct nft_forward_info info = {};unsigned char ha[ETH_ALEN ]; +int i;if (nft_dev_fill_forward_path (route, dst, ct, dir, ha, &stack) >=0 )nft_dev_path_info (&stack, &info, ha);
@@ -129,11 +144,19 @@ static void nft_dev_forward_path(struct nf_flow_route *route,return ; route->tuple[!dir].in.ifindex = info.indev->ifindex; +for (i =0 ; i < info.num_vlans; i++) { + route->tuple[!dir].in.vid[i] = info.vid[i]; + route->tuple[!dir].in.vproto[i] = info.vproto[i]; + } + route->tuple[!dir].in.num_vlans = info.num_vlans;if (info.xmit_type ==FLOW_OFFLOAD_XMIT_DIRECT ) {memcpy (route->tuple[dir].out.h_dest, info.h_source,ETH_ALEN );memcpy (route->tuple[dir].out.h_source, info.h_dest,ETH_ALEN ); - route->tuple[dir].out.ifindex = info.indev->ifindex; +if (info.vlandev) + route->tuple[dir].out.ifindex = info.vlandev->ifindex; +else + route->tuple[dir].out.ifindex = info.indev->ifindex; route->tuple[dir].xmit_type = info.xmit_type; } }
Signature · 1 line
2.20.1
Pablo Neira Ayuso
maintainerPATCH v4 9/9 selftests: netfilter: flowtable bridge and VLAN support
In reply to Pablo Neira AyusoThis patch adds two new tests to cover bridge and VLAN support:
- Add a bridge device to the Router1 (nsr1) container and attach the veth0 device to the bridge. Set the IP address to the bridge device to exercise the bridge forwarding path.
- Add VLAN encapsulation between to the bridge device in the Router1 and one of the sender containers (ns1).
---
v4: no changes.
.../selftests/netfilter/nft_flowtable.sh | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+)
tools/testing/selftests/netfilter/nft_flowtable.sh +82 -0
@@ -371,6 +371,88 @@ else ip netns exec nsr1 nft list ruleset fi +# Another test: +# Add bridge interface br0 to Router1, with NAT enabled. +ip -net nsr1 link add name br0 type bridge +ip -net nsr1 addr flush dev veth0 +ip -net nsr1 link set up dev veth0 +ip -net nsr1 link set veth0 master br0 +ip -net nsr1 addr add 10.0.1.1/24 dev br0 +ip -net nsr1 addr add dead:1::1/64 dev br0 +ip -net nsr1 link set up dev br0 + +ip netns exec nsr1 sysctl net.ipv4.conf.br0.forwarding=1 > /dev/null + +# br0 with NAT enabled. +ip netns exec nsr1 nft -f - <<EOF +flush table ip nat +table ip nat { + chain prerouting { + type nat hook prerouting priority 0; policy accept; + meta iif "br0" ip daddr 10.6.6.6 tcp dport 1666 counter dnat ip to 10.0.2.99:12345 + } + + chain postrouting { + type nat hook postrouting priority 0; policy accept; + meta oifname "veth1" counter masquerade + } +} +EOF + +if test_tcp_forwarding_nat ns1 ns2; then + echo "PASS: flow offloaded for ns1/ns2 with bridge NAT" +else + echo "FAIL: flow offload for ns1/ns2 with bridge NAT" 1>&2 + ip netns exec nsr1 nft list ruleset + ret=1 +fi + +# Another test: +# Add bridge interface br0 to Router1, with NAT and VLAN. +ip -net nsr1 link set veth0 nomaster +ip -net nsr1 link set down dev veth0 +ip -net nsr1 link add link veth0 name veth0.10 type vlan id 10 +ip -net nsr1 link set up dev veth0 +ip -net nsr1 link set up dev veth0.10 +ip -net nsr1 link set veth0.10 master br0 + +ip -net ns1 addr flush dev eth0 +ip -net ns1 link add link eth0 name eth0.10 type vlan id 10 +ip -net ns1 link set eth0 up +ip -net ns1 link set eth0.10 up +ip -net ns1 addr add 10.0.1.99/24 dev eth0.10 +ip -net ns1 route add default via 10.0.1.1 +ip -net ns1 addr add dead:1::99/64 dev eth0.10 + +if test_tcp_forwarding_nat ns1 ns2; then + echo "PASS: flow offloaded for ns1/ns2 with bridge NAT and VLAN" +else + echo "FAIL: flow offload for ns1/ns2 with bridge NAT and VLAN" 1>&2 + ip netns exec nsr1 nft list ruleset + ret=1 +fi + +# restore test topology (remove bridge and VLAN) +ip -net nsr1 link set veth0 nomaster +ip -net nsr1 link set veth0 down +ip -net nsr1 link set veth0.10 down +ip -net nsr1 link delete veth0.10 type vlan +ip -net nsr1 link delete br0 type bridge +ip -net ns1 addr flush dev eth0.10 +ip -net ns1 link set eth0.10 down +ip -net ns1 link set eth0 down +ip -net ns1 link delete eth0.10 type vlan + +# restore address in ns1 and nsr1 +ip -net ns1 link set eth0 up +ip -net ns1 addr add 10.0.1.99/24 dev eth0 +ip -net ns1 route add default via 10.0.1.1 +ip -net ns1 addr add dead:1::99/64 dev eth0 +ip -net ns1 route add default via dead:1::1 +ip -net nsr1 addr add 10.0.1.1/24 dev veth0 +ip -net nsr1 addr add dead:1::1/64 dev veth0 +ip -net nsr1 link set up dev veth0 + KEY_SHA="0x"$(ps -xaf | sha1sum | cut -d " " -f 1) KEY_AES="0x"$(ps -xaf | md5sum | cut -d " " -f 1) SPI1=$RANDOM
Signature · 1 line
2.20.1