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>

diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 6c91c1b739515305dd2be979db71030dd7215291..e4e77bd1dd39ee6fb8ba84e9277f64a350b6e3ba 100644 (file)
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -660,12 +660,6 @@ void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx)
 }
 #endif /* CONFIG_MEMCG */
 
-enum {
-       UNDER_LIMIT,
-       SOFT_LIMIT,
-       OVER_LIMIT,
-};
-
 #ifdef CONFIG_CGROUP_WRITEBACK
 
 struct list_head *mem_cgroup_cgwb_list(struct mem_cgroup *memcg);
@@ -694,6 +688,19 @@ static inline void mem_cgroup_wb_stats(struct bdi_writeback *wb,
 struct sock;
 void sock_update_memcg(struct sock *sk);
 void sock_release_memcg(struct sock *sk);
+bool mem_cgroup_charge_skmem(struct cg_proto *proto, unsigned int nr_pages);
+void mem_cgroup_uncharge_skmem(struct cg_proto *proto, unsigned int nr_pages);
+#if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_INET)
+static inline bool mem_cgroup_under_socket_pressure(struct cg_proto *proto)
+{
+       return proto->memory_pressure;
+}
+#else
+static inline bool mem_cgroup_under_pressure(struct cg_proto *proto)
+{
+       return false;
+}
+#endif
 
 #ifdef CONFIG_MEMCG_KMEM
 extern struct static_key memcg_kmem_enabled_key;

diff --git a/include/net/sock.h b/include/net/sock.h
index 8b1f8e5d3a4881deccb115d612d70929efac10ef..94a6c1a740b98aa8765d97af38c86eb57c6be446 100644 (file)
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1129,8 +1129,9 @@ static inline bool sk_under_memory_pressure(const struct sock *sk)
        if (!sk->sk_prot->memory_pressure)
                return false;
 
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               return !!sk->sk_cgrp->memory_pressure;
+       if (mem_cgroup_sockets_enabled && sk->sk_cgrp &&
+           mem_cgroup_under_socket_pressure(sk->sk_cgrp))
+               return true;
 
        return !!*sk->sk_prot->memory_pressure;
 }
@@ -1144,9 +1145,6 @@ static inline void sk_leave_memory_pressure(struct sock *sk)
 
        if (*memory_pressure)
                *memory_pressure = 0;
-
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               sk->sk_cgrp->memory_pressure = 0;
 }
 
 static inline void sk_enter_memory_pressure(struct sock *sk)
@@ -1154,76 +1152,30 @@ static inline void sk_enter_memory_pressure(struct sock *sk)
        if (!sk->sk_prot->enter_memory_pressure)
                return;
 
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               sk->sk_cgrp->memory_pressure = 1;
-
        sk->sk_prot->enter_memory_pressure(sk);
 }
 
 static inline long sk_prot_mem_limits(const struct sock *sk, int index)
 {
-       long limit = sk->sk_prot->sysctl_mem[index];
-
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               limit = min_t(long, limit, sk->sk_cgrp->memory_allocated.limit);
-
-       return limit;
-}
-
-static inline void memcg_memory_allocated_add(struct cg_proto *prot,
-                                             unsigned long amt,
-                                             int *parent_status)
-{
-       struct page_counter *counter;
-
-       if (page_counter_try_charge(&prot->memory_allocated, amt, &counter))
-               return;
-
-       page_counter_charge(&prot->memory_allocated, amt);
-       *parent_status = OVER_LIMIT;
-}
-
-static inline void memcg_memory_allocated_sub(struct cg_proto *prot,
-                                             unsigned long amt)
-{
-       page_counter_uncharge(&prot->memory_allocated, amt);
+       return sk->sk_prot->sysctl_mem[index];
 }
 
 static inline long
 sk_memory_allocated(const struct sock *sk)
 {
-       struct proto *prot = sk->sk_prot;
-
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               return page_counter_read(&sk->sk_cgrp->memory_allocated);
-
-       return atomic_long_read(prot->memory_allocated);
+       return atomic_long_read(sk->sk_prot->memory_allocated);
 }
 
 static inline long
