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