Skip to contentSkip to conversation

tcp: final (?) round of mem pressure fixes

PATCH In review Eric Dumazet 7 participants 15 messages Jun 14, 2022 – Jun 17, 2022 1 message not in the archive

Subsystems (3)
lore
Share & tools
lore
#0 lore raw

v2 cover tcp: final (?) round of mem pressure fixes

From: Eric Dumazet <[email protected]>

While working on prior patch series (e10b02ee5b6c "Merge branch 'net-reduce-tcp_memory_allocated-inflation'"), I found that we could still have frozen TCP flows under memory pressure.

I thought we had solved this in 2015, but the fix was not complete.

v2: deal with zerocopy tx paths.

Eric Dumazet (2):
tcp: fix over estimation in sk_forced_mem_schedule()
tcp: fix possible freeze in tx path under memory pressure

 net/ipv4/tcp.c        | 33 +++++++++++++++++++++++++++++----
 net/ipv4/tcp_output.c |  7 ++++---
 2 files changed, 33 insertions(+), 7 deletions(-)
Signature · 1 line
2.36.1.476.g0c4daa206d-goog
#1 lore raw

PATCH v2 1/2 tcp: fix over estimation in sk_forced_mem_schedule()

From: Eric Dumazet <[email protected]>

sk_forced_mem_schedule() has a bug similar to ones fixed in commit 7c80b038d23e ("net: fix sk_wmem_schedule() and sk_rmem_schedule() errors")

While this bug has little chance to trigger in old kernels, we need to fix it before the following patch.

Fixes d83769a580f1 ("tcp: fix possible deadlock in tcp_send_fin()")
---
 net/ipv4/tcp_output.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)
net/ipv4/tcp_output.c +4 -3
index 8ab98e1aca6797a51eaaf8886680d2001a616948..18c913a2347a984ae8cf2793bb8991e59e5e94ab 100644
@@ -3362,11 +3362,12 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
  */
 void sk_forced_mem_schedule(struct sock *sk, int size)
 {
-	int amt;
+	int delta, amt;
 
-	if (size <= sk->sk_forward_alloc)
+	delta = size - sk->sk_forward_alloc;
+	if (delta <= 0)
 		return;
-	amt = sk_mem_pages(size);
+	amt = sk_mem_pages(delta);
 	sk->sk_forward_alloc += amt << PAGE_SHIFT;
 	sk_memory_allocated_add(sk, amt);
 
Signature · 1 line
2.36.1.476.g0c4daa206d-goog
Reviewed-by on v2 1/2
#2 lore raw

Re: [PATCH v2 net-next 1/2] tcp: fix over estimation in sk_forced_mem_schedule()

Quoted 11 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

sk_forced_mem_schedule() has a bug similar to ones fixed in commit 7c80b038d23e ("net: fix sk_wmem_schedule() and sk_rmem_schedule() errors")

While this bug has little chance to trigger in old kernels, we need to fix it before the following patch.

Fixes d83769a580f1 ("tcp: fix possible deadlock in tcp_send_fin()")
Acked-by on v2 1/2
#3 lore raw

Re: [PATCH v2 net-next 1/2] tcp: fix over estimation in sk_forced_mem_schedule()

In reply to Eric Dumazet
Quoted 7 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

sk_forced_mem_schedule() has a bug similar to ones fixed in commit 7c80b038d23e ("net: fix sk_wmem_schedule() and sk_rmem_schedule() errors")

Quoted 5 lines

While this bug has little chance to trigger in old kernels, we need to fix it before the following patch.

Fixes d83769a580f1 ("tcp: fix possible deadlock in tcp_send_fin()")
Quoted 27 lines
---
 net/ipv4/tcp_output.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)
