net: tcp_memcontrol: sanitize tcp memory accounting callbacks

There won't be a tcp control soft limit, so integrating the memcg code
into the global skmem limiting scheme complicates things unnecessarily.
Replace this with simple and clear charge and uncharge calls--hidden
behind a jump label--to account skb memory.

Note that this is not purely aesthetic: as a result of shoehorning the
per-memcg code into the same memory accounting functions that handle the
global level, the old code would compare the per-memcg consumption
against the smaller of the per-memcg limit and the global limit.  This
allowed the total consumption of multiple sockets to exceed the global
limit, as long as the individual sockets stayed within bounds.  After
this change, the code will always compare the per-memcg consumption to
the per-memcg limit, and the global consumption to the global limit, and
thus close this loophole.

Without a soft limit, the per-memcg memory pressure state in sockets is
generally questionable.  However, we did it until now, so we continue to
enter it when the hard limit is hit, and packets are dropped, to let
other sockets in the cgroup know that they shouldn't grow their transmit
windows, either.  However, keep it simple in the new callback model and
leave memory pressure lazily when the next packet is accepted (as
opposed to doing it synchroneously when packets are processed).  When
packets are dropped, network performance will already be in the toilet,
so that should be a reasonable trade-off.

As described above, consumption is now checked on the per-memcg level
and the global level separately.  Likewise, memory pressure states are
maintained on both the per-memcg level and the global level, and a
socket is considered under pressure when either level asserts as much.

Signed-off-by: Johannes Weiner <hannes@cmpxchg.org>
Reviewed-by: Vladimir Davydov <vdavydov@virtuozzo.com>
Acked-by: David S. Miller <davem@davemloft.net>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 21 insertions, 12 deletions

diff --git a/net/core/sock.c b/net/core/sock.c
index 6c5dab01105b..89ae859d2dc5 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -2084,27 +2084,27 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind)
         struct proto *prot = sk->sk_prot;
         int amt = sk_mem_pages(size);
         long allocated;
-        int parent_status = UNDER_LIMIT;
 
         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
 
-        allocated = sk_memory_allocated_add(sk, amt, &parent_status);
+        allocated = sk_memory_allocated_add(sk, amt);
+
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp &&
+            !mem_cgroup_charge_skmem(sk->sk_cgrp, amt))
+                goto suppress_allocation;
 
         /* Under limit. */
-        if (parent_status == UNDER_LIMIT &&
-                        allocated <= sk_prot_mem_limits(sk, 0)) {
+        if (allocated <= sk_prot_mem_limits(sk, 0)) {
                 sk_leave_memory_pressure(sk);
                 return 1;
         }
 
-        /* Under pressure. (we or our parents) */
-        if ((parent_status > SOFT_LIMIT) ||
-                        allocated > sk_prot_mem_limits(sk, 1))
+        /* Under pressure. */
+        if (allocated > sk_prot_mem_limits(sk, 1))
                 sk_enter_memory_pressure(sk);
 
-        /* Over hard limit (we or our parents) */
-        if ((parent_status == OVER_LIMIT) ||
-                        (allocated > sk_prot_mem_limits(sk, 2)))
+        /* Over hard limit. */
+        if (allocated > sk_prot_mem_limits(sk, 2))
                 goto suppress_allocation;
 
         /* guarantee minimum buffer size under pressure */
@@ -2153,6 +2153,9 @@ suppress_allocation:
 
         sk_memory_allocated_sub(sk, amt);
 
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
+                mem_cgroup_uncharge_skmem(sk->sk_cgrp, amt);
+
         return 0;
 }
 EXPORT_SYMBOL(__sk_mem_schedule);
@@ -2168,6 +2171,9 @@ void __sk_mem_reclaim(struct sock *sk, int amount)
         sk_memory_allocated_sub(sk, amount);
         sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
 
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
+                mem_cgroup_uncharge_skmem(sk->sk_cgrp, amount);
+
         if (sk_under_memory_pressure(sk) &&
             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
                 sk_leave_memory_pressure(sk);
diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
index 412a920fe0ec..493b48945f0c 100644
--- a/net/ipv4/tcp_output.c
+++ b/net/ipv4/tcp_output.c
@@ -2813,13 +2813,16 @@ begin_fwd:
  */
 void sk_forced_mem_schedule(struct sock *sk, int size)
 {
-        int amt, status;
+        int amt;
 
         if (size <= sk->sk_forward_alloc)
                 return;
         amt = sk_mem_pages(size);
         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
-        sk_memory_allocated_add(sk, amt, &status);
+        sk_memory_allocated_add(sk, amt);
+
+        if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
+                mem_cgroup_charge_skmem(sk->sk_cgrp, amt);
 }
 
 /* Send a FIN. The caller locks the socket for us.