Skip to contentSkip to conversation

Revert "defer call to mem_cgroup_sk_alloc()"

PATCH In review Roman Gushchin 2 participants 7 messages Feb 2, 2018

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

PATCH 1/1 Revert "defer call to mem_cgroup_sk_alloc()"

This patch effectively reverts commit 9f1c2674b328 ("net: memcontrol:
defer call to mem_cgroup_sk_alloc()").

Moving mem_cgroup_sk_alloc() to the inet_csk_accept() completely breaks memcg socket memory accounting, as packets received before memcg pointer initialization are not accounted and are causing refcounting underflow on socket release.

Actually the free-after-use problem was fixed by commit c0576e397508 ("net: call cgroup_sk_alloc() earlier in sk_clone_lock()") for the cgroup pointer.

So, let's revert it and call mem_cgroup_sk_alloc() just before cgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.

Cc Eric Dumazet <[email protected]>
Cc David S. Miller <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Tejun Heo <[email protected]>
---
 mm/memcontrol.c                 | 14 ++++++++++++++
 net/core/sock.c                 |  5 +----
 net/ipv4/inet_connection_sock.c |  1 -
 3 files changed, 15 insertions(+), 5 deletions(-)
mm/memcontrol.c +14 -0
index 0ae2dc3a1748..0937f2c52c7d 100644
@@ -5747,6 +5747,20 @@ void mem_cgroup_sk_alloc(struct sock *sk)
 	if (!mem_cgroup_sockets_enabled)
 		return;
 
+	/*
+	 * Socket cloning can throw us here with sk_memcg already
+	 * filled. It won't however, necessarily happen from
+	 * process context. So the test for root memcg given
+	 * the current task's memcg won't help us in this case.
+	 *
+	 * Respecting the original socket's memcg is a better
+	 * decision in this case.
+	 */
+	if (sk->sk_memcg) {
+		css_get(&sk->sk_memcg->css);
+		return;
+	}
+
 	rcu_read_lock();
 	memcg = mem_cgroup_from_task(current);
 	if (memcg == root_mem_cgroup)
net/core/sock.c +1 -4
index 1033f8ab0547..e50e7b3f2223 100644
@@ -1683,16 +1683,13 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
 		newsk->sk_dst_pending_confirm = 0;
 		newsk->sk_wmem_queued	= 0;
 		newsk->sk_forward_alloc = 0;
-
-		/* sk->sk_memcg will be populated at accept() time */
-		newsk->sk_memcg = NULL;
-
 		atomic_set(&newsk->sk_drops, 0);
 		newsk->sk_send_head	= NULL;
 		newsk->sk_userlocks	= sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
 		atomic_set(&newsk->sk_zckey, 0);
 
 		sock_reset_flag(newsk, SOCK_DONE);
+		mem_cgroup_sk_alloc(newsk);
 		cgroup_sk_alloc(&newsk->sk_cgrp_data);
 
 		rcu_read_lock();
net/ipv4/inet_connection_sock.c +0 -1
index 12410ec6f7f7..881ac6d046f2 100644
@@ -475,7 +475,6 @@ struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
 		}
 		spin_unlock_bh(&queue->fastopenq.lock);
 	}
-	mem_cgroup_sk_alloc(newsk);
 out:
 	release_sock(sk);
 	if (req)
Signature · 1 line
2.14.3
#1 lore raw
Quoted 35 lines · Roman Gushchin