net/ipv4/tcp_output.c +4 -4
index 8ab98e1aca6797a51eaaf8886680d2001a616948..18c913a2347a984ae8cf2793bb8991e59e5e94ab 100644
@@ -3362,11 +3362,12 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
  */
 void sk_forced_mem_schedule(struct sock *sk, int size)
 {
-       int amt;
+       int delta, amt;
 
-       if (size <= sk->sk_forward_alloc)
+       delta = size - sk->sk_forward_alloc;
+       if (delta <= 0)
                return;
-       amt = sk_mem_pages(size);
+       amt = sk_mem_pages(delta);
        sk->sk_forward_alloc += amt << PAGE_SHIFT;
        sk_memory_allocated_add(sk, amt);
 
--

2.36.1.476.g0c4daa206d-goog

Reviewed-by
#4 lore raw

Re: [PATCH v2 net-next 1/2] tcp: fix over estimation in sk_forced_mem_schedule()

Quoted 9 lines · Soheil Hassas Yeganeh
Quoted 7 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

sk_forced_mem_schedule() has a bug similar to ones fixed in commit 7c80b038d23e ("net: fix sk_wmem_schedule() and sk_rmem_schedule() errors")

Quoted 5 lines
Quoted 5 lines

While this bug has little chance to trigger in old kernels, we need to fix it before the following patch.

Fixes d83769a580f1 ("tcp: fix possible deadlock in tcp_send_fin()")
Quoted 30 lines
Quoted 27 lines
---
 net/ipv4/tcp_output.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)
net/ipv4/tcp_output.c +4 -4
index 8ab98e1aca6797a51eaaf8886680d2001a616948..18c913a2347a984ae8cf2793bb8991e59e5e94ab 100644
@@ -3362,11 +3362,12 @@ void tcp_xmit_retransmit_queue(struct sock *sk)
  */
 void sk_forced_mem_schedule(struct sock *sk, int size)
 {
-       int amt;
+       int delta, amt;
 
-       if (size <= sk->sk_forward_alloc)
+       delta = size - sk->sk_forward_alloc;
+       if (delta <= 0)
                return;
-       amt = sk_mem_pages(size);
+       amt = sk_mem_pages(delta);
        sk->sk_forward_alloc += amt << PAGE_SHIFT;
        sk_memory_allocated_add(sk, amt);
 
--

2.36.1.476.g0c4daa206d-goog

#5 lore raw

PATCH v2 2/2 tcp: fix possible freeze in tx path under memory pressure

In reply to Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

Fixes 8e4d980ac215 ("tcp: fix behavior for epoll edge trigger")
---
 net/ipv4/tcp.c | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)
net/ipv4/tcp.c +29 -4
index 14ebb4ec4a51f3c55501aa53423ce897599e8637..56083c2497f0b695c660256aa43f8a743d481697 100644
@@ -951,6 +951,23 @@ static int tcp_downgrade_zcopy_pure(struct sock *sk, struct sk_buff *skb)
 	return 0;
 }
 
+static int tcp_wmem_schedule(struct sock *sk, int copy)
+{
+	int left;
+
+	if (likely(sk_wmem_schedule(sk, copy)))
+		return copy;
+
+	/* We could be in trouble if we have nothing queued.
+	 * Use whatever is left in sk->sk_forward_alloc and tcp_wmem[0]
+	 * to guarantee some progress.
+	 */
+	left = sock_net(sk)->ipv4.sysctl_tcp_wmem[0] - sk->sk_wmem_queued;
+	if (left > 0)
+		sk_forced_mem_schedule(sk, min(left, copy));
+	return min(copy, sk->sk_forward_alloc);
+}
+
 static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
 				      struct page *page, int offset, size_t *size)
 {
@@ -986,7 +1003,11 @@ static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
 		tcp_mark_push(tp, skb);
 		goto new_segment;
 	}
-	if (tcp_downgrade_zcopy_pure(sk, skb) || !sk_wmem_schedule(sk, copy))
+	if (tcp_downgrade_zcopy_pure(sk, skb))
+		return NULL;
+
+	copy = tcp_wmem_schedule(sk, copy);
+	if (!copy)
 		return NULL;
 
 	if (can_coalesce) {
@@ -1334,8 +1355,11 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
 
 			copy = min_t(int, copy, pfrag->size - pfrag->offset);
 
-			if (tcp_downgrade_zcopy_pure(sk, skb) ||
-			    !sk_wmem_schedule(sk, copy))
+			if (tcp_downgrade_zcopy_pure(sk, skb))
+				goto wait_for_space;
+
+			copy = tcp_wmem_schedule(sk, copy);
+			if (!copy)
 				goto wait_for_space;
 
 			err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
@@ -1362,7 +1386,8 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
 				skb_shinfo(skb)->flags |= SKBFL_PURE_ZEROCOPY;
 
 			if (!skb_zcopy_pure(skb)) {
-				if (!sk_wmem_schedule(sk, copy))
+				copy = tcp_wmem_schedule(sk, copy);
+				if (!copy)
 					goto wait_for_space;
 			}
 
Signature · 1 line
2.36.1.476.g0c4daa206d-goog
Acked-by on v2 2/2
#6 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

Quoted 19 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

Quoted 7 lines

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

Fixes 8e4d980ac215 ("tcp: fix behavior for epoll edge trigger")

Very nice find! Thank you!

Quoted 72 lines
---
 net/ipv4/tcp.c | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)