-sk_memory_allocated_add(struct sock *sk, int amt, int *parent_status)
+sk_memory_allocated_add(struct sock *sk, int amt)
 {
-       struct proto *prot = sk->sk_prot;
-
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp) {
-               memcg_memory_allocated_add(sk->sk_cgrp, amt, parent_status);
-               /* update the root cgroup regardless */
-               atomic_long_add_return(amt, prot->memory_allocated);
-               return page_counter_read(&sk->sk_cgrp->memory_allocated);
-       }
-
-       return atomic_long_add_return(amt, prot->memory_allocated);
+       return atomic_long_add_return(amt, sk->sk_prot->memory_allocated);
 }
 
 static inline void
 sk_memory_allocated_sub(struct sock *sk, int amt)
 {
-       struct proto *prot = sk->sk_prot;
-
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               memcg_memory_allocated_sub(sk->sk_cgrp, amt);
-
-       atomic_long_sub(amt, prot->memory_allocated);
+       atomic_long_sub(amt, sk->sk_prot->memory_allocated);
 }
 
 static inline void sk_sockets_allocated_dec(struct sock *sk)

diff --git a/include/net/tcp.h b/include/net/tcp.h
index a80255f4ca33d43bb42a92a6806a1e42dc176f0c..d9df80deba31a3266b167d1894e7ebca157e6d44 100644 (file)
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -289,8 +289,9 @@ extern int tcp_memory_pressure;
 /* optimized version of sk_under_memory_pressure() for TCP sockets */
 static inline bool tcp_under_memory_pressure(const struct sock *sk)
 {
-       if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
-               return !!sk->sk_cgrp->memory_pressure;
+       if (mem_cgroup_sockets_enabled && sk->sk_cgrp &&
+           mem_cgroup_under_socket_pressure(sk->sk_cgrp))
+               return true;
 
        return tcp_memory_pressure;
 }

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index d9344dad207e0941f63060137a4effbf12daa76b..f5de783860b87330c9326b6c0c5c45e37bd5bd62 100644 (file)
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -338,6 +338,38 @@ struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg)
 }
 EXPORT_SYMBOL(tcp_proto_cgroup);
 
+/**
+ * mem_cgroup_charge_skmem - charge socket memory
+ * @proto: proto to charge
+ * @nr_pages: number of pages to charge
+ *
+ * Charges @nr_pages to @proto. Returns %true if the charge fit within
+ * @proto's configured limit, %false if the charge had to be forced.
+ */
+bool mem_cgroup_charge_skmem(struct cg_proto *proto, unsigned int nr_pages)
+{
+       struct page_counter *counter;
+
+       if (page_counter_try_charge(&proto->memory_allocated,
+                                   nr_pages, &counter)) {
+               proto->memory_pressure = 0;
+               return true;
+       }
+       page_counter_charge(&proto->memory_allocated, nr_pages);
+       proto->memory_pressure = 1;
+       return false;
+}
+
+/**
+ * mem_cgroup_uncharge_skmem - uncharge socket memory
+ * @proto - proto to uncharge
+ * @nr_pages - number of pages to uncharge
+ */
+void mem_cgroup_uncharge_skmem(struct cg_proto *proto, unsigned int nr_pages)
+{
+       page_counter_uncharge(&proto->memory_allocated, nr_pages);
+}
+
 #endif
 
 #ifdef CONFIG_MEMCG_KMEM

diff --git a/net/core/sock.c b/net/core/sock.c
index 6c5dab01105bb384fd304327776214382380934d..89ae859d2dc54f2c3502e929637cc1a5925d2e30 100644 (file)
--- 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 412a920fe0ec0925b3291e5cf3eb5220c2a398ea..493b48945f0c37cf9d707ae71447d1191164ae2c 100644 (file)
--- 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.