This patch effectively reverts commit 9f1c2674b328 ("net: memcontrol:
defer call to mem_cgroup_sk_alloc()").

Moving mem_cgroup_sk_alloc() to the inet_csk_accept() completely breaks memcg socket memory accounting, as packets received before memcg pointer initialization are not accounted and are causing refcounting underflow on socket release.

Actually the free-after-use problem was fixed by commit c0576e397508 ("net: call cgroup_sk_alloc() earlier in sk_clone_lock()") for the cgroup pointer.

So, let's revert it and call mem_cgroup_sk_alloc() just before cgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.

Cc Eric Dumazet <[email protected]>
Cc David S. Miller <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Tejun Heo <[email protected]>
---
 mm/memcontrol.c                 | 14 ++++++++++++++
 net/core/sock.c                 |  5 +----
 net/ipv4/inet_connection_sock.c |  1 -
 3 files changed, 15 insertions(+), 5 deletions(-)
mm/memcontrol.c +0 -0
index 0ae2dc3a1748..0937f2c52c7d 100644
@@ -5747,6 +5747,20 @@ void mem_cgroup_sk_alloc(struct sock *sk)
 	if (!mem_cgroup_sockets_enabled)
 		return;
 

mm/memcontrol.c void mem_cgroup_sk_alloc(struct sock *sk) · line 5759

Quoted 10 lines
mm/memcontrol.c +10 -0
+	/*
+	 * Socket cloning can throw us here with sk_memcg already
+	 * filled. It won't however, necessarily happen from
+	 * process context. So the test for root memcg given
+	 * the current task's memcg won't help us in this case.
+	 *
+	 * Respecting the original socket's memcg is a better
+	 * decision in this case.
+	 */
+	if (sk->sk_memcg) {

Original commit had a BUG_ON(mem_cgroup_is_root(sk->sk_memcg));

I presume it is no longer useful ?

Thanks

Quoted 5 lines
mm/memcontrol.c +4 -0
+		css_get(&sk->sk_memcg->css);
+		return;
+	}
+
 	rcu_read_lock();
#2 lore raw
Quoted 49 lines · Eric Dumazet
Quoted 35 lines · Roman Gushchin

This patch effectively reverts commit 9f1c2674b328 ("net: memcontrol:
defer call to mem_cgroup_sk_alloc()").

Moving mem_cgroup_sk_alloc() to the inet_csk_accept() completely breaks memcg socket memory accounting, as packets received before memcg pointer initialization are not accounted and are causing refcounting underflow on socket release.

Actually the free-after-use problem was fixed by commit c0576e397508 ("net: call cgroup_sk_alloc() earlier in sk_clone_lock()") for the cgroup pointer.

So, let's revert it and call mem_cgroup_sk_alloc() just before cgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.

Cc Eric Dumazet <[email protected]>
Cc David S. Miller <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Tejun Heo <[email protected]>
---
 mm/memcontrol.c                 | 14 ++++++++++++++
 net/core/sock.c                 |  5 +----
 net/ipv4/inet_connection_sock.c |  1 -
 3 files changed, 15 insertions(+), 5 deletions(-)
mm/memcontrol.c +0 -0
index 0ae2dc3a1748..0937f2c52c7d 100644
@@ -5747,6 +5747,20 @@ void mem_cgroup_sk_alloc(struct sock *sk)
 	if (!mem_cgroup_sockets_enabled)
 		return;
 

mm/memcontrol.c void mem_cgroup_sk_alloc(struct sock *sk) · line 5759

Quoted 10 lines
mm/memcontrol.c +10 -0
+	/*
+	 * Socket cloning can throw us here with sk_memcg already
+	 * filled. It won't however, necessarily happen from
+	 * process context. So the test for root memcg given
+	 * the current task's memcg won't help us in this case.
+	 *
+	 * Respecting the original socket's memcg is a better
+	 * decision in this case.
+	 */
+	if (sk->sk_memcg) {

Original commit had a BUG_ON(mem_cgroup_is_root(sk->sk_memcg));

Quoted 1 line

I presume it is no longer useful ?

Idk, how even we can hit it? And if so, what scary will happen?

If you prefer to have it there, I definitely can return it, but I see no profit so far.

Thanks!

#3 lore raw
Quoted 5 lines · Roman Gushchin

Idk, how even we can hit it? And if so, what scary will happen?

If you prefer to have it there, I definitely can return it, but I see no profit so far.

I was simply curious this was not mentioned in the changelog.

A revert is normally a true revert, modulo the changes needed by conflicts and possible changes.

I personally do not care of this BUG_ON(), I had not put it in the first place.

Thanks.

#4 lore raw
Quoted 7 lines · Eric Dumazet
Quoted 5 lines · Roman Gushchin

Idk, how even we can hit it? And if so, what scary will happen?

If you prefer to have it there, I definitely can return it, but I see no profit so far.

Quoted 7 lines

I was simply curious this was not mentioned in the changelog.

A revert is normally a true revert, modulo the changes needed by conflicts and possible changes.

I personally do not care of this BUG_ON(), I had not put it in the first place.

Technically it's not a true revert, but you're totally right. Let me add a note to the commit description.

Are you ok with the rest?

Thanks!

#5 lore raw
Quoted 13 lines · Roman Gushchin
Quoted 12 lines · Eric Dumazet
Quoted 5 lines · Roman Gushchin

Idk, how even we can hit it? And if so, what scary will happen?

If you prefer to have it there, I definitely can return it, but I see no profit so far.

I was simply curious this was not mentioned in the changelog.

A revert is normally a true revert, modulo the changes needed by conflicts and possible changes.

Quoted 7 lines
Quoted 2 lines

I personally do not care of this BUG_ON(), I had not put it in the first place.

Technically it's not a true revert, but you're totally right. Let me add a note to the commit description.

Are you ok with the rest?

Sure !

Thanks.

#6 lore raw

PATCH 1/1 Revert "defer call to mem_cgroup_sk_alloc()"

Quoted 17 lines · Eric Dumazet
Quoted 16 lines · Roman Gushchin
Quoted 14 lines · Eric Dumazet
Quoted 5 lines · Roman Gushchin

Idk, how even we can hit it? And if so, what scary will happen?

If you prefer to have it there, I definitely can return it, but I see no profit so far.

I was simply curious this was not mentioned in the changelog.

A revert is normally a true revert, modulo the changes needed by conflicts and possible changes.

I personally do not care of this BUG_ON(), I had not put it in the first place.

Quoted 8 lines
Quoted 4 lines

Technically it's not a true revert, but you're totally right. Let me add a note to the commit description.

Are you ok with the rest?

Sure !

Thanks.

Hello, David!

Can you, please, pull the patch below?
It should be applied for 4.14+.

Thank you!

Roman

--

Quoted 1 line

From a0a07f65a38105562bf424d7dc072a2bc4f1569e Mon Sep 17 00:00:00 2001

From: Roman Gushchin <[email protected]>
Date: Fri, 2 Feb 2018 15:26:57 +0000
Subject: [PATCH net] Revert "defer call to mem_cgroup_sk_alloc()"

This patch effectively reverts commit 9f1c2674b328 ("net: memcontrol:
defer call to mem_cgroup_sk_alloc()").

Moving mem_cgroup_sk_alloc() to the inet_csk_accept() completely breaks memcg socket memory accounting, as packets received before memcg pointer initialization are not accounted and are causing refcounting underflow on socket release.

Actually the free-after-use problem was fixed by commit c0576e397508 ("net: call cgroup_sk_alloc() earlier in sk_clone_lock()") for the cgroup pointer.

So, let's revert it and call mem_cgroup_sk_alloc() just before cgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.

Also, let's drop BUG_ON(mem_cgroup_is_root()) check from mem_cgroup_sk_alloc(). I see no reasons why bumping the root memcg counter is a good reason to panic, and there are no realistic ways to hit it.

Cc Eric Dumazet <[email protected]>
Cc David S. Miller <[email protected]>
Cc Johannes Weiner <[email protected]>
Cc Tejun Heo <[email protected]>
---
 mm/memcontrol.c                 | 14 ++++++++++++++
 net/core/sock.c                 |  5 +----
 net/ipv4/inet_connection_sock.c |  1 -
 3 files changed, 15 insertions(+), 5 deletions(-)
mm/memcontrol.c +14 -0
index 0ae2dc3a1748..0937f2c52c7d 100644
@@ -5747,6 +5747,20 @@ void mem_cgroup_sk_alloc(struct sock *sk)
 	if (!mem_cgroup_sockets_enabled)
 		return;
 
+	/*
+	 * Socket cloning can throw us here with sk_memcg already
+	 * filled. It won't however, necessarily happen from
+	 * process context. So the test for root memcg given
+	 * the current task's memcg won't help us in this case.
+	 *
+	 * Respecting the original socket's memcg is a better
+	 * decision in this case.
+	 */
+	if (sk->sk_memcg) {
+		css_get(&sk->sk_memcg->css);
+		return;
+	}
+
 	rcu_read_lock();
 	memcg = mem_cgroup_from_task(current);
 	if (memcg == root_mem_cgroup)
net/core/sock.c +1 -4
index 1033f8ab0547..e50e7b3f2223 100644
@@ -1683,16 +1683,13 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
 		newsk->sk_dst_pending_confirm = 0;
 		newsk->sk_wmem_queued	= 0;
 		newsk->sk_forward_alloc = 0;
-
-		/* sk->sk_memcg will be populated at accept() time */
-		newsk->sk_memcg = NULL;
-
 		atomic_set(&newsk->sk_drops, 0);
 		newsk->sk_send_head	= NULL;
 		newsk->sk_userlocks	= sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
 		atomic_set(&newsk->sk_zckey, 0);
 
 		sock_reset_flag(newsk, SOCK_DONE);
+		mem_cgroup_sk_alloc(newsk);
 		cgroup_sk_alloc(&newsk->sk_cgrp_data);
 
 		rcu_read_lock();
net/ipv4/inet_connection_sock.c +0 -1
index 12410ec6f7f7..881ac6d046f2 100644
@@ -475,7 +475,6 @@ struct sock *inet_csk_accept(struct sock *sk, int flags, int *err, bool kern)
 		}
 		spin_unlock_bh(&queue->fastopenq.lock);
 	}
-	mem_cgroup_sk_alloc(newsk);
 out:
 	release_sock(sk);
 	if (req)
Signature · 1 line
2.14.3