sieni
/
linux
mirror of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

geneve: add GRO hint output path 

If a geneve egress packet contains nested UDP encap headers, add a geneve
option including the information necessary on the RX side to perform GRO
aggregation of the whole packets: the nested network and transport headers,
and the nested protocol type.

Use geneve option class `netdev`, already registered in the Network
Virtualization Overlay (NVO3) IANA registry:

https://www.iana.org/assignments/nvo3/nvo3.xhtml#Linux-NetDev.

To pass the GRO hint information across the different xmit path functions,
store them in the skb control buffer, to avoid adding additional arguments.

Signed-off-by: Paolo Abeni <pabeni@redhat.com>
Link: https://patch.msgid.link/aa614567f7bdb776d693041375bede4990a19649.1769011015.git.pabeni@redhat.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
This commit is contained in:
Paolo Abeni 2026-01-21 17:11:33 +01:00 committed by Jakub Kicinski
parent 1da80d91bd
commit e0a12cbf26
1 changed files with 120 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
drivers/net/geneve.c
View File

@ -38,6 +38,26 @@ MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
#define GENEVE_IPV4_HLEN (ETH_HLEN + sizeof(struct iphdr) + GENEVE_BASE_HLEN)
#define GENEVE_IPV6_HLEN (ETH_HLEN + sizeof(struct ipv6hdr) + GENEVE_BASE_HLEN)
#define GENEVE_OPT_NETDEV_CLASS 0x100
#define GENEVE_OPT_GRO_HINT_SIZE 8
#define GENEVE_OPT_GRO_HINT_TYPE 1
#define GENEVE_OPT_GRO_HINT_LEN 1
struct geneve_opt_gro_hint {
u8 inner_proto_id:2,
nested_is_v6:1;
u8 nested_nh_offset;
u8 nested_tp_offset;
u8 nested_hdr_len;
};
struct geneve_skb_cb {
unsigned int gro_hint_len;
struct geneve_opt_gro_hint gro_hint;
};
#define GENEVE_SKB_CB(__skb) ((struct geneve_skb_cb *)&((__skb)->cb[0]))
/* per-network namespace private data for this module */
struct geneve_net {
struct list_head geneve_list;
@ -93,6 +113,21 @@ struct geneve_sock {
struct hlist_head vni_list[VNI_HASH_SIZE];
};
static const __be16 proto_id_map[] = { htons(ETH_P_TEB),
htons(ETH_P_IPV6),
htons(ETH_P_IP) };
static int proto_to_id(__be16 proto)
{
int i;
for (i = 0; i < ARRAY_SIZE(proto_id_map); i++)
if (proto_id_map[i] == proto)
return i;
return -1;
}
static inline __u32 geneve_net_vni_hash(u8 vni[3])
{
__u32 vnid;
@ -773,6 +808,78 @@ static void geneve_build_header(struct genevehdr *geneveh,
ip_tunnel_info_opts_get(geneveh->options, info);
}
static int geneve_build_gro_hint_opt(const struct geneve_dev *geneve,
struct sk_buff *skb)
{
struct geneve_skb_cb *cb = GENEVE_SKB_CB(skb);
struct geneve_opt_gro_hint *hint;
unsigned int nhlen;
bool nested_is_v6;
int id;
BUILD_BUG_ON(sizeof(skb->cb) < sizeof(struct geneve_skb_cb));
cb->gro_hint_len = 0;
/* Try to add the GRO hint only in case of double encap. */
if (!geneve->cfg.gro_hint || !skb->encapsulation)
return 0;
/*
* The nested headers must fit the geneve opt len fields and the
* nested encap must carry a nested transport (UDP) header.
*/
nhlen = skb_inner_mac_header(skb) - skb->data;
if (nhlen > 255 || !skb_transport_header_was_set(skb) ||
skb->inner_protocol_type != ENCAP_TYPE_ETHER ||
(skb_transport_offset(skb) + sizeof(struct udphdr) > nhlen))
return 0;
id = proto_to_id(skb->inner_protocol);
if (id < 0)
return 0;
nested_is_v6 = skb->protocol == htons(ETH_P_IPV6);
if (nested_is_v6) {
int start = skb_network_offset(skb) + sizeof(struct ipv6hdr);
u8 proto = ipv6_hdr(skb)->nexthdr;
__be16 foff;
if (ipv6_skip_exthdr(skb, start, &proto, &foff) < 0 ||
proto != IPPROTO_UDP)
return 0;
} else {
if (ip_hdr(skb)->protocol != IPPROTO_UDP)
return 0;
}
hint = &cb->gro_hint;
memset(hint, 0, sizeof(*hint));
hint->inner_proto_id = id;
hint->nested_is_v6 = skb->protocol == htons(ETH_P_IPV6);
hint->nested_nh_offset = skb_network_offset(skb);
hint->nested_tp_offset = skb_transport_offset(skb);
hint->nested_hdr_len = nhlen;
cb->gro_hint_len = GENEVE_OPT_GRO_HINT_SIZE;
return GENEVE_OPT_GRO_HINT_SIZE;
}
static void geneve_put_gro_hint_opt(struct genevehdr *gnvh, int opt_size,
const struct geneve_opt_gro_hint *hint)
{
struct geneve_opt *gro_opt;
/* geneve_build_header() did not took in account the GRO hint. */
gnvh->opt_len = (opt_size + GENEVE_OPT_GRO_HINT_SIZE) >> 2;
gro_opt = (void *)(gnvh + 1) + opt_size;
memset(gro_opt, 0, sizeof(*gro_opt));
gro_opt->opt_class = htons(GENEVE_OPT_NETDEV_CLASS);
gro_opt->type = GENEVE_OPT_GRO_HINT_TYPE;
gro_opt->length = GENEVE_OPT_GRO_HINT_LEN;
memcpy(gro_opt + 1, hint, sizeof(*hint));
}
static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
const struct ip_tunnel_info *info,
const struct geneve_dev *geneve, int ip_hdr_len)
@ -780,17 +887,20 @@ static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
bool udp_sum = test_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags);
bool inner_proto_inherit = geneve->cfg.inner_proto_inherit;
bool xnet = !net_eq(geneve->net, dev_net(geneve->dev));
struct geneve_skb_cb *cb = GENEVE_SKB_CB(skb);
struct genevehdr *gnvh;
__be16 inner_proto;
bool double_encap;
int min_headroom;
int opt_size;
int err;
skb_reset_mac_header(skb);
skb_scrub_packet(skb, xnet);
opt_size = info->options_len + cb->gro_hint_len;
min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
GENEVE_BASE_HLEN + info->options_len + ip_hdr_len;
GENEVE_BASE_HLEN + opt_size + ip_hdr_len;
err = skb_cow_head(skb, min_headroom);
if (unlikely(err))
goto free_dst;
@ -800,9 +910,13 @@ static int geneve_build_skb(struct dst_entry *dst, struct sk_buff *skb,
if (err)
goto free_dst;
gnvh = __skb_push(skb, sizeof(*gnvh) + info->options_len);
gnvh = __skb_push(skb, sizeof(*gnvh) + opt_size);
inner_proto = inner_proto_inherit ? skb->protocol : htons(ETH_P_TEB);
geneve_build_header(gnvh, info, inner_proto);
if (cb->gro_hint_len)
geneve_put_gro_hint_opt(gnvh, info->options_len, &cb->gro_hint);
udp_tunnel_set_inner_protocol(skb, double_encap, inner_proto);
return 0;
@ -862,7 +976,8 @@ static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev,
return PTR_ERR(rt);
err = skb_tunnel_check_pmtu(skb, &rt->dst,
GENEVE_IPV4_HLEN + info->options_len,
GENEVE_IPV4_HLEN + info->options_len +
geneve_build_gro_hint_opt(geneve, skb),
netif_is_any_bridge_port(dev));
if (err < 0) {
dst_release(&rt->dst);
@ -972,7 +1087,8 @@ static int geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
return PTR_ERR(dst);
err = skb_tunnel_check_pmtu(skb, dst,
GENEVE_IPV6_HLEN + info->options_len,
GENEVE_IPV6_HLEN + info->options_len +
geneve_build_gro_hint_opt(geneve, skb),
netif_is_any_bridge_port(dev));
if (err < 0) {
dst_release(dst);