socket: initial cgroup code.

The goal of this work is to move the memory pressure tcp
controls to a cgroup, instead of just relying on global
conditions.

To avoid excessive overhead in the network fast paths,
the code that accounts allocated memory to a cgroup is
hidden inside a static_branch(). This branch is patched out
until the first non-root cgroup is created. So when nobody
is using cgroups, even if it is mounted, no significant performance
penalty should be seen.

This patch handles the generic part of the code, and has nothing
tcp-specific.

Signed-off-by: Glauber Costa <glommer@parallels.com>
Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtsu.com>
CC: Kirill A. Shutemov <kirill@shutemov.name>
CC: David S. Miller <davem@davemloft.net>
CC: Eric W. Biederman <ebiederm@xmission.com>
CC: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 16 insertions, 8 deletions

diff --git a/net/core/sock.c b/net/core/sock.c
index a3d4205e7238..6a871b8fdd20 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -111,6 +111,7 @@
 #include <linux/init.h>
 #include <linux/highmem.h>
 #include <linux/user_namespace.h>
+#include <linux/jump_label.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -142,6 +143,9 @@
 static struct lock_class_key af_family_keys[AF_MAX];
 static struct lock_class_key af_family_slock_keys[AF_MAX];
 
+struct jump_label_key memcg_socket_limit_enabled;
+EXPORT_SYMBOL(memcg_socket_limit_enabled);
+
 /*
  * Make lock validator output more readable. (we pre-construct these
  * strings build-time, so that runtime initialization of socket
@@ -1711,23 +1715,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);
+        allocated = sk_memory_allocated_add(sk, amt, &parent_status);
 
         /* Under limit. */
-        if (allocated <= sk_prot_mem_limits(sk, 0)) {
+        if (parent_status == UNDER_LIMIT &&
+                        allocated <= sk_prot_mem_limits(sk, 0)) {
                 sk_leave_memory_pressure(sk);
                 return 1;
         }
 
-        /* Under pressure. */
-        if (allocated > sk_prot_mem_limits(sk, 1))
+        /* Under pressure. (we or our parents) */
+        if ((parent_status > SOFT_LIMIT) ||
+                        allocated > sk_prot_mem_limits(sk, 1))
                 sk_enter_memory_pressure(sk);
 
-        /* Over hard limit. */
-        if (allocated > sk_prot_mem_limits(sk, 2))
+        /* Over hard limit (we or our parents) */
+        if ((parent_status == OVER_LIMIT) ||
+                        (allocated > sk_prot_mem_limits(sk, 2)))
                 goto suppress_allocation;
 
         /* guarantee minimum buffer size under pressure */
@@ -1774,7 +1782,7 @@ suppress_allocation:
         /* Alas. Undo changes. */
         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
 
-        sk_memory_allocated_sub(sk, amt);
+        sk_memory_allocated_sub(sk, amt, parent_status);
 
         return 0;
 }
@@ -1787,7 +1795,7 @@ EXPORT_SYMBOL(__sk_mem_schedule);
 void __sk_mem_reclaim(struct sock *sk)
 {
         sk_memory_allocated_sub(sk,
-                                sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT);
+                                sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT, 0);
         sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
 
         if (sk_under_memory_pressure(sk) &&