net: add gro frag support to udp tunnel api
Subsystems (3)
RFC 1/1 net: add gro frag support to udp tunnel api
Hi Steffen,
This is very much a "RFC", in that the code here is fodder for discussion more than something I'm seriously proposing at the moment. I'm writing to you specifically because I recall us having discussed something like this a while ago and you being interested.
WireGuard would benefit from getting lists of SKBs all together in a bunch on the receive side. At the moment, encap_rcv splits them apart one by one before giving them to the API. This patch proposes a way to opt-in to receiving them before they've been split. The solution involves adding an encap_type flag that enables calling the encap_rcv function earlier before the skbs have been split apart.
I worry that it's not this straight forward, however, because of this function below called, "udp_unexpected_gso". It looks like there's a fast path for the case when it doesn't need to be split apart, and that if it is already split apart, that's expected, whereas splitting it apart would be "unexpected." I'm not too familiar with this code. Do you know off hand why this would be unexpected? And does that imply that a proper implementation of this might be a bit more involved? Or is the naming just silly and this actually is _the_ path where this happens?
The other thing I'm wondering with regards to this is how you even hit this path. So far I've only been able to hit it with the out of tree Qualcom driver, "rmnet_perf". I saw a mailing list discussion a few years ago about adding some flags to be able to simulate this with veth, but I didn't see that go anywhere. Figuring out how I can test this is probably a good idea before proceeding further.
Finally, and most importantly, is this overlapping with something you're working on at the moment? Where do you stand with this? Did you wind up solving your own use cases in a different way, or are you sitting on a more proper version of this RFC or something else?
Regards,
Jason
--- include/uapi/linux/udp.h | 1 + net/ipv4/udp.c | 10 ++++++++++ 2 files changed, 11 insertions(+)
include/uapi/linux/udp.h +1 -0
@@ -42,5 +42,6 @@ struct udphdr {#define UDP_ENCAP_GTP0 4/* GSM TS 09.60 */ #define UDP_ENCAP_GTP1U 5/* 3GPP TS 29.060 */ #define UDP_ENCAP_RXRPC 6 +#define UDP_ENCAP_SUPPORT_GRO_FRAGS (1UL << 31)#endif /* _UAPI_LINUX_UDP_H */
net/ipv4/udp.c +10 -0
@@ -2095,9 +2095,19 @@ static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb)static int udp_queue_rcv_skb (struct sock *sk,struct sk_buff *skb) { +int (*encap_rcv_gro)(struct sock *sk,struct sk_buff *skb);struct sk_buff *next, *segs;int ret; +if (static_branch_unlikely (&udp_encap_needed_key) && + up->encap_type &UDP_ENCAP_SUPPORT_GRO_FRAGS && + (encap_rcv_gro =READ_ONCE (up->encap_rcv))) { +//XXX: deal with checksum? + ret =encap_rcv (sk, skb); +if (ret <=0 )//XXX: deal with incrementing udp error stats? +return -ret; + } +if (likely (!udp_unexpected_gso (sk, skb)))return udp_queue_rcv_one_skb (sk, skb);
Signature · 1 line
2.24.1
Willem de Bruijn
maintainerQuoted 15 lines · Jason A. Donenfeld
Hi Steffen,
This is very much a "RFC", in that the code here is fodder for discussion more than something I'm seriously proposing at the moment. I'm writing to you specifically because I recall us having discussed something like this a while ago and you being interested.
WireGuard would benefit from getting lists of SKBs all together in a bunch on the receive side. At the moment,
encap_rcvsplits them apart one by one before giving them to the API. This patch proposes a way to opt-in to receiving them before they've been split. The solution involves adding anencap_typeflag that enables calling theencap_rcvfunction earlier before the skbs have been split apart.
Quoted 6 lines
I worry that it's not this straight forward, however, because of this function below called, "
udp_unexpected_gso". It looks like there's a fast path for the case when it doesn't need to be split apart, and that if it is already split apart, that's expected, whereas splitting it apart would be "unexpected." I'm not too familiar with this code. Do you know off hand why this would be unexpected?
This is for delivery to local sockets.
UDP GRO packets need to be split back up before delivery, unless the socket has set socket option UDP_GRO.
This is checked in the GRO layer by checking udp_sk(sk)->gro_enabled.
There is a race condition between this check and the packet arriving at the socket. Hence the unexpected.
Note that UDP GSO can take two forms, the fraglist approach by Steffen or the earlier implementation that builds a single skb with frags.
Quoted 4 lines
static int
udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb){net/ipv4/udp.c +1
-0+int (*encap_rcv_gro)(struct sock *sk,struct sk_buff *skb);struct sk_buff *next, *segs;
net/ipv4/udp.c static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb) · line 2109
Quoted 10 lines
net/ipv4/udp.c +8
-0int ret; +if (static_branch_unlikely (&udp_encap_needed_key) && + up->encap_type &UDP_ENCAP_SUPPORT_GRO_FRAGS && + (encap_rcv_gro =READ_ONCE (up->encap_rcv))) { +//XXX: deal with checksum? + ret =encap_rcv (sk, skb); +if (ret <=0 )//XXX: deal with incrementing udp error stats? +return -ret; + }
I think it'll be sufficient to just set optionally udp_sk(sk)->gro_enabled on encap sockets and let it takes the default path, below?
Quoted 7 lines
+
if (likely(!udp_unexpected_gso(sk, skb)))
returnudp_queue_rcv_one_skb(sk, skb);--
2.24.1
Quoted 25 lines · Willem de Bruijn
Quoted 15 lines · Jason A. Donenfeld
Hi Steffen,
This is very much a "RFC", in that the code here is fodder for discussion more than something I'm seriously proposing at the moment. I'm writing to you specifically because I recall us having discussed something like this a while ago and you being interested.
WireGuard would benefit from getting lists of SKBs all together in a bunch on the receive side. At the moment,
encap_rcvsplits them apart one by one before giving them to the API. This patch proposes a way to opt-in to receiving them before they've been split. The solution involves adding anencap_typeflag that enables calling theencap_rcvfunction earlier before the skbs have been split apart.Quoted 6 lines
I worry that it's not this straight forward, however, because of this function below called, "
udp_unexpected_gso". It looks like there's a fast path for the case when it doesn't need to be split apart, and that if it is already split apart, that's expected, whereas splitting it apart would be "unexpected." I'm not too familiar with this code. Do you know off hand why this would be unexpected?This is for delivery to local sockets.
Quoted 7 lines
UDP GRO packets need to be split back up before delivery, unless the socket has set socket option
UDP_GRO.This is checked in the GRO layer by checking udp_sk(sk)->gro_enabled.
There is a race condition between this check and the packet arriving at the socket. Hence the unexpected.
Actually, if fraglist GRO is enabled this codepath is not that unexpected anymore. Maybe we should remove the branch predictor on !udp_unexpected_gso.
Quoted 19 lines
Note that UDP GSO can take two forms, the fraglist approach by Steffen or the earlier implementation that builds a single skb with frags.
Quoted 4 lines
static int
udp_queue_rcv_skb(struct sock *sk, struct sk_buff *skb){net/ipv4/udp.c +1
-0+int (*encap_rcv_gro)(struct sock *sk,struct sk_buff *skb);struct sk_buff *next, *segs;net/ipv4/udp.c static int udp_queue_rcv_one_skb(struct sock *sk, struct sk_buff *skb) · line 2109
Quoted 10 lines
net/ipv4/udp.c +8
-0int ret; +if (static_branch_unlikely (&udp_encap_needed_key) && + up->encap_type &UDP_ENCAP_SUPPORT_GRO_FRAGS && + (encap_rcv_gro =READ_ONCE (up->encap_rcv))) { +//XXX: deal with checksum? + ret =encap_rcv (sk, skb); +if (ret <=0 )//XXX: deal with incrementing udp error stats? +return -ret; + }
Quoted 3 lines
I think it'll be sufficient to just set optionally udp_sk(sk)->gro_enabled on encap sockets and let it takes the default path, below?
I think Jason wants to have the fraglist GRO version. Just setting udp_sk(sk)->gro_enabled would generate standard GRO packets. The UDP payload from wireguard is encrypted, so merging into a single datagram does not work that well here.
Quoted 5 lines
Quoted 5 lines
+
if (likely(!udp_unexpected_gso(sk, skb)))
returnudp_queue_rcv_one_skb(sk, skb);
Hi Jason,
Quoted 30 lines · Jason A. Donenfeld
Hi Steffen,
This is very much a "RFC", in that the code here is fodder for discussion more than something I'm seriously proposing at the moment. I'm writing to you specifically because I recall us having discussed something like this a while ago and you being interested.
WireGuard would benefit from getting lists of SKBs all together in a bunch on the receive side. At the moment,
encap_rcvsplits them apart one by one before giving them to the API. This patch proposes a way to opt-in to receiving them before they've been split. The solution involves adding anencap_typeflag that enables calling theencap_rcvfunction earlier before the skbs have been split apart.I worry that it's not this straight forward, however, because of this function below called, "
udp_unexpected_gso". It looks like there's a fast path for the case when it doesn't need to be split apart, and that if it is already split apart, that's expected, whereas splitting it apart would be "unexpected." I'm not too familiar with this code. Do you know off hand why this would be unexpected? And does that imply that a proper implementation of this might be a bit more involved? Or is the naming just silly and this actually is _the_ path where this happens?The other thing I'm wondering with regards to this is how you even hit this path. So far I've only been able to hit it with the out of tree Qualcom driver, "
rmnet_perf". I saw a mailing list discussion a few years ago about adding some flags to be able to simulate this with veth, but I didn't see that go anywhere. Figuring out how I can test this is probably a good idea before proceeding further.
Quoted 4 lines
Finally, and most importantly, is this overlapping with something you're working on at the moment? Where do you stand with this? Did you wind up solving your own use cases in a different way, or are you sitting on a more proper version of this RFC or something else?
I have a patch to enable GRO for ESP in UDP encapsulation. The patch is not that well tested so far, so I hold it back for now. But I think it won't overlap with enabling fraglist GRO for encap sockets. I have not thought about enabling fraglist GRO for encap sockets, but a flag to signal this could be a way to go.
Other that that I plan to enable UDP GRO by default once we are sure that this won't add a regression.