net/ipv4/tcp.c +29 -5
index 14ebb4ec4a51f3c55501aa53423ce897599e8637..56083c2497f0b695c660256aa43f8a743d481697 100644
@@ -951,6 +951,23 @@ static int tcp_downgrade_zcopy_pure(struct sock *sk, struct sk_buff *skb)
        return 0;
 }
 
+static int tcp_wmem_schedule(struct sock *sk, int copy)
+{
+       int left;
+
+       if (likely(sk_wmem_schedule(sk, copy)))
+               return copy;
+
+       /* We could be in trouble if we have nothing queued.
+        * Use whatever is left in sk->sk_forward_alloc and tcp_wmem[0]
+        * to guarantee some progress.
+        */
+       left = sock_net(sk)->ipv4.sysctl_tcp_wmem[0] - sk->sk_wmem_queued;
+       if (left > 0)
+               sk_forced_mem_schedule(sk, min(left, copy));
+       return min(copy, sk->sk_forward_alloc);
+}
+
 static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                                      struct page *page, int offset, size_t *size)
 {
@@ -986,7 +1003,11 @@ static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                tcp_mark_push(tp, skb);
                goto new_segment;
        }
-       if (tcp_downgrade_zcopy_pure(sk, skb) || !sk_wmem_schedule(sk, copy))
+       if (tcp_downgrade_zcopy_pure(sk, skb))
+               return NULL;
+
+       copy = tcp_wmem_schedule(sk, copy);
+       if (!copy)
                return NULL;
 
        if (can_coalesce) {
@@ -1334,8 +1355,11 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
 
                        copy = min_t(int, copy, pfrag->size - pfrag->offset);
 
-                       if (tcp_downgrade_zcopy_pure(sk, skb) ||
-                           !sk_wmem_schedule(sk, copy))
+                       if (tcp_downgrade_zcopy_pure(sk, skb))
+                               goto wait_for_space;
+
+                       copy = tcp_wmem_schedule(sk, copy);
+                       if (!copy)
                                goto wait_for_space;
 
                        err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
@@ -1362,7 +1386,8 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
                                skb_shinfo(skb)->flags |= SKBFL_PURE_ZEROCOPY;
 
                        if (!skb_zcopy_pure(skb)) {
-                               if (!sk_wmem_schedule(sk, copy))
+                               copy = tcp_wmem_schedule(sk, copy);
+                               if (!copy)
                                        goto wait_for_space;
                        }
 
--

2.36.1.476.g0c4daa206d-goog

#7 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

Quoted 64 lines · Soheil Hassas Yeganeh
Quoted 19 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

Quoted 7 lines

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

Fixes 8e4d980ac215 ("tcp: fix behavior for epoll edge trigger")

Very nice find! Thank you!

Quoted 31 lines
---
 net/ipv4/tcp.c | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)
net/ipv4/tcp.c +17 -0
index 14ebb4ec4a51f3c55501aa53423ce897599e8637..56083c2497f0b695c660256aa43f8a743d481697 100644
@@ -951,6 +951,23 @@ static int tcp_downgrade_zcopy_pure(struct sock *sk, struct sk_buff *skb)
        return 0;
 }
 
