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