net/ipv4/tcp_memcontrol.c

   1 #include <net/tcp.h>
   2 #include <net/tcp_memcontrol.h>
   3 #include <net/sock.h>
   4 #include <net/ip.h>
   5 #include <linux/nsproxy.h>
   6 #include <linux/memcontrol.h>
   7 #include <linux/module.h>
   8
   9 static void memcg_tcp_enter_memory_pressure(struct sock *sk)
  10 {
  11         if (sk->sk_cgrp->memory_pressure)
  12                 sk->sk_cgrp->memory_pressure = 1;
  13 }
  14 EXPORT_SYMBOL(memcg_tcp_enter_memory_pressure);
  15
  16 int tcp_init_cgroup(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
  17 {
  18         /*
  19          * The root cgroup does not use res_counters, but rather,
  20          * rely on the data already collected by the network
  21          * subsystem
  22          */
  23         struct res_counter *res_parent = NULL;
  24         struct cg_proto *cg_proto, *parent_cg;
  25         struct mem_cgroup *parent = parent_mem_cgroup(memcg);
  26
  27         cg_proto = tcp_prot.proto_cgroup(memcg);
  28         if (!cg_proto)
  29                 return 0;
  30
  31         cg_proto->sysctl_mem[0] = sysctl_tcp_mem[0];
  32         cg_proto->sysctl_mem[1] = sysctl_tcp_mem[1];
  33         cg_proto->sysctl_mem[2] = sysctl_tcp_mem[2];
  34         cg_proto->memory_pressure = 0;
  35         cg_proto->memcg = memcg;
  36
  37         parent_cg = tcp_prot.proto_cgroup(parent);
  38         if (parent_cg)
  39                 res_parent = &parent_cg->memory_allocated;
  40
  41         res_counter_init(&cg_proto->memory_allocated, res_parent);
  42         percpu_counter_init(&cg_proto->sockets_allocated, 0);
  43
  44         return 0;
  45 }
  46 EXPORT_SYMBOL(tcp_init_cgroup);
  47
  48 void tcp_destroy_cgroup(struct mem_cgroup *memcg)
  49 {
  50         struct cg_proto *cg_proto;
  51
  52         cg_proto = tcp_prot.proto_cgroup(memcg);
  53         if (!cg_proto)
  54                 return;
  55
  56         percpu_counter_destroy(&cg_proto->sockets_allocated);
  57 }
  58 EXPORT_SYMBOL(tcp_destroy_cgroup);
  59
  60 static int tcp_update_limit(struct mem_cgroup *memcg, u64 val)
  61 {
  62         struct cg_proto *cg_proto;
  63         int i;
  64         int ret;
  65
  66         cg_proto = tcp_prot.proto_cgroup(memcg);
  67         if (!cg_proto)
  68                 return -EINVAL;
  69
  70         if (val > RES_COUNTER_MAX)
  71                 val = RES_COUNTER_MAX;
  72
  73         ret = res_counter_set_limit(&cg_proto->memory_allocated, val);
  74         if (ret)
  75                 return ret;
  76
  77         for (i = 0; i < 3; i++)
  78                 cg_proto->sysctl_mem[i] = min_t(long, val >> PAGE_SHIFT,
  79                                                 sysctl_tcp_mem[i]);
  80
  81         if (val == RES_COUNTER_MAX)
  82                 clear_bit(MEMCG_SOCK_ACTIVE, &cg_proto->flags);
  83         else if (val != RES_COUNTER_MAX) {
  84                 /*
  85                  * The active bit needs to be written after the static_key
  86                  * update. This is what guarantees that the socket activation
  87                  * function is the last one to run. See sock_update_memcg() for
  88                  * details, and note that we don't mark any socket as belonging
  89                  * to this memcg until that flag is up.
  90                  *
  91                  * We need to do this, because static_keys will span multiple
  92                  * sites, but we can't control their order. If we mark a socket
  93                  * as accounted, but the accounting functions are not patched in
  94                  * yet, we'll lose accounting.
  95                  *
  96                  * We never race with the readers in sock_update_memcg(),
  97                  * because when this value change, the code to process it is not
  98                  * patched in yet.
  99                  *
 100                  * The activated bit is used to guarantee that no two writers
 101                  * will do the update in the same memcg. Without that, we can't
 102                  * properly shutdown the static key.
 103                  */
 104                 if (!test_and_set_bit(MEMCG_SOCK_ACTIVATED, &cg_proto->flags))
 105                         static_key_slow_inc(&memcg_socket_limit_enabled);
 106                 set_bit(MEMCG_SOCK_ACTIVE, &cg_proto->flags);
 107         }
 108
 109         return 0;
 110 }
 111
 112 static int tcp_cgroup_write(struct cgroup_subsys_state *css, struct cftype *cft,
 113                             const char *buffer)
 114 {
 115         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 116         unsigned long long val;
 117         int ret = 0;
 118
 119         switch (cft->private) {
 120         case RES_LIMIT:
 121                 /* see memcontrol.c */
 122                 ret = res_counter_memparse_write_strategy(buffer, &val);
 123                 if (ret)
 124                         break;
 125                 ret = tcp_update_limit(memcg, val);
 126                 break;
 127         default:
 128                 ret = -EINVAL;
 129                 break;
 130         }
 131         return ret;
 132 }
 133
 134 static u64 tcp_read_stat(struct mem_cgroup *memcg, int type, u64 default_val)
 135 {
 136         struct cg_proto *cg_proto;
 137
 138         cg_proto = tcp_prot.proto_cgroup(memcg);
 139         if (!cg_proto)
 140                 return default_val;
 141
 142         return res_counter_read_u64(&cg_proto->memory_allocated, type);
 143 }
 144
 145 static u64 tcp_read_usage(struct mem_cgroup *memcg)
 146 {
 147         struct cg_proto *cg_proto;
 148
 149         cg_proto = tcp_prot.proto_cgroup(memcg);
 150         if (!cg_proto)
 151                 return atomic_long_read(&tcp_memory_allocated) << PAGE_SHIFT;
 152
 153         return res_counter_read_u64(&cg_proto->memory_allocated, RES_USAGE);
 154 }
 155
 156 static u64 tcp_cgroup_read(struct cgroup_subsys_state *css, struct cftype *cft)
 157 {
 158         struct mem_cgroup *memcg = mem_cgroup_from_css(css);
 159         u64 val;
 160
 161         switch (cft->private) {
 162         case RES_LIMIT:
 163                 val = tcp_read_stat(memcg, RES_LIMIT, RES_COUNTER_MAX);
 164                 break;
 165         case RES_USAGE:
 166                 val = tcp_read_usage(memcg);
 167                 break;
 168         case RES_FAILCNT:
 169         case RES_MAX_USAGE:
 170                 val = tcp_read_stat(memcg, cft->private, 0);
 171                 break;
 172         default:
 173                 BUG();
 174         }
 175         return val;
 176 }
 177
 178 static int tcp_cgroup_reset(struct cgroup_subsys_state *css, unsigned int event)
 179 {
 180         struct mem_cgroup *memcg;
 181         struct cg_proto *cg_proto;
 182
 183         memcg = mem_cgroup_from_css(css);
 184         cg_proto = tcp_prot.proto_cgroup(memcg);
 185         if (!cg_proto)
 186                 return 0;
 187
 188         switch (event) {
 189         case RES_MAX_USAGE:
 190                 res_counter_reset_max(&cg_proto->memory_allocated);
 191                 break;
 192         case RES_FAILCNT:
 193                 res_counter_reset_failcnt(&cg_proto->memory_allocated);
 194                 break;
 195         }
 196
 197         return 0;
 198 }
 199
 200 static struct cftype tcp_files[] = {
 201         {
 202                 .name = "kmem.tcp.limit_in_bytes",
 203                 .write_string = tcp_cgroup_write,
 204                 .read_u64 = tcp_cgroup_read,
 205                 .private = RES_LIMIT,
 206         },
 207         {
 208                 .name = "kmem.tcp.usage_in_bytes",
 209                 .read_u64 = tcp_cgroup_read,
 210                 .private = RES_USAGE,
 211         },
 212         {
 213                 .name = "kmem.tcp.failcnt",
 214                 .private = RES_FAILCNT,
 215                 .trigger = tcp_cgroup_reset,
 216                 .read_u64 = tcp_cgroup_read,
 217         },
 218         {
 219                 .name = "kmem.tcp.max_usage_in_bytes",
 220                 .private = RES_MAX_USAGE,
 221                 .trigger = tcp_cgroup_reset,
 222                 .read_u64 = tcp_cgroup_read,
 223         },
 224         { }     /* terminate */
 225 };
 226
 227 static int __init tcp_memcontrol_init(void)
 228 {
 229         WARN_ON(cgroup_add_cftypes(&mem_cgroup_subsys, tcp_files));
 230         return 0;
 231 }
 232 __initcall(tcp_memcontrol_init);