+static int tcp_wmem_schedule(struct sock *sk, int copy)
+{
+       int left;
+
+       if (likely(sk_wmem_schedule(sk, copy)))
+               return copy;
+
+       /* We could be in trouble if we have nothing queued.
+        * Use whatever is left in sk->sk_forward_alloc and tcp_wmem[0]
+        * to guarantee some progress.
+        */
+       left = sock_net(sk)->ipv4.sysctl_tcp_wmem[0] - sk->sk_wmem_queued;
+       if (left > 0)
+               sk_forced_mem_schedule(sk, min(left, copy));
+       return min(copy, sk->sk_forward_alloc);
+}
+
 static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                                      struct page *page, int offset, size_t *size)
Quoted 8 lines

net/ipv4/tcp.c static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags, · line 1007

Quoted 8 lines
net/ipv4/tcp.c +2 -1
 {
@@ -986,7 +1003,11 @@ static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                tcp_mark_push(tp, skb);
                goto new_segment;
        }
-       if (tcp_downgrade_zcopy_pure(sk, skb) || !sk_wmem_schedule(sk, copy))
+       if (tcp_downgrade_zcopy_pure(sk, skb))
+               return NULL;

Do we need to take care of the call to sk_wmem_schedule() inside tcp_downgrade_zcopy_pure()?

Quoted 33 lines
Quoted 33 lines
net/ipv4/tcp.c +10 -4
+
+       copy = tcp_wmem_schedule(sk, copy);
+       if (!copy)
                return NULL;
 
        if (can_coalesce) {
@@ -1334,8 +1355,11 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
 
                        copy = min_t(int, copy, pfrag->size - pfrag->offset);
 
-                       if (tcp_downgrade_zcopy_pure(sk, skb) ||
-                           !sk_wmem_schedule(sk, copy))
+                       if (tcp_downgrade_zcopy_pure(sk, skb))
+                               goto wait_for_space;
+
+                       copy = tcp_wmem_schedule(sk, copy);
+                       if (!copy)
                                goto wait_for_space;
 
                        err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
@@ -1362,7 +1386,8 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
                                skb_shinfo(skb)->flags |= SKBFL_PURE_ZEROCOPY;
 
                        if (!skb_zcopy_pure(skb)) {
-                               if (!sk_wmem_schedule(sk, copy))
+                               copy = tcp_wmem_schedule(sk, copy);
+                               if (!copy)
                                        goto wait_for_space;
                        }
 
--

2.36.1.476.g0c4daa206d-goog

A message that is not in the archive (sent off-list or not yet received): CANn89iJYwSoL-XvkcUK1am2wYQjToMnNRG-9pD9qY8+L=GyqaA@mail.gmail.com

Reviewed-by
#9 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

Quoted 28 lines · Eric Dumazet
Quoted 24 lines · Wei Wang
Quoted 21 lines · Soheil Hassas Yeganeh
Quoted 19 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

Fixes 8e4d980ac215 ("tcp: fix behavior for epoll edge trigger")
Quoted 49 lines
Quoted 39 lines
Quoted 39 lines

Very nice find! Thank you!

Quoted 34 lines
---
 net/ipv4/tcp.c | 33 +++++++++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 4 deletions(-)
net/ipv4/tcp.c +17 -0
index 14ebb4ec4a51f3c55501aa53423ce897599e8637..56083c2497f0b695c660256aa43f8a743d481697 100644
@@ -951,6 +951,23 @@ static int tcp_downgrade_zcopy_pure(struct sock *sk, struct sk_buff *skb)
        return 0;
 }
 
