diff mbox series

[v2,net-next] udp: allow forwarding of plain (non-fraglisted) UDP GRO packets

Message ID 20210113103232.4761-1-alobakin@pm.me (mailing list archive)
State Superseded
Delegated to: Netdev Maintainers
Headers show
Series [v2,net-next] udp: allow forwarding of plain (non-fraglisted) UDP GRO packets | expand

Checks

Context Check Description
netdev/cover_letter success Link
netdev/fixes_present success Link
netdev/patch_count success Link
netdev/tree_selection success Clearly marked for net-next
netdev/subject_prefix success Link
netdev/cc_maintainers success CCed 5 of 5 maintainers
netdev/source_inline success Was 0 now: 0
netdev/verify_signedoff success Link
netdev/module_param success Was 0 now: 0
netdev/build_32bit success Errors and warnings before: 8 this patch: 8
netdev/kdoc success Errors and warnings before: 0 this patch: 0
netdev/verify_fixes success Link
netdev/checkpatch success total: 0 errors, 0 warnings, 0 checks, 14 lines checked
netdev/build_allmodconfig_warn success Errors and warnings before: 8 this patch: 8
netdev/header_inline success Link
netdev/stable success Stable not CCed

Commit Message

Alexander Lobakin Jan. 13, 2021, 10:32 a.m. UTC
Commit 9fd1ff5d2ac7 ("udp: Support UDP fraglist GRO/GSO.") actually
not only added a support for fraglisted UDP GRO, but also tweaked
some logics the way that non-fraglisted UDP GRO started to work for
forwarding too.
Commit 2e4ef10f5850 ("net: add GSO UDP L4 and GSO fraglists to the
list of software-backed types") added GSO UDP L4 to the list of
software GSO to allow virtual netdevs to forward them as is up to
the real drivers.

Tests showed that currently forwarding and NATing of plain UDP GRO
packets are performed fully correctly, regardless if the target
netdevice has a support for hardware/driver GSO UDP L4 or not.
Add the last element and allow to form plain UDP GRO packets if
there is no socket -> we are on forwarding path.

Plain UDP GRO forwarding even shows better performance than fraglisted
UDP GRO in some cases due to not wasting one skbuff_head per every
segment.

Since v1 [0]:
 - drop redundant 'if (sk)' check (Alexander Duyck);
 - add a ref in the commit message to one more commit that was
   an important step for UDP GRO forwarding.

[0] https://lore.kernel.org/netdev/20210112211536.261172-1-alobakin@pm.me

Signed-off-by: Alexander Lobakin <alobakin@pm.me>
---
 net/ipv4/udp_offload.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

Comments

Paolo Abeni Jan. 13, 2021, 6:37 p.m. UTC | #1
On Wed, 2021-01-13 at 10:32 +0000, Alexander Lobakin wrote:
> Commit 9fd1ff5d2ac7 ("udp: Support UDP fraglist GRO/GSO.") actually
> not only added a support for fraglisted UDP GRO, but also tweaked
> some logics the way that non-fraglisted UDP GRO started to work for
> forwarding too.
> Commit 2e4ef10f5850 ("net: add GSO UDP L4 and GSO fraglists to the
> list of software-backed types") added GSO UDP L4 to the list of
> software GSO to allow virtual netdevs to forward them as is up to
> the real drivers.
> 
> Tests showed that currently forwarding and NATing of plain UDP GRO
> packets are performed fully correctly, regardless if the target
> netdevice has a support for hardware/driver GSO UDP L4 or not.
> Add the last element and allow to form plain UDP GRO packets if
> there is no socket -> we are on forwarding path.

If I read correctly, the above will make UDP GRO in the forwarding path
always enabled (admin can't disable that, if forwarding is enabled).

UDP GRO can introduce measurable latency for UDP packets staging in the
napi GRO hash (no push flag for UDP ;).

Currently the admin (for fraglist) or the application (for socket-based 
"plain" GRO) have to explicitly enable the feature, but this change
will impact every user.

I think we need at lest an explict switch for this.

Cheers,

Paolo
Alexander Lobakin Jan. 14, 2021, 10:45 a.m. UTC | #2
From: Paolo Abeni <pabeni@redhat.com>
Date: Wed, 13 Jan 2021 19:37:18 +0100

> On Wed, 2021-01-13 at 10:32 +0000, Alexander Lobakin wrote:
>> Commit 9fd1ff5d2ac7 ("udp: Support UDP fraglist GRO/GSO.") actually
>> not only added a support for fraglisted UDP GRO, but also tweaked
>> some logics the way that non-fraglisted UDP GRO started to work for
>> forwarding too.
>> Commit 2e4ef10f5850 ("net: add GSO UDP L4 and GSO fraglists to the
>> list of software-backed types") added GSO UDP L4 to the list of
>> software GSO to allow virtual netdevs to forward them as is up to
>> the real drivers.
>>
>> Tests showed that currently forwarding and NATing of plain UDP GRO
>> packets are performed fully correctly, regardless if the target
>> netdevice has a support for hardware/driver GSO UDP L4 or not.
>> Add the last element and allow to form plain UDP GRO packets if
>> there is no socket -> we are on forwarding path.
>
> If I read correctly, the above will make UDP GRO in the forwarding path
> always enabled (admin can't disable that, if forwarding is enabled).
>
> UDP GRO can introduce measurable latency for UDP packets staging in the
> napi GRO hash (no push flag for UDP ;).
>
> Currently the admin (for fraglist) or the application (for socket-based
> "plain" GRO) have to explicitly enable the feature, but this change
> will impact every user.
>
> I think we need at lest an explict switch for this.

Fraglist UDP GRO is controlled by netdev feature / ethtool, plain UDO
GRO is controlled by the sockopt. Regarding that we have no sock on
forwarding, what kind of switch should we introduce here? One more
netdev feature, smth like NETIF_F_GRO_UDP_L4?

> Cheers,
>
> Paolo

Thanks,
Al
diff mbox series

Patch

diff --git a/net/ipv4/udp_offload.c b/net/ipv4/udp_offload.c
index ff39e94781bf..6f5237a0d181 100644
--- a/net/ipv4/udp_offload.c
+++ b/net/ipv4/udp_offload.c
@@ -460,12 +460,12 @@  struct sk_buff *udp_gro_receive(struct list_head *head, struct sk_buff *skb,
 	if (skb->dev->features & NETIF_F_GRO_FRAGLIST)
 		NAPI_GRO_CB(skb)->is_flist = sk ? !udp_sk(sk)->gro_enabled: 1;
 
-	if ((sk && udp_sk(sk)->gro_enabled) || NAPI_GRO_CB(skb)->is_flist) {
+	if (!sk || udp_sk(sk)->gro_enabled || NAPI_GRO_CB(skb)->is_flist) {
 		pp = call_gro_receive(udp_gro_receive_segment, head, skb);
 		return pp;
 	}
 
-	if (!sk || NAPI_GRO_CB(skb)->encap_mark ||
+	if (NAPI_GRO_CB(skb)->encap_mark ||
 	    (skb->ip_summed != CHECKSUM_PARTIAL &&
 	     NAPI_GRO_CB(skb)->csum_cnt == 0 &&
 	     !NAPI_GRO_CB(skb)->csum_valid) ||