* [PATCH nf-next v9 1/3] net: netfilter: Add IPIP flowtable rx sw acceleration
2025-11-07 11:14 [PATCH nf-next v9 0/3] Add IPIP flowtable SW acceleration Lorenzo Bianconi
@ 2025-11-07 11:14 ` Lorenzo Bianconi
2025-11-07 11:14 ` [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx " Lorenzo Bianconi
2025-11-07 11:14 ` [PATCH nf-next v9 3/3] selftests: netfilter: nft_flowtable.sh: Add IPIP flowtable selftest Lorenzo Bianconi
2 siblings, 0 replies; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-07 11:14 UTC (permalink / raw)
To: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Pablo Neira Ayuso, Jozsef Kadlecsik,
Shuah Khan, Andrew Lunn, Phil Sutter
Cc: Florian Westphal, netdev, netfilter-devel, coreteam,
linux-kselftest, Lorenzo Bianconi
Introduce sw acceleration for rx path of IPIP tunnels relying on the
netfilter flowtable infrastructure. Subsequent patches will add sw
acceleration for IPIP tunnels tx path.
This series introduces basic infrastructure to accelerate other tunnel
types (e.g. IP6IP6).
IPIP rx sw acceleration can be tested running the following scenario where
the traffic is forwarded between two NICs (eth0 and eth1) and an IPIP
tunnel is used to access a remote site (using eth1 as the underlay device):
ETH0 -- TUN0 <==> ETH1 -- [IP network] -- TUN1 (192.168.100.2)
$ip addr show
6: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether 00:00:22:33:11:55 brd ff:ff:ff:ff:ff:ff
inet 192.168.0.2/24 scope global eth0
valid_lft forever preferred_lft forever
7: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether 00:11:22:33:11:55 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.1/24 scope global eth1
valid_lft forever preferred_lft forever
8: tun0@NONE: <POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1480 qdisc noqueue state UNKNOWN group default qlen 1000
link/ipip 192.168.1.1 peer 192.168.1.2
inet 192.168.100.1/24 scope global tun0
valid_lft forever preferred_lft forever
$ip route show
default via 192.168.100.2 dev tun0
192.168.0.0/24 dev eth0 proto kernel scope link src 192.168.0.2
192.168.1.0/24 dev eth1 proto kernel scope link src 192.168.1.1
192.168.100.0/24 dev tun0 proto kernel scope link src 192.168.100.1
$nft list ruleset
table inet filter {
flowtable ft {
hook ingress priority filter
devices = { eth0, eth1 }
}
chain forward {
type filter hook forward priority filter; policy accept;
meta l4proto { tcp, udp } flow add @ft
}
}
Reproducing the scenario described above using veths I got the following
results:
- TCP stream received from the IPIP tunnel:
- net-next: (baseline) ~ 71Gbps
- net-next + IPIP flowtbale support: ~101Gbps
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
include/linux/netdevice.h | 13 +++++++
include/net/netfilter/nf_flow_table.h | 18 +++++++++
net/ipv4/ipip.c | 25 +++++++++++++
net/netfilter/nf_flow_table_core.c | 3 ++
net/netfilter/nf_flow_table_ip.c | 69 ++++++++++++++++++++++++++++++++---
net/netfilter/nf_flow_table_path.c | 38 +++++++++++++++----
6 files changed, 153 insertions(+), 13 deletions(-)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 7f5aad5cc9a1994f95ba9037d3a4af27eef9d5e3..0355461960ce3c0db49e00a6f77f48b031a635dc 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -874,6 +874,7 @@ enum net_device_path_type {
DEV_PATH_PPPOE,
DEV_PATH_DSA,
DEV_PATH_MTK_WDMA,
+ DEV_PATH_TUN,
};
struct net_device_path {
@@ -885,6 +886,18 @@ struct net_device_path {
__be16 proto;
u8 h_dest[ETH_ALEN];
} encap;
+ struct {
+ union {
+ struct in_addr src_v4;
+ struct in6_addr src_v6;
+ };
+ union {
+ struct in_addr dst_v4;
+ struct in6_addr dst_v6;
+ };
+
+ u8 l3_proto;
+ } tun;
struct {
enum {
DEV_PATH_BR_VLAN_KEEP,
diff --git a/include/net/netfilter/nf_flow_table.h b/include/net/netfilter/nf_flow_table.h
index 89cfe72283983ad651a943919ab2141ef082977a..4047075c615e1b64722f98da3b36acf3a2733b64 100644
--- a/include/net/netfilter/nf_flow_table.h
+++ b/include/net/netfilter/nf_flow_table.h
@@ -107,6 +107,19 @@ enum flow_offload_xmit_type {
#define NF_FLOW_TABLE_ENCAP_MAX 2
+struct flow_offload_tunnel {
+ union {
+ struct in_addr src_v4;
+ struct in6_addr src_v6;
+ };
+ union {
+ struct in_addr dst_v4;
+ struct in6_addr dst_v6;
+ };
+
+ u8 l3_proto;
+};
+
struct flow_offload_tuple {
union {
struct in_addr src_v4;
@@ -130,12 +143,15 @@ struct flow_offload_tuple {
__be16 proto;
} encap[NF_FLOW_TABLE_ENCAP_MAX];
+ struct flow_offload_tunnel tun;
+
/* All members above are keys for lookups, see flow_offload_hash(). */
struct { } __hash;
u8 dir:2,
xmit_type:3,
encap_num:2,
+ tun_num:2,
in_vlan_ingress:2;
u16 mtu;
union {
@@ -206,7 +222,9 @@ struct nf_flow_route {
u16 id;
__be16 proto;
} encap[NF_FLOW_TABLE_ENCAP_MAX];
+ struct flow_offload_tunnel tun;
u8 num_encaps:2,
+ num_tuns:2,
ingress_vlans:2;
} in;
struct {
diff --git a/net/ipv4/ipip.c b/net/ipv4/ipip.c
index 3e03af073a1ccc3d7597a998a515b6cfdded40b5..ff95b1b9908e9f4ba4bff207a5bd2c5d5670215a 100644
--- a/net/ipv4/ipip.c
+++ b/net/ipv4/ipip.c
@@ -353,6 +353,30 @@ ipip_tunnel_ctl(struct net_device *dev, struct ip_tunnel_parm_kern *p, int cmd)
return ip_tunnel_ctl(dev, p, cmd);
}
+static int ipip_fill_forward_path(struct net_device_path_ctx *ctx,
+ struct net_device_path *path)
+{
+ struct ip_tunnel *tunnel = netdev_priv(ctx->dev);
+ const struct iphdr *tiph = &tunnel->parms.iph;
+ struct rtable *rt;
+
+ rt = ip_route_output(dev_net(ctx->dev), tiph->daddr, 0, 0, 0,
+ RT_SCOPE_UNIVERSE);
+ if (IS_ERR(rt))
+ return PTR_ERR(rt);
+
+ path->type = DEV_PATH_TUN;
+ path->tun.src_v4.s_addr = tiph->saddr;
+ path->tun.dst_v4.s_addr = tiph->daddr;
+ path->tun.l3_proto = IPPROTO_IPIP;
+ path->dev = ctx->dev;
+
+ ctx->dev = rt->dst.dev;
+ ip_rt_put(rt);
+
+ return 0;
+}
+
static const struct net_device_ops ipip_netdev_ops = {
.ndo_init = ipip_tunnel_init,
.ndo_uninit = ip_tunnel_uninit,
@@ -362,6 +386,7 @@ static const struct net_device_ops ipip_netdev_ops = {
.ndo_get_stats64 = dev_get_tstats64,
.ndo_get_iflink = ip_tunnel_get_iflink,
.ndo_tunnel_ctl = ipip_tunnel_ctl,
+ .ndo_fill_forward_path = ipip_fill_forward_path,
};
#define IPIP_FEATURES (NETIF_F_SG | \
diff --git a/net/netfilter/nf_flow_table_core.c b/net/netfilter/nf_flow_table_core.c
index 6c6a5165f9933b130e772c096a01d3fcb1d61c94..06e8251a6644e2335117ae3720b9ebf159eb2264 100644
--- a/net/netfilter/nf_flow_table_core.c
+++ b/net/netfilter/nf_flow_table_core.c
@@ -118,7 +118,10 @@ static int flow_offload_fill_route(struct flow_offload *flow,
flow_tuple->in_vlan_ingress |= BIT(j);
j++;
}
+
+ flow_tuple->tun = route->tuple[dir].in.tun;
flow_tuple->encap_num = route->tuple[dir].in.num_encaps;
+ flow_tuple->tun_num = route->tuple[dir].in.num_tuns;
switch (route->tuple[dir].xmit_type) {
case FLOW_OFFLOAD_XMIT_DIRECT:
diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
index be21600cff5390202f5451cd76c4e2afc6f8bc00..b40080b0d71cc011e18b68201af33e9c84987d78 100644
--- a/net/netfilter/nf_flow_table_ip.c
+++ b/net/netfilter/nf_flow_table_ip.c
@@ -145,8 +145,11 @@ static bool ip_has_options(unsigned int thoff)
static void nf_flow_tuple_encap(struct sk_buff *skb,
struct flow_offload_tuple *tuple)
{
+ __be16 inner_proto = skb->protocol;
struct vlan_ethhdr *veth;
struct pppoe_hdr *phdr;
+ struct iphdr *iph;
+ u16 offset = 0;
int i = 0;
if (skb_vlan_tag_present(skb)) {
@@ -159,13 +162,26 @@ static void nf_flow_tuple_encap(struct sk_buff *skb,
veth = (struct vlan_ethhdr *)skb_mac_header(skb);
tuple->encap[i].id = ntohs(veth->h_vlan_TCI);
tuple->encap[i].proto = skb->protocol;
+ inner_proto = veth->h_vlan_encapsulated_proto;
+ offset += VLAN_HLEN;
break;
case htons(ETH_P_PPP_SES):
phdr = (struct pppoe_hdr *)skb_network_header(skb);
tuple->encap[i].id = ntohs(phdr->sid);
tuple->encap[i].proto = skb->protocol;
+ inner_proto = *((__be16 *)(phdr + 1));
+ offset += PPPOE_SES_HLEN;
break;
}
+
+ if (inner_proto == htons(ETH_P_IP)) {
+ iph = (struct iphdr *)(skb_network_header(skb) + offset);
+ if (iph->protocol == IPPROTO_IPIP) {
+ tuple->tun.dst_v4.s_addr = iph->daddr;
+ tuple->tun.src_v4.s_addr = iph->saddr;
+ tuple->tun.l3_proto = IPPROTO_IPIP;
+ }
+ }
}
struct nf_flowtable_ctx {
@@ -277,11 +293,46 @@ static unsigned int nf_flow_xmit_xfrm(struct sk_buff *skb,
return NF_STOLEN;
}
+static bool nf_flow_ip4_encap_proto(struct sk_buff *skb, u32 *psize)
+{
+ struct iphdr *iph;
+ u16 size;
+
+ if (!pskb_may_pull(skb, sizeof(*iph) + *psize))
+ return false;
+
+ iph = (struct iphdr *)(skb_network_header(skb) + *psize);
+ size = iph->ihl << 2;
+
+ if (ip_is_fragment(iph) || unlikely(ip_has_options(size)))
+ return false;
+
+ if (iph->ttl <= 1)
+ return false;
+
+ if (iph->protocol == IPPROTO_IPIP)
+ *psize += size;
+
+ return true;
+}
+
+static void nf_flow_ip4_encap_pop(struct sk_buff *skb)
+{
+ struct iphdr *iph = (struct iphdr *)skb_network_header(skb);
+
+ if (iph->protocol != IPPROTO_IPIP)
+ return;
+
+ skb_pull(skb, iph->ihl << 2);
+ skb_reset_network_header(skb);
+}
+
static bool nf_flow_skb_encap_protocol(struct sk_buff *skb, __be16 proto,
u32 *offset)
{
+ __be16 inner_proto = skb->protocol;
struct vlan_ethhdr *veth;
- __be16 inner_proto;
+ bool ret = false;
switch (skb->protocol) {
case htons(ETH_P_8021Q):
@@ -291,19 +342,23 @@ static bool nf_flow_skb_encap_protocol(struct sk_buff *skb, __be16 proto,
veth = (struct vlan_ethhdr *)skb_mac_header(skb);
if (veth->h_vlan_encapsulated_proto == proto) {
*offset += VLAN_HLEN;
- return true;
+ inner_proto = proto;
+ ret = true;
}
break;
case htons(ETH_P_PPP_SES):
if (nf_flow_pppoe_proto(skb, &inner_proto) &&
inner_proto == proto) {
*offset += PPPOE_SES_HLEN;
- return true;
+ ret = true;
}
break;
}
- return false;
+ if (inner_proto == htons(ETH_P_IP))
+ ret = nf_flow_ip4_encap_proto(skb, offset);
+
+ return ret;
}
static void nf_flow_encap_pop(struct sk_buff *skb,
@@ -331,6 +386,9 @@ static void nf_flow_encap_pop(struct sk_buff *skb,
break;
}
}
+
+ if (skb->protocol == htons(ETH_P_IP))
+ nf_flow_ip4_encap_pop(skb);
}
struct nf_flow_xmit {
@@ -356,8 +414,7 @@ nf_flow_offload_lookup(struct nf_flowtable_ctx *ctx,
{
struct flow_offload_tuple tuple = {};
- if (skb->protocol != htons(ETH_P_IP) &&
- !nf_flow_skb_encap_protocol(skb, htons(ETH_P_IP), &ctx->offset))
+ if (!nf_flow_skb_encap_protocol(skb, htons(ETH_P_IP), &ctx->offset))
return NULL;
if (nf_flow_tuple_ip(ctx, skb, &tuple) < 0)
diff --git a/net/netfilter/nf_flow_table_path.c b/net/netfilter/nf_flow_table_path.c
index 50b2b7d0c579ec0855f5870d1e1f7d6f74db0e8f..64e2672a3c3383bae896c4fb68ff9ab7489fe791 100644
--- a/net/netfilter/nf_flow_table_path.c
+++ b/net/netfilter/nf_flow_table_path.c
@@ -80,6 +80,8 @@ struct nft_forward_info {
__be16 proto;
} encap[NF_FLOW_TABLE_ENCAP_MAX];
u8 num_encaps;
+ struct flow_offload_tunnel tun;
+ u8 num_tuns;
u8 ingress_vlans;
u8 h_source[ETH_ALEN];
u8 h_dest[ETH_ALEN];
@@ -102,6 +104,7 @@ static void nft_dev_path_info(const struct net_device_path_stack *stack,
case DEV_PATH_DSA:
case DEV_PATH_VLAN:
case DEV_PATH_PPPOE:
+ case DEV_PATH_TUN:
info->indev = path->dev;
if (is_zero_ether_addr(info->h_source))
memcpy(info->h_source, path->dev->dev_addr, ETH_ALEN);
@@ -113,14 +116,27 @@ static void nft_dev_path_info(const struct net_device_path_stack *stack,
break;
}
- /* DEV_PATH_VLAN and DEV_PATH_PPPOE */
- if (info->num_encaps >= NF_FLOW_TABLE_ENCAP_MAX) {
- info->indev = NULL;
- break;
+ /* DEV_PATH_VLAN, DEV_PATH_PPPOE and DEV_PATH_TUN */
+ if (path->type == DEV_PATH_TUN) {
+ if (info->num_tuns) {
+ info->indev = NULL;
+ break;
+ }
+ info->tun.src_v6 = path->tun.src_v6;
+ info->tun.dst_v6 = path->tun.dst_v6;
+ info->tun.l3_proto = path->tun.l3_proto;
+ info->num_tuns++;
+ } else {
+ if (info->num_encaps >= NF_FLOW_TABLE_ENCAP_MAX) {
+ info->indev = NULL;
+ break;
+ }
+ info->encap[info->num_encaps].id =
+ path->encap.id;
+ info->encap[info->num_encaps].proto =
+ path->encap.proto;
+ info->num_encaps++;
}
- info->encap[info->num_encaps].id = path->encap.id;
- info->encap[info->num_encaps].proto = path->encap.proto;
- info->num_encaps++;
if (path->type == DEV_PATH_PPPOE)
memcpy(info->h_dest, path->encap.h_dest, ETH_ALEN);
break;
@@ -196,6 +212,14 @@ static void nft_dev_forward_path(struct nf_flow_route *route,
route->tuple[!dir].in.encap[i].id = info.encap[i].id;
route->tuple[!dir].in.encap[i].proto = info.encap[i].proto;
}
+
+ if (info.num_tuns) {
+ route->tuple[!dir].in.tun.src_v6 = info.tun.dst_v6;
+ route->tuple[!dir].in.tun.dst_v6 = info.tun.src_v6;
+ route->tuple[!dir].in.tun.l3_proto = info.tun.l3_proto;
+ route->tuple[!dir].in.num_tuns = info.num_tuns;
+ }
+
route->tuple[!dir].in.num_encaps = info.num_encaps;
route->tuple[!dir].in.ingress_vlans = info.ingress_vlans;
route->tuple[dir].out.ifindex = info.outdev->ifindex;
--
2.51.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-07 11:14 [PATCH nf-next v9 0/3] Add IPIP flowtable SW acceleration Lorenzo Bianconi
2025-11-07 11:14 ` [PATCH nf-next v9 1/3] net: netfilter: Add IPIP flowtable rx sw acceleration Lorenzo Bianconi
@ 2025-11-07 11:14 ` Lorenzo Bianconi
2025-11-12 12:55 ` Pablo Neira Ayuso
2025-11-07 11:14 ` [PATCH nf-next v9 3/3] selftests: netfilter: nft_flowtable.sh: Add IPIP flowtable selftest Lorenzo Bianconi
2 siblings, 1 reply; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-07 11:14 UTC (permalink / raw)
To: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Pablo Neira Ayuso, Jozsef Kadlecsik,
Shuah Khan, Andrew Lunn, Phil Sutter
Cc: Florian Westphal, netdev, netfilter-devel, coreteam,
linux-kselftest, Lorenzo Bianconi
Introduce sw acceleration for tx path of IPIP tunnels relying on the
netfilter flowtable infrastructure.
This patch introduces basic infrastructure to accelerate other tunnel
types (e.g. IP6IP6).
IPIP sw tx acceleration can be tested running the following scenario where
the traffic is forwarded between two NICs (eth0 and eth1) and an IPIP
tunnel is used to access a remote site (using eth1 as the underlay device):
ETH0 -- TUN0 <==> ETH1 -- [IP network] -- TUN1 (192.168.100.2)
$ip addr show
6: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether 00:00:22:33:11:55 brd ff:ff:ff:ff:ff:ff
inet 192.168.0.2/24 scope global eth0
valid_lft forever preferred_lft forever
7: eth1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether 00:11:22:33:11:55 brd ff:ff:ff:ff:ff:ff
inet 192.168.1.1/24 scope global eth1
valid_lft forever preferred_lft forever
8: tun0@NONE: <POINTOPOINT,NOARP,UP,LOWER_UP> mtu 1480 qdisc noqueue state UNKNOWN group default qlen 1000
link/ipip 192.168.1.1 peer 192.168.1.2
inet 192.168.100.1/24 scope global tun0
valid_lft forever preferred_lft forever
$ip route show
default via 192.168.100.2 dev tun0
192.168.0.0/24 dev eth0 proto kernel scope link src 192.168.0.2
192.168.1.0/24 dev eth1 proto kernel scope link src 192.168.1.1
192.168.100.0/24 dev tun0 proto kernel scope link src 192.168.100.1
$nft list ruleset
table inet filter {
flowtable ft {
hook ingress priority filter
devices = { eth0, eth1 }
}
chain forward {
type filter hook forward priority filter; policy accept;
meta l4proto { tcp, udp } flow add @ft
}
}
Reproducing the scenario described above using veths I got the following
results:
- TCP stream trasmitted into the IPIP tunnel:
- net-next: (baseline) ~ 85Gbps
- net-next + IPIP flowtbale support: ~102Gbps
Co-developed-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Pablo Neira Ayuso <pablo@netfilter.org>
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
net/netfilter/nf_flow_table_ip.c | 66 ++++++++++++++++++++++++++++++++++++--
net/netfilter/nf_flow_table_path.c | 48 ++++++++++++++++++++++++---
2 files changed, 107 insertions(+), 7 deletions(-)
diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
index b40080b0d71cc011e18b68201af33e9c84987d78..9e6e26f49826e749c168b4f96ab53d24ddb88fe3 100644
--- a/net/netfilter/nf_flow_table_ip.c
+++ b/net/netfilter/nf_flow_table_ip.c
@@ -437,6 +437,9 @@ static int nf_flow_offload_forward(struct nf_flowtable_ctx *ctx,
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
mtu = flow->tuplehash[dir].tuple.mtu + ctx->offset;
+ if (flow->tuplehash[!dir].tuple.tun_num)
+ mtu -= sizeof(*iph);
+
if (unlikely(nf_flow_exceeds_mtu(skb, mtu)))
return 0;
@@ -508,10 +511,62 @@ static int nf_flow_pppoe_push(struct sk_buff *skb, u16 id)
return 0;
}
-static int nf_flow_encap_push(struct sk_buff *skb, struct flow_offload_tuple *tuple)
+static int nf_flow_tunnel_v4_push(struct net *net, struct sk_buff *skb,
+ struct flow_offload_tuple *tuple)
+{
+ struct iphdr *iph = (struct iphdr *)skb_network_header(skb);
+ struct rtable *rt = dst_rtable(tuple->dst_cache);
+ __be16 frag_off = iph->frag_off;
+ u32 headroom = sizeof(*iph);
+ u8 tos = iph->tos, ttl = iph->ttl;
+ int err;
+
+ err = iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4);
+ if (err)
+ return err;
+
+ skb_set_inner_ipproto(skb, IPPROTO_IPIP);
+ headroom += LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len;
+ err = skb_cow_head(skb, headroom);
+ if (err)
+ return err;
+
+ skb_scrub_packet(skb, true);
+ skb_clear_hash_if_not_l4(skb);
+ memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
+
+ /* Push down and install the IP header. */
+ skb_push(skb, sizeof(*iph));
+ skb_reset_network_header(skb);
+
+ iph = ip_hdr(skb);
+ iph->version = 4;
+ iph->ihl = sizeof(*iph) >> 2;
+ iph->frag_off = ip_mtu_locked(&rt->dst) ? 0 : frag_off;
+ iph->protocol = tuple->tun.l3_proto;
+ iph->tos = tos;
+ iph->daddr = tuple->tun.src_v4.s_addr;
+ iph->saddr = tuple->tun.dst_v4.s_addr;
+ iph->ttl = ttl;
+ iph->tot_len = htons(skb->len);
+ __ip_select_ident(net, iph, skb_shinfo(skb)->gso_segs ?: 1);
+ ip_send_check(iph);
+
+ return 0;
+}
+
+static int nf_flow_encap_push(struct net *net, struct sk_buff *skb,
+ struct flow_offload_tuple *tuple)
{
int i;
+ if (tuple->tun_num) {
+ int err = nf_flow_tunnel_v4_push(net, skb, tuple);
+
+ if (err)
+ return err;
+ }
+
for (i = 0; i < tuple->encap_num; i++) {
switch (tuple->encap[i].proto) {
case htons(ETH_P_8021Q):
@@ -535,6 +590,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
{
struct flow_offload_tuple_rhash *tuplehash;
struct nf_flowtable *flow_table = priv;
+ struct flow_offload_tuple *other_tuple;
enum flow_offload_tuple_dir dir;
struct nf_flowtable_ctx ctx = {
.in = state->in,
@@ -543,6 +599,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
struct flow_offload *flow;
struct neighbour *neigh;
struct rtable *rt;
+ __be32 dest;
int ret;
tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
@@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
dir = tuplehash->tuple.dir;
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
+ other_tuple = &flow->tuplehash[!dir].tuple;
- if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
+ if (nf_flow_encap_push(state->net, skb, other_tuple))
return NF_DROP;
switch (tuplehash->tuple.xmit_type) {
@@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
flow_offload_teardown(flow);
return NF_DROP;
}
- neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
+ dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
+ : other_tuple->src_v4.s_addr;
+ neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, dest));
if (IS_ERR(neigh)) {
flow_offload_teardown(flow);
return NF_DROP;
diff --git a/net/netfilter/nf_flow_table_path.c b/net/netfilter/nf_flow_table_path.c
index 64e2672a3c3383bae896c4fb68ff9ab7489fe791..7d6668e4d42456404df4db9f512625ba985a2772 100644
--- a/net/netfilter/nf_flow_table_path.c
+++ b/net/netfilter/nf_flow_table_path.c
@@ -190,7 +190,46 @@ static bool nft_flowtable_find_dev(const struct net_device *dev,
return found;
}
-static void nft_dev_forward_path(struct nf_flow_route *route,
+static int nft_flow_tunnel_update_route(const struct nft_pktinfo *pkt,
+ struct flow_offload_tunnel *tun,
+ struct nf_flow_route *route,
+ enum ip_conntrack_dir dir)
+{
+ struct dst_entry *cur_dst = route->tuple[dir].dst;
+ struct dst_entry *tun_dst = NULL;
+ struct flowi fl = {};
+
+ switch (nft_pf(pkt)) {
+ case NFPROTO_IPV4:
+ fl.u.ip4.daddr = tun->dst_v4.s_addr;
+ fl.u.ip4.saddr = tun->src_v4.s_addr;
+ fl.u.ip4.flowi4_iif = nft_in(pkt)->ifindex;
+ fl.u.ip4.flowi4_dscp = ip4h_dscp(ip_hdr(pkt->skb));
+ fl.u.ip4.flowi4_mark = pkt->skb->mark;
+ fl.u.ip4.flowi4_flags = FLOWI_FLAG_ANYSRC;
+ break;
+ case NFPROTO_IPV6:
+ fl.u.ip6.daddr = tun->dst_v6;
+ fl.u.ip6.saddr = tun->src_v6;
+ fl.u.ip6.flowi6_iif = nft_in(pkt)->ifindex;
+ fl.u.ip6.flowlabel = ip6_flowinfo(ipv6_hdr(pkt->skb));
+ fl.u.ip6.flowi6_mark = pkt->skb->mark;
+ fl.u.ip6.flowi6_flags = FLOWI_FLAG_ANYSRC;
+ break;
+ }
+
+ nf_route(nft_net(pkt), &tun_dst, &fl, false, nft_pf(pkt));
+ if (!tun_dst)
+ return -ENOENT;
+
+ route->tuple[dir].dst = tun_dst;
+ dst_release(cur_dst);
+
+ return 0;
+}
+
+static void nft_dev_forward_path(const struct nft_pktinfo *pkt,
+ struct nf_flow_route *route,
const struct nf_conn *ct,
enum ip_conntrack_dir dir,
struct nft_flowtable *ft)
@@ -213,7 +252,8 @@ static void nft_dev_forward_path(struct nf_flow_route *route,
route->tuple[!dir].in.encap[i].proto = info.encap[i].proto;
}
- if (info.num_tuns) {
+ if (info.num_tuns &&
+ !nft_flow_tunnel_update_route(pkt, &info.tun, route, dir)) {
route->tuple[!dir].in.tun.src_v6 = info.tun.dst_v6;
route->tuple[!dir].in.tun.dst_v6 = info.tun.src_v6;
route->tuple[!dir].in.tun.l3_proto = info.tun.l3_proto;
@@ -274,9 +314,9 @@ int nft_flow_route(const struct nft_pktinfo *pkt, const struct nf_conn *ct,
nft_default_forward_path(route, other_dst, !dir);
if (route->tuple[dir].xmit_type == FLOW_OFFLOAD_XMIT_NEIGH)
- nft_dev_forward_path(route, ct, dir, ft);
+ nft_dev_forward_path(pkt, route, ct, dir, ft);
if (route->tuple[!dir].xmit_type == FLOW_OFFLOAD_XMIT_NEIGH)
- nft_dev_forward_path(route, ct, !dir, ft);
+ nft_dev_forward_path(pkt, route, ct, !dir, ft);
return 0;
}
--
2.51.1
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-07 11:14 ` [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx " Lorenzo Bianconi
@ 2025-11-12 12:55 ` Pablo Neira Ayuso
2025-11-12 16:02 ` Lorenzo Bianconi
0 siblings, 1 reply; 12+ messages in thread
From: Pablo Neira Ayuso @ 2025-11-12 12:55 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 1264 bytes --]
Hi Lorenzo,
On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
[...]
> @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
>
> dir = tuplehash->tuple.dir;
> flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> + other_tuple = &flow->tuplehash[!dir].tuple;
>
> - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> + if (nf_flow_encap_push(state->net, skb, other_tuple))
> return NF_DROP;
>
> switch (tuplehash->tuple.xmit_type) {
> @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> flow_offload_teardown(flow);
> return NF_DROP;
> }
> - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> + : other_tuple->src_v4.s_addr;
I think this can be simplified if my series use the ip_hdr(skb)->daddr
for rt_nexthop(), see attached patch. This would be fetched _before_
pushing the tunnel and layer 2 encapsulation headers. Then, there is
no need to fetch other_tuple and check if tun_num is greater than
zero.
See my sketch patch, I am going to give this a try, if this is
correct, I would need one more iteration from you.
[-- Attachment #2: update.patch --]
[-- Type: text/x-diff, Size: 1100 bytes --]
diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
index 8b74fb34998e..ff2b6c16c715 100644
--- a/net/netfilter/nf_flow_table_ip.c
+++ b/net/netfilter/nf_flow_table_ip.c
@@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
struct flow_offload *flow;
struct neighbour *neigh;
struct rtable *rt;
+ __be32 ip_dst;
int ret;
tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
@@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
dir = tuplehash->tuple.dir;
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
+ ip_dst = ip_hdr(skb)->daddr;
switch (tuplehash->tuple.xmit_type) {
case FLOW_OFFLOAD_XMIT_NEIGH:
@@ -458,7 +460,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
flow_offload_teardown(flow);
return NF_DROP;
}
- neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
+ neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, ip_dst));
if (IS_ERR(neigh)) {
flow_offload_teardown(flow);
return NF_DROP;
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-12 12:55 ` Pablo Neira Ayuso
@ 2025-11-12 16:02 ` Lorenzo Bianconi
2025-11-12 23:10 ` Pablo Neira Ayuso
0 siblings, 1 reply; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-12 16:02 UTC (permalink / raw)
To: Pablo Neira Ayuso
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 2799 bytes --]
> Hi Lorenzo,
Hi Pablo,
>
> On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
> [...]
> > @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> >
> > dir = tuplehash->tuple.dir;
> > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > + other_tuple = &flow->tuplehash[!dir].tuple;
> >
> > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > + if (nf_flow_encap_push(state->net, skb, other_tuple))
> > return NF_DROP;
> >
> > switch (tuplehash->tuple.xmit_type) {
> > @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > flow_offload_teardown(flow);
> > return NF_DROP;
> > }
> > - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> > + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> > + : other_tuple->src_v4.s_addr;
>
> I think this can be simplified if my series use the ip_hdr(skb)->daddr
> for rt_nexthop(), see attached patch. This would be fetched _before_
> pushing the tunnel and layer 2 encapsulation headers. Then, there is
> no need to fetch other_tuple and check if tun_num is greater than
> zero.
>
> See my sketch patch, I am going to give this a try, if this is
> correct, I would need one more iteration from you.
> diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> index 8b74fb34998e..ff2b6c16c715 100644
> --- a/net/netfilter/nf_flow_table_ip.c
> +++ b/net/netfilter/nf_flow_table_ip.c
> @@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> struct flow_offload *flow;
> struct neighbour *neigh;
> struct rtable *rt;
> + __be32 ip_dst;
> int ret;
>
> tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
> @@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
>
> dir = tuplehash->tuple.dir;
> flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> + ip_dst = ip_hdr(skb)->daddr;
I agree this patch will simplify my series (thx :)) but I guess we should move
ip_dst initialization after nf_flow_encap_push() since we need to route the
traffic according to the tunnel dst IP address, right?
Regards,
Lorenzo
>
> switch (tuplehash->tuple.xmit_type) {
> case FLOW_OFFLOAD_XMIT_NEIGH:
> @@ -458,7 +460,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> flow_offload_teardown(flow);
> return NF_DROP;
> }
> - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> + neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, ip_dst));
> if (IS_ERR(neigh)) {
> flow_offload_teardown(flow);
> return NF_DROP;
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-12 16:02 ` Lorenzo Bianconi
@ 2025-11-12 23:10 ` Pablo Neira Ayuso
2025-11-13 7:40 ` Lorenzo Bianconi
0 siblings, 1 reply; 12+ messages in thread
From: Pablo Neira Ayuso @ 2025-11-12 23:10 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
Hi Lorenzo,
On Wed, Nov 12, 2025 at 05:02:37PM +0100, Lorenzo Bianconi wrote:
[...]
> > On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
> > [...]
> > > @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > >
> > > dir = tuplehash->tuple.dir;
> > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > + other_tuple = &flow->tuplehash[!dir].tuple;
> > >
> > > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > > + if (nf_flow_encap_push(state->net, skb, other_tuple))
> > > return NF_DROP;
> > >
> > > switch (tuplehash->tuple.xmit_type) {
> > > @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > flow_offload_teardown(flow);
> > > return NF_DROP;
> > > }
> > > - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> > > + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> > > + : other_tuple->src_v4.s_addr;
> >
> > I think this can be simplified if my series use the ip_hdr(skb)->daddr
> > for rt_nexthop(), see attached patch. This would be fetched _before_
> > pushing the tunnel and layer 2 encapsulation headers. Then, there is
> > no need to fetch other_tuple and check if tun_num is greater than
> > zero.
> >
> > See my sketch patch, I am going to give this a try, if this is
> > correct, I would need one more iteration from you.
> >
> > diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> > index 8b74fb34998e..ff2b6c16c715 100644
> > --- a/net/netfilter/nf_flow_table_ip.c
> > +++ b/net/netfilter/nf_flow_table_ip.c
> > @@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > struct flow_offload *flow;
> > struct neighbour *neigh;
> > struct rtable *rt;
> > + __be32 ip_dst;
> > int ret;
> >
> > tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
> > @@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> >
> > dir = tuplehash->tuple.dir;
> > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > + ip_dst = ip_hdr(skb)->daddr;
>
> I agree this patch will simplify my series (thx :)) but I guess we should move
> ip_dst initialization after nf_flow_encap_push() since we need to route the
> traffic according to the tunnel dst IP address, right?
Right, I made a quick edit, it looks like this:
@@ -566,9 +624,14 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
dir = tuplehash->tuple.dir;
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
+ other_tuple = &flow->tuplehash[!dir].tuple;
+
+ if (nf_flow_tunnel_push(skb, other_tuple) < 0)
+ return NF_DROP;
+
ip_daddr = ip_hdr(skb)->daddr;
- if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
+ if (nf_flow_encap_push(skb, other_tuple) < 0)
return NF_DROP;
switch (tuplehash->tuple.xmit_type) {
That is, after tunnel header push but before pushing l2 encap (that
could possibly modify skb_network_header pointer), fetch the
destination address.
I made a few more comestic edits on your series and I pushed them out
to this branch:
https://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git/log/?h=flowtable-consolidate-xmit%2bipip
I just noticed, in nf_flow_tunnel_ipip_push(), that this can be removed:
memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
because this packet never entered the IP layer, the flowtable takes it
before it can get there.
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-12 23:10 ` Pablo Neira Ayuso
@ 2025-11-13 7:40 ` Lorenzo Bianconi
2025-11-17 22:54 ` Pablo Neira Ayuso
0 siblings, 1 reply; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-13 7:40 UTC (permalink / raw)
To: Pablo Neira Ayuso
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 4017 bytes --]
> Hi Lorenzo,
Hi Pablo,
>
> On Wed, Nov 12, 2025 at 05:02:37PM +0100, Lorenzo Bianconi wrote:
> [...]
> > > On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
> > > [...]
> > > > @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > >
> > > > dir = tuplehash->tuple.dir;
> > > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > > + other_tuple = &flow->tuplehash[!dir].tuple;
> > > >
> > > > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > > > + if (nf_flow_encap_push(state->net, skb, other_tuple))
> > > > return NF_DROP;
> > > >
> > > > switch (tuplehash->tuple.xmit_type) {
> > > > @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > flow_offload_teardown(flow);
> > > > return NF_DROP;
> > > > }
> > > > - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> > > > + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> > > > + : other_tuple->src_v4.s_addr;
> > >
> > > I think this can be simplified if my series use the ip_hdr(skb)->daddr
> > > for rt_nexthop(), see attached patch. This would be fetched _before_
> > > pushing the tunnel and layer 2 encapsulation headers. Then, there is
> > > no need to fetch other_tuple and check if tun_num is greater than
> > > zero.
> > >
> > > See my sketch patch, I am going to give this a try, if this is
> > > correct, I would need one more iteration from you.
> > >
> > > diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> > > index 8b74fb34998e..ff2b6c16c715 100644
> > > --- a/net/netfilter/nf_flow_table_ip.c
> > > +++ b/net/netfilter/nf_flow_table_ip.c
> > > @@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > struct flow_offload *flow;
> > > struct neighbour *neigh;
> > > struct rtable *rt;
> > > + __be32 ip_dst;
> > > int ret;
> > >
> > > tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
> > > @@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > >
> > > dir = tuplehash->tuple.dir;
> > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > + ip_dst = ip_hdr(skb)->daddr;
> >
> > I agree this patch will simplify my series (thx :)) but I guess we should move
> > ip_dst initialization after nf_flow_encap_push() since we need to route the
> > traffic according to the tunnel dst IP address, right?
>
> Right, I made a quick edit, it looks like this:
>
> @@ -566,9 +624,14 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
>
> dir = tuplehash->tuple.dir;
> flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> + other_tuple = &flow->tuplehash[!dir].tuple;
> +
> + if (nf_flow_tunnel_push(skb, other_tuple) < 0)
> + return NF_DROP;
> +
> ip_daddr = ip_hdr(skb)->daddr;
>
> - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> + if (nf_flow_encap_push(skb, other_tuple) < 0)
> return NF_DROP;
>
> switch (tuplehash->tuple.xmit_type) {
>
> That is, after tunnel header push but before pushing l2 encap (that
> could possibly modify skb_network_header pointer), fetch the
> destination address.
>
> I made a few more comestic edits on your series and I pushed them out
> to this branch:
>
> https://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git/log/?h=flowtable-consolidate-xmit%2bipip
[
ack, I tested this branch and it works fine running my local tests. Thanks for
fixing pending bits.
Regards,
Lorenzo
>
> I just noticed, in nf_flow_tunnel_ipip_push(), that this can be removed:
>
> memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
>
> because this packet never entered the IP layer, the flowtable takes it
> before it can get there.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-13 7:40 ` Lorenzo Bianconi
@ 2025-11-17 22:54 ` Pablo Neira Ayuso
2025-11-17 23:53 ` Lorenzo Bianconi
0 siblings, 1 reply; 12+ messages in thread
From: Pablo Neira Ayuso @ 2025-11-17 22:54 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
On Thu, Nov 13, 2025 at 08:40:52AM +0100, Lorenzo Bianconi wrote:
> > Hi Lorenzo,
>
> Hi Pablo,
>
> >
> > On Wed, Nov 12, 2025 at 05:02:37PM +0100, Lorenzo Bianconi wrote:
> > [...]
> > > > On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
> > > > [...]
> > > > > @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > >
> > > > > dir = tuplehash->tuple.dir;
> > > > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > > > + other_tuple = &flow->tuplehash[!dir].tuple;
> > > > >
> > > > > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > > > > + if (nf_flow_encap_push(state->net, skb, other_tuple))
> > > > > return NF_DROP;
> > > > >
> > > > > switch (tuplehash->tuple.xmit_type) {
> > > > > @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > > flow_offload_teardown(flow);
> > > > > return NF_DROP;
> > > > > }
> > > > > - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> > > > > + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> > > > > + : other_tuple->src_v4.s_addr;
> > > >
> > > > I think this can be simplified if my series use the ip_hdr(skb)->daddr
> > > > for rt_nexthop(), see attached patch. This would be fetched _before_
> > > > pushing the tunnel and layer 2 encapsulation headers. Then, there is
> > > > no need to fetch other_tuple and check if tun_num is greater than
> > > > zero.
> > > >
> > > > See my sketch patch, I am going to give this a try, if this is
> > > > correct, I would need one more iteration from you.
> > > >
> > > > diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> > > > index 8b74fb34998e..ff2b6c16c715 100644
> > > > --- a/net/netfilter/nf_flow_table_ip.c
> > > > +++ b/net/netfilter/nf_flow_table_ip.c
> > > > @@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > struct flow_offload *flow;
> > > > struct neighbour *neigh;
> > > > struct rtable *rt;
> > > > + __be32 ip_dst;
> > > > int ret;
> > > >
> > > > tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
> > > > @@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > >
> > > > dir = tuplehash->tuple.dir;
> > > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > > + ip_dst = ip_hdr(skb)->daddr;
> > >
> > > I agree this patch will simplify my series (thx :)) but I guess we should move
> > > ip_dst initialization after nf_flow_encap_push() since we need to route the
> > > traffic according to the tunnel dst IP address, right?
> >
> > Right, I made a quick edit, it looks like this:
> >
> > @@ -566,9 +624,14 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> >
> > dir = tuplehash->tuple.dir;
> > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > + other_tuple = &flow->tuplehash[!dir].tuple;
> > +
> > + if (nf_flow_tunnel_push(skb, other_tuple) < 0)
> > + return NF_DROP;
> > +
> > ip_daddr = ip_hdr(skb)->daddr;
> >
> > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > + if (nf_flow_encap_push(skb, other_tuple) < 0)
> > return NF_DROP;
> >
> > switch (tuplehash->tuple.xmit_type) {
> >
> > That is, after tunnel header push but before pushing l2 encap (that
> > could possibly modify skb_network_header pointer), fetch the
> > destination address.
> >
> > I made a few more comestic edits on your series and I pushed them out
> > to this branch:
> >
> > https://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git/log/?h=flowtable-consolidate-xmit%2bipip
> [
>
> ack, I tested this branch and it works fine running my local tests. Thanks for
> fixing pending bits.
I need this one more little change below.
> > I just noticed, in nf_flow_tunnel_ipip_push(), that this can be removed:
> >
> > memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
> >
> > because this packet never entered the IP layer, the flowtable takes it
> > before it can get there.
I have removed this memset and pushed out a new branch:
flowtable-consolidate-xmit+ipip2
This should be good to go.
Thanks.
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-17 22:54 ` Pablo Neira Ayuso
@ 2025-11-17 23:53 ` Lorenzo Bianconi
2025-11-19 0:13 ` Pablo Neira Ayuso
0 siblings, 1 reply; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-17 23:53 UTC (permalink / raw)
To: Pablo Neira Ayuso
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 4701 bytes --]
> On Thu, Nov 13, 2025 at 08:40:52AM +0100, Lorenzo Bianconi wrote:
> > > Hi Lorenzo,
> >
> > Hi Pablo,
> >
> > >
> > > On Wed, Nov 12, 2025 at 05:02:37PM +0100, Lorenzo Bianconi wrote:
> > > [...]
> > > > > On Fri, Nov 07, 2025 at 12:14:47PM +0100, Lorenzo Bianconi wrote:
> > > > > [...]
> > > > > > @@ -565,8 +622,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > > >
> > > > > > dir = tuplehash->tuple.dir;
> > > > > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > > > > + other_tuple = &flow->tuplehash[!dir].tuple;
> > > > > >
> > > > > > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > > > > > + if (nf_flow_encap_push(state->net, skb, other_tuple))
> > > > > > return NF_DROP;
> > > > > >
> > > > > > switch (tuplehash->tuple.xmit_type) {
> > > > > > @@ -577,7 +635,9 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > > > flow_offload_teardown(flow);
> > > > > > return NF_DROP;
> > > > > > }
> > > > > > - neigh = ip_neigh_gw4(rt->dst.dev, rt_nexthop(rt, flow->tuplehash[!dir].tuple.src_v4.s_addr));
> > > > > > + dest = other_tuple->tun_num ? other_tuple->tun.src_v4.s_addr
> > > > > > + : other_tuple->src_v4.s_addr;
> > > > >
> > > > > I think this can be simplified if my series use the ip_hdr(skb)->daddr
> > > > > for rt_nexthop(), see attached patch. This would be fetched _before_
> > > > > pushing the tunnel and layer 2 encapsulation headers. Then, there is
> > > > > no need to fetch other_tuple and check if tun_num is greater than
> > > > > zero.
> > > > >
> > > > > See my sketch patch, I am going to give this a try, if this is
> > > > > correct, I would need one more iteration from you.
> > > > >
> > > > > diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> > > > > index 8b74fb34998e..ff2b6c16c715 100644
> > > > > --- a/net/netfilter/nf_flow_table_ip.c
> > > > > +++ b/net/netfilter/nf_flow_table_ip.c
> > > > > @@ -427,6 +427,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > > struct flow_offload *flow;
> > > > > struct neighbour *neigh;
> > > > > struct rtable *rt;
> > > > > + __be32 ip_dst;
> > > > > int ret;
> > > > >
> > > > > tuplehash = nf_flow_offload_lookup(&ctx, flow_table, skb);
> > > > > @@ -449,6 +450,7 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > > > >
> > > > > dir = tuplehash->tuple.dir;
> > > > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > > > + ip_dst = ip_hdr(skb)->daddr;
> > > >
> > > > I agree this patch will simplify my series (thx :)) but I guess we should move
> > > > ip_dst initialization after nf_flow_encap_push() since we need to route the
> > > > traffic according to the tunnel dst IP address, right?
> > >
> > > Right, I made a quick edit, it looks like this:
> > >
> > > @@ -566,9 +624,14 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> > >
> > > dir = tuplehash->tuple.dir;
> > > flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> > > + other_tuple = &flow->tuplehash[!dir].tuple;
> > > +
> > > + if (nf_flow_tunnel_push(skb, other_tuple) < 0)
> > > + return NF_DROP;
> > > +
> > > ip_daddr = ip_hdr(skb)->daddr;
> > >
> > > - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> > > + if (nf_flow_encap_push(skb, other_tuple) < 0)
> > > return NF_DROP;
> > >
> > > switch (tuplehash->tuple.xmit_type) {
> > >
> > > That is, after tunnel header push but before pushing l2 encap (that
> > > could possibly modify skb_network_header pointer), fetch the
> > > destination address.
> > >
> > > I made a few more comestic edits on your series and I pushed them out
> > > to this branch:
> > >
> > > https://git.kernel.org/pub/scm/linux/kernel/git/netfilter/nf-next.git/log/?h=flowtable-consolidate-xmit%2bipip
> > [
> >
> > ack, I tested this branch and it works fine running my local tests. Thanks for
> > fixing pending bits.
>
> I need this one more little change below.
>
> > > I just noticed, in nf_flow_tunnel_ipip_push(), that this can be removed:
> > >
> > > memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
> > >
> > > because this packet never entered the IP layer, the flowtable takes it
> > > before it can get there.
>
> I have removed this memset and pushed out a new branch:
>
> flowtable-consolidate-xmit+ipip2
ack, it works fine for me.
Regards,
Lorenzo
>
> This should be good to go.
>
> Thanks.
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-17 23:53 ` Lorenzo Bianconi
@ 2025-11-19 0:13 ` Pablo Neira Ayuso
2025-11-19 11:19 ` Lorenzo Bianconi
0 siblings, 1 reply; 12+ messages in thread
From: Pablo Neira Ayuso @ 2025-11-19 0:13 UTC (permalink / raw)
To: Lorenzo Bianconi
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 466 bytes --]
Hi Lorenzo,
I found one more issue: caching the ip6 daddr does not work because
skb_cow_head() can reallocate the skb header, invalidating all
pointers.
I went back to use the other_tuple, it is safer, new branch:
flowtable-consolidate-xmit+ipip3
Hopefully, this is the last iteration for this series.
I am attaching a diff that compares flowtable-consolidate-xmit+ipip2
vs. flowtable-consolidate-xmit+ipip3 branches.
I also made a few cosmetic edits.
[-- Attachment #2: diff-v2-v3.patch --]
[-- Type: text/x-diff, Size: 3099 bytes --]
diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
index ee81ee3a5110..e128b0fe9a7b 100644
--- a/net/netfilter/nf_flow_table_ip.c
+++ b/net/netfilter/nf_flow_table_ip.c
@@ -512,13 +512,14 @@ static int nf_flow_pppoe_push(struct sk_buff *skb, u16 id)
}
static int nf_flow_tunnel_ipip_push(struct net *net, struct sk_buff *skb,
- struct flow_offload_tuple *tuple)
+ struct flow_offload_tuple *tuple,
+ __be32 *ip_daddr)
{
struct iphdr *iph = (struct iphdr *)skb_network_header(skb);
struct rtable *rt = dst_rtable(tuple->dst_cache);
- __be16 frag_off = iph->frag_off;
- u32 headroom = sizeof(*iph);
u8 tos = iph->tos, ttl = iph->ttl;
+ __be16 frag_off = iph->frag_off;
+ u32 headroom = sizeof(*iph);
int err;
err = iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4);
@@ -551,14 +552,17 @@ static int nf_flow_tunnel_ipip_push(struct net *net, struct sk_buff *skb,
__ip_select_ident(net, iph, skb_shinfo(skb)->gso_segs ?: 1);
ip_send_check(iph);
+ *ip_daddr = tuple->tun.src_v4.s_addr;
+
return 0;
}
static int nf_flow_tunnel_v4_push(struct net *net, struct sk_buff *skb,
- struct flow_offload_tuple *tuple)
+ struct flow_offload_tuple *tuple,
+ __be32 *ip_daddr)
{
if (tuple->tun_num)
- return nf_flow_tunnel_ipip_push(net, skb, tuple);
+ return nf_flow_tunnel_ipip_push(net, skb, tuple, ip_daddr);
return 0;
}
@@ -572,7 +576,8 @@ static int nf_flow_encap_push(struct sk_buff *skb,
switch (tuple->encap[i].proto) {
case htons(ETH_P_8021Q):
case htons(ETH_P_8021AD):
- if (skb_vlan_push(skb, tuple->encap[i].proto, tuple->encap[i].id) < 0)
+ if (skb_vlan_push(skb, tuple->encap[i].proto,
+ tuple->encap[i].id) < 0)
return -1;
break;
case htons(ETH_P_PPP_SES):
@@ -624,12 +629,11 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
dir = tuplehash->tuple.dir;
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
other_tuple = &flow->tuplehash[!dir].tuple;
+ ip_daddr = other_tuple->src_v4.s_addr;
- if (nf_flow_tunnel_v4_push(state->net, skb, other_tuple) < 0)
+ if (nf_flow_tunnel_v4_push(state->net, skb, other_tuple, &ip_daddr) < 0)
return NF_DROP;
- ip_daddr = ip_hdr(skb)->daddr;
-
if (nf_flow_encap_push(skb, other_tuple) < 0)
return NF_DROP;
@@ -906,6 +910,7 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,
{
struct flow_offload_tuple_rhash *tuplehash;
struct nf_flowtable *flow_table = priv;
+ struct flow_offload_tuple *other_tuple;
enum flow_offload_tuple_dir dir;
struct nf_flowtable_ctx ctx = {
.in = state->in,
@@ -937,9 +942,10 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,
dir = tuplehash->tuple.dir;
flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
- ip6_daddr = &ipv6_hdr(skb)->daddr;
+ other_tuple = &flow->tuplehash[!dir].tuple;
+ ip6_daddr = &other_tuple->src_v6;
- if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
+ if (nf_flow_encap_push(skb, other_tuple) < 0)
return NF_DROP;
switch (tuplehash->tuple.xmit_type) {
^ permalink raw reply related [flat|nested] 12+ messages in thread* Re: [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx sw acceleration
2025-11-19 0:13 ` Pablo Neira Ayuso
@ 2025-11-19 11:19 ` Lorenzo Bianconi
0 siblings, 0 replies; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-19 11:19 UTC (permalink / raw)
To: Pablo Neira Ayuso
Cc: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Jozsef Kadlecsik, Shuah Khan,
Andrew Lunn, Phil Sutter, Florian Westphal, netdev,
netfilter-devel, coreteam, linux-kselftest
[-- Attachment #1: Type: text/plain, Size: 4067 bytes --]
> Hi Lorenzo,
>
> I found one more issue: caching the ip6 daddr does not work because
> skb_cow_head() can reallocate the skb header, invalidating all
> pointers.
>
> I went back to use the other_tuple, it is safer, new branch:
>
> flowtable-consolidate-xmit+ipip3
Hi Pablo,
thx for fixing it. I tested the branch above and it works fine with IPIP tunnel
flowtable offloading.
>
> Hopefully, this is the last iteration for this series.
>
> I am attaching a diff that compares flowtable-consolidate-xmit+ipip2
> vs. flowtable-consolidate-xmit+ipip3 branches.
>
> I also made a few cosmetic edits.
> diff --git a/net/netfilter/nf_flow_table_ip.c b/net/netfilter/nf_flow_table_ip.c
> index ee81ee3a5110..e128b0fe9a7b 100644
> --- a/net/netfilter/nf_flow_table_ip.c
> +++ b/net/netfilter/nf_flow_table_ip.c
> @@ -512,13 +512,14 @@ static int nf_flow_pppoe_push(struct sk_buff *skb, u16 id)
> }
>
> static int nf_flow_tunnel_ipip_push(struct net *net, struct sk_buff *skb,
> - struct flow_offload_tuple *tuple)
> + struct flow_offload_tuple *tuple,
> + __be32 *ip_daddr)
> {
> struct iphdr *iph = (struct iphdr *)skb_network_header(skb);
> struct rtable *rt = dst_rtable(tuple->dst_cache);
> - __be16 frag_off = iph->frag_off;
> - u32 headroom = sizeof(*iph);
> u8 tos = iph->tos, ttl = iph->ttl;
> + __be16 frag_off = iph->frag_off;
> + u32 headroom = sizeof(*iph);
> int err;
>
> err = iptunnel_handle_offloads(skb, SKB_GSO_IPXIP4);
> @@ -551,14 +552,17 @@ static int nf_flow_tunnel_ipip_push(struct net *net, struct sk_buff *skb,
> __ip_select_ident(net, iph, skb_shinfo(skb)->gso_segs ?: 1);
> ip_send_check(iph);
>
> + *ip_daddr = tuple->tun.src_v4.s_addr;
> +
> return 0;
> }
>
> static int nf_flow_tunnel_v4_push(struct net *net, struct sk_buff *skb,
> - struct flow_offload_tuple *tuple)
> + struct flow_offload_tuple *tuple,
> + __be32 *ip_daddr)
> {
> if (tuple->tun_num)
> - return nf_flow_tunnel_ipip_push(net, skb, tuple);
> + return nf_flow_tunnel_ipip_push(net, skb, tuple, ip_daddr);
>
> return 0;
> }
> @@ -572,7 +576,8 @@ static int nf_flow_encap_push(struct sk_buff *skb,
> switch (tuple->encap[i].proto) {
> case htons(ETH_P_8021Q):
> case htons(ETH_P_8021AD):
> - if (skb_vlan_push(skb, tuple->encap[i].proto, tuple->encap[i].id) < 0)
> + if (skb_vlan_push(skb, tuple->encap[i].proto,
> + tuple->encap[i].id) < 0)
> return -1;
> break;
> case htons(ETH_P_PPP_SES):
> @@ -624,12 +629,11 @@ nf_flow_offload_ip_hook(void *priv, struct sk_buff *skb,
> dir = tuplehash->tuple.dir;
> flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> other_tuple = &flow->tuplehash[!dir].tuple;
> + ip_daddr = other_tuple->src_v4.s_addr;
>
> - if (nf_flow_tunnel_v4_push(state->net, skb, other_tuple) < 0)
> + if (nf_flow_tunnel_v4_push(state->net, skb, other_tuple, &ip_daddr) < 0)
> return NF_DROP;
>
> - ip_daddr = ip_hdr(skb)->daddr;
> -
> if (nf_flow_encap_push(skb, other_tuple) < 0)
> return NF_DROP;
>
> @@ -906,6 +910,7 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,
> {
> struct flow_offload_tuple_rhash *tuplehash;
> struct nf_flowtable *flow_table = priv;
> + struct flow_offload_tuple *other_tuple;
> enum flow_offload_tuple_dir dir;
> struct nf_flowtable_ctx ctx = {
> .in = state->in,
> @@ -937,9 +942,10 @@ nf_flow_offload_ipv6_hook(void *priv, struct sk_buff *skb,
>
> dir = tuplehash->tuple.dir;
> flow = container_of(tuplehash, struct flow_offload, tuplehash[dir]);
> - ip6_daddr = &ipv6_hdr(skb)->daddr;
> + other_tuple = &flow->tuplehash[!dir].tuple;
> + ip6_daddr = &other_tuple->src_v6;
>
> - if (nf_flow_encap_push(skb, &flow->tuplehash[!dir].tuple) < 0)
> + if (nf_flow_encap_push(skb, other_tuple) < 0)
> return NF_DROP;
>
> switch (tuplehash->tuple.xmit_type) {
ack, the above changes are fine to me.
Regards,
Lorenzo
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 228 bytes --]
^ permalink raw reply [flat|nested] 12+ messages in thread
* [PATCH nf-next v9 3/3] selftests: netfilter: nft_flowtable.sh: Add IPIP flowtable selftest
2025-11-07 11:14 [PATCH nf-next v9 0/3] Add IPIP flowtable SW acceleration Lorenzo Bianconi
2025-11-07 11:14 ` [PATCH nf-next v9 1/3] net: netfilter: Add IPIP flowtable rx sw acceleration Lorenzo Bianconi
2025-11-07 11:14 ` [PATCH nf-next v9 2/3] net: netfilter: Add IPIP flowtable tx " Lorenzo Bianconi
@ 2025-11-07 11:14 ` Lorenzo Bianconi
2 siblings, 0 replies; 12+ messages in thread
From: Lorenzo Bianconi @ 2025-11-07 11:14 UTC (permalink / raw)
To: David S. Miller, David Ahern, Eric Dumazet, Jakub Kicinski,
Paolo Abeni, Simon Horman, Pablo Neira Ayuso, Jozsef Kadlecsik,
Shuah Khan, Andrew Lunn, Phil Sutter
Cc: Florian Westphal, netdev, netfilter-devel, coreteam,
linux-kselftest, Lorenzo Bianconi
Introduce specific selftest for IPIP flowtable SW acceleration in
nft_flowtable.sh
Signed-off-by: Lorenzo Bianconi <lorenzo@kernel.org>
---
.../selftests/net/netfilter/nft_flowtable.sh | 69 ++++++++++++++++++++++
1 file changed, 69 insertions(+)
diff --git a/tools/testing/selftests/net/netfilter/nft_flowtable.sh b/tools/testing/selftests/net/netfilter/nft_flowtable.sh
index 45832df982950c2164dcb6637497870f0d3daefe..1fbfc8ad8dcdc5db2ab1a1ea9310f655d09eee83 100755
--- a/tools/testing/selftests/net/netfilter/nft_flowtable.sh
+++ b/tools/testing/selftests/net/netfilter/nft_flowtable.sh
@@ -558,6 +558,73 @@ if ! test_tcp_forwarding_nat "$ns1" "$ns2" 1 ""; then
ip netns exec "$nsr1" nft list ruleset
fi
+# IPIP tunnel test:
+# Add IPIP tunnel interfaces and check flowtable acceleration.
+test_ipip() {
+if ! ip -net "$nsr1" link add name tun0 type ipip \
+ local 192.168.10.1 remote 192.168.10.2 >/dev/null;then
+ echo "SKIP: could not add ipip tunnel"
+ [ "$ret" -eq 0 ] && ret=$ksft_skip
+ return
+fi
+ip -net "$nsr1" link set tun0 up
+ip -net "$nsr1" addr add 192.168.100.1/24 dev tun0
+ip netns exec "$nsr1" sysctl net.ipv4.conf.tun0.forwarding=1 > /dev/null
+
+ip -net "$nsr2" link add name tun0 type ipip local 192.168.10.2 remote 192.168.10.1
+ip -net "$nsr2" link set tun0 up
+ip -net "$nsr2" addr add 192.168.100.2/24 dev tun0
+ip netns exec "$nsr2" sysctl net.ipv4.conf.tun0.forwarding=1 > /dev/null
+
+ip -net "$nsr1" route change default via 192.168.100.2
+ip -net "$nsr2" route change default via 192.168.100.1
+ip -net "$ns2" route add default via 10.0.2.1
+
+ip netns exec "$nsr1" nft -a insert rule inet filter forward 'meta oif tun0 accept'
+ip netns exec "$nsr1" nft -a insert rule inet filter forward \
+ 'meta oif "veth0" tcp sport 12345 ct mark set 1 flow add @f1 counter name routed_repl accept'
+
+if ! test_tcp_forwarding_nat "$ns1" "$ns2" 1 "IPIP tunnel"; then
+ echo "FAIL: flow offload for ns1/ns2 with IPIP tunnel" 1>&2
+ ip netns exec "$nsr1" nft list ruleset
+ ret=1
+fi
+
+# Create vlan tagged devices for IPIP traffic.
+ip -net "$nsr1" link add link veth1 name veth1.10 type vlan id 10
+ip -net "$nsr1" link set veth1.10 up
+ip -net "$nsr1" addr add 192.168.20.1/24 dev veth1.10
+ip netns exec "$nsr1" sysctl net.ipv4.conf.veth1/10.forwarding=1 > /dev/null
+ip netns exec "$nsr1" nft -a insert rule inet filter forward 'meta oif veth1.10 accept'
+ip -net "$nsr1" link add name tun1 type ipip local 192.168.20.1 remote 192.168.20.2
+ip -net "$nsr1" link set tun1 up
+ip -net "$nsr1" addr add 192.168.200.1/24 dev tun1
+ip -net "$nsr1" route change default via 192.168.200.2
+ip netns exec "$nsr1" sysctl net.ipv4.conf.tun1.forwarding=1 > /dev/null
+ip netns exec "$nsr1" nft -a insert rule inet filter forward 'meta oif tun1 accept'
+
+ip -net "$nsr2" link add link veth0 name veth0.10 type vlan id 10
+ip -net "$nsr2" link set veth0.10 up
+ip -net "$nsr2" addr add 192.168.20.2/24 dev veth0.10
+ip netns exec "$nsr2" sysctl net.ipv4.conf.veth0/10.forwarding=1 > /dev/null
+ip -net "$nsr2" link add name tun1 type ipip local 192.168.20.2 remote 192.168.20.1
+ip -net "$nsr2" link set tun1 up
+ip -net "$nsr2" addr add 192.168.200.2/24 dev tun1
+ip -net "$nsr2" route change default via 192.168.200.1
+ip netns exec "$nsr2" sysctl net.ipv4.conf.tun1.forwarding=1 > /dev/null
+
+if ! test_tcp_forwarding_nat "$ns1" "$ns2" 1 "IPIP tunnel over vlan"; then
+ echo "FAIL: flow offload for ns1/ns2 with IPIP tunnel over vlan" 1>&2
+ ip netns exec "$nsr1" nft list ruleset
+ ret=1
+fi
+
+# Restore the previous configuration
+ip -net "$nsr1" route change default via 192.168.10.2
+ip -net "$nsr2" route change default via 192.168.10.1
+ip -net "$ns2" route del default via 10.0.2.1
+}
+
# Another test:
# Add bridge interface br0 to Router1, with NAT enabled.
test_bridge() {
@@ -643,6 +710,8 @@ ip -net "$nsr1" addr add dead:1::1/64 dev veth0 nodad
ip -net "$nsr1" link set up dev veth0
}
+test_ipip
+
test_bridge
KEY_SHA="0x"$(ps -af | sha1sum | cut -d " " -f 1)
--
2.51.1
^ permalink raw reply related [flat|nested] 12+ messages in thread