foundations of per-cgroup memory pressure controlling.

This patch replaces all uses of struct sock fields' memory_pressure,
memory_allocated, sockets_allocated, and sysctl_mem to acessor
macros. Those macros can either receive a socket argument, or a mem_cgroup
argument, depending on the context they live in.

Since we're only doing a macro wrapping here, no performance impact at all is
expected in the case where we don't have cgroups disabled.

Signed-off-by: Glauber Costa <glommer@parallels.com>
Reviewed-by: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com>
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, 34 insertions, 23 deletions

diff --git a/net/core/sock.c b/net/core/sock.c
index 9777da86aeac..a3d4205e7238 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1323,7 +1323,7 @@ struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
                 newsk->sk_wq = NULL;
 
                 if (newsk->sk_prot->sockets_allocated)
-                        percpu_counter_inc(newsk->sk_prot->sockets_allocated);
+                        sk_sockets_allocated_inc(newsk);
 
                 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
                         net_enable_timestamp();
@@ -1713,28 +1713,28 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind)
         long allocated;
 
         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
-        allocated = atomic_long_add_return(amt, prot->memory_allocated);
+
+        allocated = sk_memory_allocated_add(sk, amt);
 
         /* Under limit. */
-        if (allocated <= prot->sysctl_mem[0]) {
-                if (prot->memory_pressure && *prot->memory_pressure)
-                        *prot->memory_pressure = 0;
+        if (allocated <= sk_prot_mem_limits(sk, 0)) {
+                sk_leave_memory_pressure(sk);
                 return 1;
         }
 
         /* Under pressure. */
-        if (allocated > prot->sysctl_mem[1])
-                if (prot->enter_memory_pressure)
-                        prot->enter_memory_pressure(sk);
+        if (allocated > sk_prot_mem_limits(sk, 1))
+                sk_enter_memory_pressure(sk);
 
         /* Over hard limit. */
-        if (allocated > prot->sysctl_mem[2])
+        if (allocated > sk_prot_mem_limits(sk, 2))
                 goto suppress_allocation;
 
         /* guarantee minimum buffer size under pressure */
         if (kind == SK_MEM_RECV) {
                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
                         return 1;
+
         } else { /* SK_MEM_SEND */
                 if (sk->sk_type == SOCK_STREAM) {
                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
@@ -1744,13 +1744,13 @@ int __sk_mem_schedule(struct sock *sk, int size, int kind)
                                 return 1;
         }
 
-        if (prot->memory_pressure) {
+        if (sk_has_memory_pressure(sk)) {
                 int alloc;
 
-                if (!*prot->memory_pressure)
+                if (!sk_under_memory_pressure(sk))
                         return 1;
-                alloc = percpu_counter_read_positive(prot->sockets_allocated);
-                if (prot->sysctl_mem[2] > alloc *
+                alloc = sk_sockets_allocated_read_positive(sk);
+                if (sk_prot_mem_limits(sk, 2) > alloc *
                     sk_mem_pages(sk->sk_wmem_queued +
                                  atomic_read(&sk->sk_rmem_alloc) +
                                  sk->sk_forward_alloc))
@@ -1773,7 +1773,9 @@ suppress_allocation:
 
         /* Alas. Undo changes. */
         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
-        atomic_long_sub(amt, prot->memory_allocated);
+
+        sk_memory_allocated_sub(sk, amt);
+
         return 0;
 }
 EXPORT_SYMBOL(__sk_mem_schedule);
@@ -1784,15 +1786,13 @@ EXPORT_SYMBOL(__sk_mem_schedule);
  */
 void __sk_mem_reclaim(struct sock *sk)
 {
-        struct proto *prot = sk->sk_prot;
-
-        atomic_long_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
-                   prot->memory_allocated);
+        sk_memory_allocated_sub(sk,
+                                sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT);
         sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
 
-        if (prot->memory_pressure && *prot->memory_pressure &&
-            (atomic_long_read(prot->memory_allocated) < prot->sysctl_mem[0]))
-                *prot->memory_pressure = 0;
+        if (sk_under_memory_pressure(sk) &&
+            (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
+                sk_leave_memory_pressure(sk);
 }
 EXPORT_SYMBOL(__sk_mem_reclaim);
 
@@ -2507,16 +2507,27 @@ static char proto_method_implemented(const void *method)
 {
         return method == NULL ? 'n' : 'y';
 }
+static long sock_prot_memory_allocated(struct proto *proto)
+{
+        return proto->memory_allocated != NULL ? proto_memory_allocated(proto): -1L;
+}
+
+static char *sock_prot_memory_pressure(struct proto *proto)
+{
+        return proto->memory_pressure != NULL ?
+        proto_memory_pressure(proto) ? "yes" : "no" : "NI";
+}
 
 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
 {
+
         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
                    proto->name,
                    proto->obj_size,
                    sock_prot_inuse_get(seq_file_net(seq), proto),
-                   proto->memory_allocated != NULL ? atomic_long_read(proto->memory_allocated) : -1L,
-                   proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
+                   sock_prot_memory_allocated(proto),
+                   sock_prot_memory_pressure(proto),
                    proto->max_header,
                    proto->slab == NULL ? "no" : "yes",
                    module_name(proto->owner),