Revert "defer call to mem_cgroup_sk_alloc()"
Subsystems (6)
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.
--- 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
@@ -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
@@ -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
@@ -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
Quoted 35 lines · Roman Gushchin
This patch effectively reverts commit
9f1c2674b328("net: memcontrol:
defer call tomem_cgroup_sk_alloc()").Moving
mem_cgroup_sk_alloc()to theinet_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: callcgroup_sk_alloc()earlier insk_clone_lock()") for the cgroup pointer.So, let's revert it and call
mem_cgroup_sk_alloc()just beforecgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.Signed-off-by Roman Gushchin <[email protected]>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@@ -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 ();
Quoted 49 lines · Eric Dumazet
Quoted 35 lines · Roman Gushchin
This patch effectively reverts commit
9f1c2674b328("net: memcontrol:
defer call tomem_cgroup_sk_alloc()").Moving
mem_cgroup_sk_alloc()to theinet_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: callcgroup_sk_alloc()earlier insk_clone_lock()") for the cgroup pointer.So, let's revert it and call
mem_cgroup_sk_alloc()just beforecgroup_sk_alloc(). This is safe, as we hold a reference to the socket we're cloning, and it holds a reference to the memcg.Signed-off-by Roman Gushchin <[email protected]>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@@ -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!
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.
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!
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.
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
a0a07f65a38105562bf424d7dc072a2bc4f1569eMon 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.
--- 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
@@ -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
@@ -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
@@ -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