+static int tcp_wmem_schedule(struct sock *sk, int copy)
+{
+       int left;
+
+       if (likely(sk_wmem_schedule(sk, copy)))
+               return copy;
+
+       /* We could be in trouble if we have nothing queued.
+        * Use whatever is left in sk->sk_forward_alloc and tcp_wmem[0]
+        * to guarantee some progress.
+        */
+       left = sock_net(sk)->ipv4.sysctl_tcp_wmem[0] - sk->sk_wmem_queued;
+       if (left > 0)
+               sk_forced_mem_schedule(sk, min(left, copy));
+       return min(copy, sk->sk_forward_alloc);
+}
+
 static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                                      struct page *page, int offset, size_t *size)
 {
@@ -986,7 +1003,11 @@ static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags,
                tcp_mark_push(tp, skb);
Quoted 8 lines
Quoted 5 lines

net/ipv4/tcp.c static struct sk_buff *tcp_build_frag(struct sock *sk, int size_goal, int flags, · line 1007

Quoted 5 lines
net/ipv4/tcp.c +2 -1
                goto new_segment;
        }
-       if (tcp_downgrade_zcopy_pure(sk, skb) || !sk_wmem_schedule(sk, copy))
+       if (tcp_downgrade_zcopy_pure(sk, skb))
+               return NULL;

Do we need to take care of the call to sk_wmem_schedule() inside tcp_downgrade_zcopy_pure()?

Quoted 1 line

We can not. Payload has been added already, and will be sent eventually.

Ack. Thanks for the explanation.

Quoted 35 lines
Quoted 35 lines
Quoted 35 lines
Quoted 35 lines
net/ipv4/tcp.c +10 -4
+
+       copy = tcp_wmem_schedule(sk, copy);
+       if (!copy)
                return NULL;
 
        if (can_coalesce) {
@@ -1334,8 +1355,11 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
 
                        copy = min_t(int, copy, pfrag->size - pfrag->offset);
 
-                       if (tcp_downgrade_zcopy_pure(sk, skb) ||
-                           !sk_wmem_schedule(sk, copy))
+                       if (tcp_downgrade_zcopy_pure(sk, skb))
+                               goto wait_for_space;
+
+                       copy = tcp_wmem_schedule(sk, copy);
+                       if (!copy)
                                goto wait_for_space;
 
                        err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
@@ -1362,7 +1386,8 @@ int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
                                skb_shinfo(skb)->flags |= SKBFL_PURE_ZEROCOPY;
 
                        if (!skb_zcopy_pure(skb)) {
-                               if (!sk_wmem_schedule(sk, copy))
+                               copy = tcp_wmem_schedule(sk, copy);
+                               if (!copy)
                                        goto wait_for_space;
                        }
 
--

2.36.1.476.g0c4daa206d-goog

Reviewed-by on v2 2/2
#10 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

In reply to Eric Dumazet
Quoted 19 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

Quoted 7 lines

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

Fixes 8e4d980ac215 ("tcp: fix behavior for epoll edge trigger")
#11 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

In reply to Eric Dumazet

Hi,

Quoted 14 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Quoted 8 lines

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

I think this might have gotten double applied:

https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=849b425cd091e1804af964b771761cfbefbafb43
https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=f54755f6a11accb2db5ef17f8f75aad0875aefdc

and now net-next builds are broken:

../../../../../../../../net/ipv4/tcp.c:971:12: error: redefinition of ‘tcp_wmem_schedule’
971 | static int tcp_wmem_schedule(struct sock *sk, int copy) | ^~~~~~~~~~~~~~~~~
../../../../../../../../net/ipv4/tcp.c:954:12: note: previous definition of ‘tcp_wmem_schedule’ with type ‘int(struct sock *, int)’
954 | static int tcp_wmem_schedule(struct sock *sk, int copy) | ^~~~~~~~~~~~~~~~~
../../../../../../../../net/ipv4/tcp.c:954:12: warning: ‘tcp_wmem_schedule’ defined but not used [-Wunused-function] make[5]: *** [/home/wgci/tmp/2813390.12234/tmp.0PMBO65tGf/scripts/Makefile.build:249: net
/ipv4/tcp.o] Error 1 make[4]: *** [/home/wgci/tmp/2813390.12234/tmp.0PMBO65tGf/scripts/Makefile.build:466: net/ipv4] Error 2
make[4]: *** Waiting for unfinished jobs....

Jason

#12 lore raw

Re: [PATCH v2 net-next 2/2] tcp: fix possible freeze in tx path under memory pressure

Quoted 33 lines · Jason A. Donenfeld

Hi,

Quoted 14 lines · Eric Dumazet

From: Eric Dumazet <[email protected]>

Blamed commit only dealt with applications issuing small writes.

Issue here is that we allow to force memory schedule for the sk_buff allocation, but we have no guarantee that sendmsg() is able to copy some payload in it.

In this patch, I make sure the socket can use up to tcp_wmem[0] bytes.

For example, if we consider tcp_wmem[0] = 4096 (default on x86), and initial skb->truesize being 1280, tcp_sendmsg() is able to copy up to 2816 bytes under memory pressure.

Quoted 8 lines

Before this patch a sendmsg() sending more than 2816 bytes would either block forever (if persistent memory pressure), or return -EAGAIN.

For bigger MTU networks, it is advised to increase tcp_wmem[0] to avoid sending too small packets.

v2: deal with zero copy paths.

I think this might have gotten double applied:

https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=849b425cd091e1804af964b771761cfbefbafb43
https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=f54755f6a11accb2db5ef17f8f75aad0875aefdc

and now net-next builds are broken:

Quoted 7 lines

../../../../../../../../net/ipv4/tcp.c:971:12: error: redefinition of ‘tcp_wmem_schedule’
971 | static int tcp_wmem_schedule(struct sock *sk, int copy) | ^~~~~~~~~~~~~~~~~
../../../../../../../../net/ipv4/tcp.c:954:12: note: previous definition of ‘tcp_wmem_schedule’ with type ‘int(struct sock *, int)’
954 | static int tcp_wmem_schedule(struct sock *sk, int copy) | ^~~~~~~~~~~~~~~~~
../../../../../../../../net/ipv4/tcp.c:954:12: warning: ‘tcp_wmem_schedule’ defined but not used [-Wunused-function] make[5]: *** [/home/wgci/tmp/2813390.12234/tmp.0PMBO65tGf/scripts/Makefile.build:249: net
/ipv4/tcp.o] Error 1 make[4]: *** [/home/wgci/tmp/2813390.12234/tmp.0PMBO65tGf/scripts/Makefile.build:466: net/ipv4] Error 2
make[4]: *** Waiting for unfinished jobs....

Ah, fixed already:
https://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next.git/commit/?id=fd8b330ce1bb79ba00047435cc213b14f886bf1f

Quoted 2 lines

Jason

maintainer
#13 lore raw
In reply to Eric Dumazet

From: Eric Dumazet <[email protected]>
Date: Tue, 14 Jun 2022 10:17:32 -0700

Quoted 9 lines

From: Eric Dumazet <[email protected]>

While working on prior patch series (e10b02ee5b6c "Merge branch 'net-reduce-tcp_memory_allocated-inflation'"), I found that we could still have frozen TCP flows under memory pressure.

I thought we had solved this in 2015, but the fix was not complete.

v2: deal with zerocopy tx paths.

Does not apply cleanly to net, please respin.

Thank you.

#14 lore raw
Quoted 10 lines · David Miller

From: Eric Dumazet <[email protected]>
Date: Tue, 14 Jun 2022 10:17:32 -0700

Quoted 6 lines

From: Eric Dumazet <[email protected]>

While working on prior patch series (e10b02ee5b6c "Merge branch 'net-reduce-tcp_memory_allocated-inflation'"), I found that we could still have frozen TCP flows under memory pressure.

Quoted 7 lines
Quoted 3 lines

I thought we had solved this in 2015, but the fix was not complete.

v2: deal with zerocopy tx paths.

Does not apply cleanly to net, please respin.

Thank you.

I was targeting net-next tree for this old bug, and planning to prepare stable backports.

Tell me if you prefer to respin to net tree, probably later today because I am traveling.

Thanks.

#15 lore raw
Quoted 14 lines · Eric Dumazet
Quoted 12 lines · David Miller

From: Eric Dumazet <[email protected]>
Date: Tue, 14 Jun 2022 10:17:32 -0700

Quoted 8 lines

From: Eric Dumazet <[email protected]>

While working on prior patch series (e10b02ee5b6c "Merge branch 'net-reduce-tcp_memory_allocated-inflation'"), I found that we could still have frozen TCP flows under memory pressure.

I thought we had solved this in 2015, but the fix was not complete.

Quoted 8 lines
Quoted 5 lines
Quoted 1 line

v2: deal with zerocopy tx paths.

Does not apply cleanly to net, please respin.

Thank you.

I was targeting net-next tree for this old bug, and planning to prepare stable backports.

This was because in net-next we got rid of SK_MEM_QUANTUM, and to limit merge conflicts.

Quoted 5 lines

Tell me if you prefer to respin to net tree, probably later today because I am traveling.

Thanks.