OpenVZ Forum - RDF feed
type: channel
items: [PATCH v8 0/9] per-cgroup tcp memory pressure controls
items: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
items: [PATCH v8 2/9] foundations of per-cgroup memory pressure controlling.
items: [PATCH v8 3/9] socket: initial cgroup code.
items: [PATCH v8 4/9] tcp memory pressure controls
items: [PATCH v8 5/9] per-netns ipv4 sysctl_tcp_mem
items: [PATCH v8 6/9] tcp buffer limitation: per-cgroup limit
items: [PATCH v8 7/9] Display current tcp memory allocation in kmem cgroup
items: [PATCH v8 8/9] Display current tcp failcnt in kmem cgroup
items: [PATCH v8 9/9] Display maximum tcp memory allocation in kmem cgroup
items: Re: [PATCH v8 0/9] per-cgroup tcp memory pressure controls
items: Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
items: Re: [PATCH v8 2/9] foundations of per-cgroup memory pressure controlling.
items: Re: [PATCH v8 3/9] socket: initial cgroup code.
items: Re: [PATCH v8 4/9] tcp memory pressure controls
items: Re: [PATCH v8 5/9] per-netns ipv4 sysctl_tcp_mem
items: Re: [PATCH v8 6/9] tcp buffer limitation: per-cgroup limit
items: Re: [PATCH v8 7/9] Display current tcp memory allocation in kmem cgroup
items: Re: [PATCH v8 9/9] Display maximum tcp memory allocation in kmem cgroup
items: RE: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller

[PATCH v8 0/9] per-cgroup tcp memory pressure controls
type: item
description: Hi, This is my new attempt to fix all the concerns that were raised during the last iteration. I should highlight: 1) proc information is kept intact. (although I kept the wrapper functions) it will be submitted as a follow up patch so it can get the attention it deserves 2) sockets now hold a reference to memcg. sockets can be alive even after the task is gone, so we don't bother with between cgroups movements. To be able to release resources more easily in this cenario, the parent pointer in struct cg_proto was replaced by a memcg object. We then iterate through its pointer (which is cleaner anyway) The rest should be mostly the same except for small fixes and style changes. Glauber Costa (9): Basic kernel memory functionality for the Memory Controller foundations of per-cgroup memory pressure controlling. socket: initial cgroup code. tcp memory pressure controls per-netns ipv4 sysctl_tcp_mem tcp buffer limitation: per-cgroup limit Display current tcp memory allocation in kmem cgroup Display current tcp failcnt in kmem cgroup Display maximum tcp memory allocation in kmem cgroup Documentation/cgroups/memory.txt | 46 ++++++- include/linux/memcontrol.h | 23 ++++ include/net/netns/ipv4.h | 1 + include/net/sock.h | 239 +++++++++++++++++++++++++++++++++- include/net/tcp.h | 4 +- include/net/tcp_memcontrol.h | 19 +++ init/Kconfig | 11 ++ mm/memcontrol.c | 189 +++++++++++++++++++++++++- net/core/sock.c | 118 ++++++++++++----- net/ipv4/Makefile | 1 + net/ipv4/af_inet.c | 2 + net/ipv4/proc.c | 6 +- net/ipv4/sysctl_net_ipv4.c | 65 ++++++++- net/ipv4/tcp.c | 11 +-- net/ipv4/tcp_input.c | 12 +- net/ipv4/tcp_ipv4.c | 14 ++- net/ipv4/tcp_memcontrol.c | 272 ++++++++++++++++++++++++++++++++++++++ net/ipv4/tcp_output.c | 2 +- net/ipv4/tcp_timer.c | 2 +- net/ipv6/af_inet6.c | 2 + net/ipv6/tcp_ipv6.c | 8 +- 21 files changed, 968 insertions(+), 79 deletions(-) create mode 100644 include/net/tcp_memcontrol.h create mode 100644 net/ipv4/tcp_memcontrol.c -- 1.7.6.4
creator: Glauber Costa
date: 2011-12-05T21:34:54-00:00

[PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: This patch lays down the foundation for the kernel memory component of the Memory Controller. As of today, I am only laying down the following files: * memory.independent_kmem_limit * memory.kmem.limit_in_bytes (currently ignored) * memory.kmem.usage_in_bytes (always zero) Signed-off-by: Glauber Costa <glommer@parallels.com> Reviewed-by: Kirill A. Shutemov <kirill@shutemov.name> CC: Paul Menage <paul@paulmenage.org> CC: Greg Thelen <gthelen@google.com> --- Documentation/cgroups/memory.txt | 40 ++++++++++++++- init/Kconfig | 11 ++++ mm/memcontrol.c | 103 ++++++++++++++++++++++++++++++++++++-- 3 files changed, 147 insertions(+), 7 deletions(-) diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt index cc0ebc5..f245324 100644 --- a/Documentation/cgroups/memory.txt +++ b/Documentation/cgroups/memory.txt @@ -44,8 +44,9 @@ Features: - oom-killer disable knob and oom-notifier - Root cgroup has no limit controls. - Kernel memory and Hugepages are not under control yet. We just manage - pages on LRU. To add more controls, we have to take care of performance. + Hugepages is not under control yet. We just manage pages on LRU. To add more + controls, we have to take care of performance. Kernel memory support is work + in progress, and the current version provides basically functionality. Brief summary of control files. @@ -56,8 +57,11 @@ Brief summary of control files. (See 5.5 for details) memory.memsw.usage_in_bytes # show current res_counter usage for memory+Swap (See 5.5 for details) + memory.kmem.usage_in_bytes # show current res_counter usage for kmem only. + (See 2.7 for details) memory.limit_in_bytes # set/show limit of memory usage memory.memsw.limit_in_bytes # set/show limit of memory+Swap usage + memory.kmem.limit_in_bytes # if allowed, set/show limit of kernel memory memory.failcnt # show the number of memory usage hits limits memory.memsw.failcnt # show the number of memory+Swap hits limits memory.max_usage_in_bytes # show max memory usa…
creator: Glauber Costa
date: 2011-12-05T21:34:55-00:00

[PATCH v8 2/9] foundations of per-cgroup memory pressure controlling.
type: item
description: 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> CC: David S. Miller <davem@davemloft.net> CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com> CC: Eric W. Biederman <ebiederm@xmission.com> CC: Eric Dumazet <eric.dumazet@gmail.com> --- include/net/sock.h | 96 ++++++++++++++++++++++++++++++++++++++++++++++++- include/net/tcp.h | 3 +- net/core/sock.c | 59 +++++++++++++++++------------- net/ipv4/proc.c | 6 ++-- net/ipv4/tcp_input.c | 12 +++--- net/ipv4/tcp_ipv4.c | 4 +- net/ipv4/tcp_output.c | 2 +- net/ipv4/tcp_timer.c | 2 +- net/ipv6/tcp_ipv6.c | 2 +- 9 files changed, 145 insertions(+), 41 deletions(-) diff --git a/include/net/sock.h b/include/net/sock.h index abb6e0f..5f43fd9 100644 --- a/include/net/sock.h +++ b/include/net/sock.h @@ -53,6 +53,7 @@ #include <linux/security.h> #include <linux/slab.h> #include <linux/uaccess.h> +#include <linux/memcontrol.h> #include <linux/filter.h> #include <linux/rculist_nulls.h> @@ -863,6 +864,99 @@ static inline void sk_refcnt_debug_release(const struct sock *sk) #define sk_refcnt_debug_release(sk) do { } while (0) #endif /* SOCK_REFCNT_DEBUG */ +static inline bool sk_has_memory_pressure(const struct sock *sk) +{ + return sk->sk_prot->memory_pressure != NULL; +} + +static inline bool sk_under_memory_pressure(const struct sock *sk) +{ + if (!sk->sk_prot->memory_pressure) + return false; + return !!*sk->sk_prot->memory_pressure; +} + +static inline void sk_leave_memory_pressure(struct sock *sk) +{ + int *memory_pressure = sk->sk_prot->memory_pressure; + + if (memory_pressure && *memory_pressure) + *memory_pressure = 0; +} + +static inline …
creator: Glauber Costa
date: 2011-12-05T21:34:56-00:00

[PATCH v8 3/9] socket: initial cgroup code.
type: item
description: The goal of this work is to move the memory pressure tcp controls to a cgroup, instead of just relying on global conditions. To avoid excessive overhead in the network fast paths, the code that accounts allocated memory to a cgroup is hidden inside a static_branch(). This branch is patched out until the first non-root cgroup is created. So when nobody is using cgroups, even if it is mounted, no significant performance penalty should be seen. This patch handles the generic part of the code, and has nothing tcp-specific. Signed-off-by: Glauber Costa <glommer@parallels.com> CC: Kirill A. Shutemov <kirill@shutemov.name> CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtsu.com> CC: David S. Miller <davem@davemloft.net> CC: Eric W. Biederman <ebiederm@xmission.com> CC: Eric Dumazet <eric.dumazet@gmail.com> --- Documentation/cgroups/memory.txt | 4 +- include/linux/memcontrol.h | 22 ++++++ include/net/sock.h | 151 ++++++++++++++++++++++++++++++++++++-- mm/memcontrol.c | 46 +++++++++++- net/core/sock.c | 24 ++++-- 5 files changed, 230 insertions(+), 17 deletions(-) diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt index f245324..23a8dc5 100644 --- a/Documentation/cgroups/memory.txt +++ b/Documentation/cgroups/memory.txt @@ -289,7 +289,9 @@ to trigger slab reclaim when those limits are reached. 2.7.1 Current Kernel Memory resources accounted -None +* sockets memory pressure: some sockets protocols have memory pressure +thresholds. The Memory Controller allows them to be controlled individually +per cgroup, instead of globally. 3. User Interface diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index b87068a..f15021b 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -85,6 +85,8 @@ extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page); extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm); +extern…
creator: Glauber Costa
date: 2011-12-05T21:34:57-00:00

[PATCH v8 4/9] tcp memory pressure controls
type: item
description: This patch introduces memory pressure controls for the tcp protocol. It uses the generic socket memory pressure code introduced in earlier patches, and fills in the necessary data in cg_proto struct. Signed-off-by: Glauber Costa <glommer@parallels.com> CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtisu.com> CC: Eric W. Biederman <ebiederm@xmission.com> --- Documentation/cgroups/memory.txt | 2 + include/linux/memcontrol.h | 1 + include/net/sock.h | 2 + include/net/tcp_memcontrol.h | 17 +++++++++ mm/memcontrol.c | 40 ++++++++++++++++++++- net/core/sock.c | 43 ++++++++++++++++++++-- net/ipv4/Makefile | 1 + net/ipv4/tcp_ipv4.c | 9 ++++- net/ipv4/tcp_memcontrol.c | 74 ++++++++++++++++++++++++++++++++++++++ net/ipv6/tcp_ipv6.c | 5 +++ 10 files changed, 189 insertions(+), 5 deletions(-) create mode 100644 include/net/tcp_memcontrol.h create mode 100644 net/ipv4/tcp_memcontrol.c diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt index 23a8dc5..687dea5 100644 --- a/Documentation/cgroups/memory.txt +++ b/Documentation/cgroups/memory.txt @@ -293,6 +293,8 @@ to trigger slab reclaim when those limits are reached. thresholds. The Memory Controller allows them to be controlled individually per cgroup, instead of globally. +* tcp memory pressure: sockets memory pressure for the tcp protocol. + 3. User Interface 0. Configuration diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index f15021b..1513994 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -86,6 +86,7 @@ extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p); extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm); extern struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg); +extern struct mem_cgroup *mem_cgroup_from_cont(struct cgroup *cont); static inline int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup) diff --git a/include/net/sock.h b/include/net/sock.h index b8a63f8..910…
creator: Glauber Costa
date: 2011-12-05T21:34:58-00:00

[PATCH v8 5/9] per-netns ipv4 sysctl_tcp_mem
type: item
description: This patch allows each namespace to independently set up its levels for tcp memory pressure thresholds. This patch alone does not buy much: we need to make this values per group of process somehow. This is achieved in the patches that follows in this patchset. Signed-off-by: Glauber Costa <glommer@parallels.com> CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> CC: David S. Miller <davem@davemloft.net> CC: Eric W. Biederman <ebiederm@xmission.com> --- include/net/netns/ipv4.h | 1 + include/net/tcp.h | 1 - net/ipv4/af_inet.c | 2 + net/ipv4/sysctl_net_ipv4.c | 51 +++++++++++++++++++++++++++++++++++++------ net/ipv4/tcp.c | 11 +------- net/ipv4/tcp_ipv4.c | 1 - net/ipv4/tcp_memcontrol.c | 9 +++++-- net/ipv6/af_inet6.c | 2 + net/ipv6/tcp_ipv6.c | 1 - 9 files changed, 57 insertions(+), 22 deletions(-) diff --git a/include/net/netns/ipv4.h b/include/net/netns/ipv4.h index d786b4f..bbd023a 100644 --- a/include/net/netns/ipv4.h +++ b/include/net/netns/ipv4.h @@ -55,6 +55,7 @@ struct netns_ipv4 { int current_rt_cache_rebuild_count; unsigned int sysctl_ping_group_range[2]; + long sysctl_tcp_mem[3]; atomic_t rt_genid; atomic_t dev_addr_genid; diff --git a/include/net/tcp.h b/include/net/tcp.h index f080e0b..61c7e76 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h @@ -230,7 +230,6 @@ extern int sysctl_tcp_fack; extern int sysctl_tcp_reordering; extern int sysctl_tcp_ecn; extern int sysctl_tcp_dsack; -extern long sysctl_tcp_mem[3]; extern int sysctl_tcp_wmem[3]; extern int sysctl_tcp_rmem[3]; extern int sysctl_tcp_app_win; diff --git a/net/ipv4/af_inet.c b/net/ipv4/af_inet.c index 1b5096a..a8bbcff 100644 --- a/net/ipv4/af_inet.c +++ b/net/ipv4/af_inet.c @@ -1671,6 +1671,8 @@ static int __init inet_init(void) ip_static_sysctl_init(); #endif + tcp_prot.sysctl_mem = init_net.ipv4.sysctl_tcp_mem; + /* * Add all the base protocols. */ diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c index 69fd720..bbd67ab 100644 --- a/net/ipv4/sysctl_net_ipv4.c +++ b/ne…
creator: Glauber Costa
date: 2011-12-05T21:34:59-00:00

[PATCH v8 6/9] tcp buffer limitation: per-cgroup limit
type: item
description: This patch uses the "tcp.limit_in_bytes" field of the kmem_cgroup to effectively control the amount of kernel memory pinned by a cgroup. This value is ignored in the root cgroup, and in all others, caps the value specified by the admin in the net namespaces' view of tcp_sysctl_mem. If namespaces are being used, the admin is allowed to set a value bigger than cgroup's maximum, the same way it is allowed to set pretty much unlimited values in a real box. Signed-off-by: Glauber Costa <glommer@parallels.com> CC: David S. Miller <davem@davemloft.net> CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com> CC: Eric W. Biederman <ebiederm@xmission.com> --- Documentation/cgroups/memory.txt | 1 + include/net/tcp_memcontrol.h | 2 + net/ipv4/sysctl_net_ipv4.c | 14 ++++ net/ipv4/tcp_memcontrol.c | 137 +++++++++++++++++++++++++++++++++++++- 4 files changed, 152 insertions(+), 2 deletions(-) diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt index 687dea5..1c9779a 100644 --- a/Documentation/cgroups/memory.txt +++ b/Documentation/cgroups/memory.txt @@ -78,6 +78,7 @@ Brief summary of control files. memory.independent_kmem_limit # select whether or not kernel memory limits are independent of user limits + memory.kmem.tcp.limit_in_bytes # set/show hard limit for tcp buf memory 1. History diff --git a/include/net/tcp_memcontrol.h b/include/net/tcp_memcontrol.h index 5f5e158..3512082 100644 --- a/include/net/tcp_memcontrol.h +++ b/include/net/tcp_memcontrol.h @@ -14,4 +14,6 @@ struct tcp_memcontrol { struct cg_proto *tcp_proto_cgroup(struct mem_cgroup *memcg); int tcp_init_cgroup(struct cgroup *cgrp, struct cgroup_subsys *ss); void tcp_destroy_cgroup(struct cgroup *cgrp, struct cgroup_subsys *ss); +unsigned long long tcp_max_memory(const struct mem_cgroup *memcg); +void tcp_prot_mem(struct mem_cgroup *memcg, long val, int idx); #endif /* _TCP_MEMCG_H */ diff --git a/net/ipv4/sysctl_net_ipv4.c b/net/ipv4/sysctl_net_ipv4.c index bbd67ab..fe9bf91 100644 --- a…
creator: Glauber Costa
date: 2011-12-05T21:35:00-00:00

[PATCH v8 7/9] Display current tcp memory allocation in kmem cgroup
type: item
description: This patch introduces kmem.tcp.usage_in_bytes file, living in the kmem_cgroup filesystem. It is a simple read-only file that displays the amount of kernel memory currently consumed by the cgroup. 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> --- Documentation/cgroups/memory.txt | 1 + net/ipv4/tcp_memcontrol.c | 21 +++++++++++++++++++++ 2 files changed, 22 insertions(+), 0 deletions(-) diff --git a/Documentation/cgroups/memory.txt b/Documentation/cgroups/memory.txt index 1c9779a..6922b6c 100644 --- a/Documentation/cgroups/memory.txt +++ b/Documentation/cgroups/memory.txt @@ -79,6 +79,7 @@ Brief summary of control files. memory.independent_kmem_limit # select whether or not kernel memory limits are independent of user limits memory.kmem.tcp.limit_in_bytes # set/show hard limit for tcp buf memory + memory.kmem.tcp.usage_in_bytes # show current tcp buf memory allocation 1. History diff --git a/net/ipv4/tcp_memcontrol.c b/net/ipv4/tcp_memcontrol.c index e353390..9481f23 100644 --- a/net/ipv4/tcp_memcontrol.c +++ b/net/ipv4/tcp_memcontrol.c @@ -17,6 +17,11 @@ static struct cftype tcp_files[] = { .read_u64 = tcp_cgroup_read, .private = RES_LIMIT, }, + { + .name = "kmem.tcp.usage_in_bytes", + .read_u64 = tcp_cgroup_read, + .private = RES_USAGE, + }, }; static inline struct tcp_memcontrol *tcp_from_cgproto(struct cg_proto *cg_proto) @@ -167,6 +172,19 @@ static u64 tcp_read_stat(struct mem_cgroup *memcg, int type, u64 default_val) return res_counter_read_u64(&tcp->tcp_memory_allocated, type); } +static u64 tcp_read_usage(struct mem_cgroup *memcg) +{ + struct tcp_memcontrol *tcp; + struct cg_proto *cg_proto; + + cg_proto = tcp_prot.proto_cgroup(memcg); + if (!cg_proto) + return atomic_long_read(&tcp_memory_allocated) << PAGE_SHIFT; + + tcp = tcp_from_cgproto(cg_proto); + return res_counter_read_u64(&tcp->tcp_memory_allo…
creator: Glauber Costa
date: 2011-12-05T21:35:01-00:00

[PATCH v8 8/9] Display current tcp failcnt in kmem cgroup
type: item
description: This patch introduces kmem.tcp.failcnt file, living in the kmem_cgroup filesystem. Following the pattern in the other memcg resources, this files keeps a counter of how many times allocation failed due to limits being hit in this cgroup. The root cgroup will always show a failcnt of 0. 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> --- net/ipv4/tcp_memcontrol.c | 31 +++++++++++++++++++++++++++++++ 1 files changed, 31 insertions(+), 0 deletions(-) diff --git a/net/ipv4/tcp_memcontrol.c b/net/ipv4/tcp_memcontrol.c index 9481f23..d438fba 100644 --- a/net/ipv4/tcp_memcontrol.c +++ b/net/ipv4/tcp_memcontrol.c @@ -9,6 +9,7 @@ static u64 tcp_cgroup_read(struct cgroup *cont, struct cftype *cft); static int tcp_cgroup_write(struct cgroup *cont, struct cftype *cft, const char *buffer); +static int tcp_cgroup_reset(struct cgroup *cont, unsigned int event); static struct cftype tcp_files[] = { { @@ -22,6 +23,12 @@ static struct cftype tcp_files[] = { .read_u64 = tcp_cgroup_read, .private = RES_USAGE, }, + { + .name = "kmem.tcp.failcnt", + .private = RES_FAILCNT, + .trigger = tcp_cgroup_reset, + .read_u64 = tcp_cgroup_read, + }, }; static inline struct tcp_memcontrol *tcp_from_cgproto(struct cg_proto *cg_proto) @@ -197,12 +204,36 @@ static u64 tcp_cgroup_read(struct cgroup *cont, struct cftype *cft) case RES_USAGE: val = tcp_read_usage(memcg); break; + case RES_FAILCNT: + val = tcp_read_stat(memcg, RES_FAILCNT, 0); + break; default: BUG(); } return val; } +static int tcp_cgroup_reset(struct cgroup *cont, unsigned int event) +{ + struct mem_cgroup *memcg; + struct tcp_memcontrol *tcp; + struct cg_proto *cg_proto; + + memcg = mem_cgroup_from_cont(cont); + cg_proto = tcp_prot.proto_cgroup(memcg); + if (!cg_proto) + return 0; + tcp = tcp_from_cgproto(cg_proto); + + switch (event) { + case RES_FAILCNT: + res_counter_reset_failc…
creator: Glauber Costa
date: 2011-12-05T21:35:02-00:00

[PATCH v8 9/9] Display maximum tcp memory allocation in kmem cgroup
type: item
description: This patch introduces kmem.tcp.max_usage_in_bytes file, living in the kmem_cgroup filesystem. The root cgroup will display a value equal to RESOURCE_MAX. This is to avoid introducing any locking schemes in the network paths when cgroups are not being actively used. All others, will see the maximum memory ever used by this cgroup. 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> --- net/ipv4/tcp_memcontrol.c | 12 +++++++++++- 1 files changed, 11 insertions(+), 1 deletions(-) diff --git a/net/ipv4/tcp_memcontrol.c b/net/ipv4/tcp_memcontrol.c index d438fba..171d7b6 100644 --- a/net/ipv4/tcp_memcontrol.c +++ b/net/ipv4/tcp_memcontrol.c @@ -29,6 +29,12 @@ static struct cftype tcp_files[] = { .trigger = tcp_cgroup_reset, .read_u64 = tcp_cgroup_read, }, + { + .name = "kmem.tcp.max_usage_in_bytes", + .private = RES_MAX_USAGE, + .trigger = tcp_cgroup_reset, + .read_u64 = tcp_cgroup_read, + }, }; static inline struct tcp_memcontrol *tcp_from_cgproto(struct cg_proto *cg_proto) @@ -205,7 +211,8 @@ static u64 tcp_cgroup_read(struct cgroup *cont, struct cftype *cft) val = tcp_read_usage(memcg); break; case RES_FAILCNT: - val = tcp_read_stat(memcg, RES_FAILCNT, 0); + case RES_MAX_USAGE: + val = tcp_read_stat(memcg, cft->private, 0); break; default: BUG(); @@ -226,6 +233,9 @@ static int tcp_cgroup_reset(struct cgroup *cont, unsigned int event) tcp = tcp_from_cgproto(cg_proto); switch (event) { + case RES_MAX_USAGE: + res_counter_reset_max(&tcp->tcp_memory_allocated); + break; case RES_FAILCNT: res_counter_reset_failcnt(&tcp->tcp_memory_allocated); break; -- 1.7.6.4
creator: Glauber Costa
date: 2011-12-05T21:35:03-00:00

Re: [PATCH v8 0/9] per-cgroup tcp memory pressure controls
type: item
description: On 12/05/2011 07:34 PM, Glauber Costa wrote: > Hi, > > This is my new attempt to fix all the concerns that were raised during > the last iteration. > > I should highlight: > 1) proc information is kept intact. (although I kept the wrapper functions) > it will be submitted as a follow up patch so it can get the attention it > deserves > 2) sockets now hold a reference to memcg. sockets can be alive even after the > task is gone, so we don't bother with between cgroups movements. > To be able to release resources more easily in this cenario, the parent > pointer in struct cg_proto was replaced by a memcg object. We then iterate > through its pointer (which is cleaner anyway) > > The rest should be mostly the same except for small fixes and style changes. > Kame, Does this one address your previous concerns? Thanks
creator: Glauber Costa
date: 2011-12-07T11:06:17-00:00

Re: [PATCH v8 0/9] per-cgroup tcp memory pressure controls
type: item
description: On Wed, 7 Dec 2011 09:06:17 -0200 Glauber Costa <glommer@parallels.com> wrote: > On 12/05/2011 07:34 PM, Glauber Costa wrote: > > Hi, > > > > This is my new attempt to fix all the concerns that were raised during > > the last iteration. > > > > I should highlight: > > 1) proc information is kept intact. (although I kept the wrapper functions) > > it will be submitted as a follow up patch so it can get the attention it > > deserves > > 2) sockets now hold a reference to memcg. sockets can be alive even after the > > task is gone, so we don't bother with between cgroups movements. > > To be able to release resources more easily in this cenario, the parent > > pointer in struct cg_proto was replaced by a memcg object. We then iterate > > through its pointer (which is cleaner anyway) > > > > The rest should be mostly the same except for small fixes and style changes. > > > > Kame, > > Does this one address your previous concerns? > Your highlight seems good. I'll look into details. Thanks, -Kame
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:04:20-00:00

Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: On Mon, 5 Dec 2011 19:34:55 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch lays down the foundation for the kernel memory component > of the Memory Controller. > > As of today, I am only laying down the following files: > > * memory.independent_kmem_limit > * memory.kmem.limit_in_bytes (currently ignored) > * memory.kmem.usage_in_bytes (always zero) > > Signed-off-by: Glauber Costa <glommer@parallels.com> > Reviewed-by: Kirill A. Shutemov <kirill@shutemov.name> > CC: Paul Menage <paul@paulmenage.org> > CC: Greg Thelen <gthelen@google.com> As I wrote, please CC Johannes and Michal Hocko for memcg related parts. A few questions. == > + val = !!val; > + > + if (parent && parent->use_hierarchy && > + (val != parent->kmem_independent_accounting)) > + return -EINVAL; == Hm, why you check val != parent->kmem_independent_accounting ? if (parent && parent->use_hierarchy) return -EINVAL; ? BTW, you didn't check this cgroup has children or not. I think if (this_cgroup->use_hierarchy && !list_empty(this_cgroup->childlen)) return -EINVAL; == > + /* > + * TODO: We need to handle the case in which we are doing > + * independent kmem accounting as authorized by our parent, > + * but then our parent changes its parameter. > + */ > + cgroup_lock(); > + memcg->kmem_independent_accounting = val; > + cgroup_unlock(); Do we need cgroup_lock() here ? Thanks, -Kame
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:21:13-00:00

Re: [PATCH v8 2/9] foundations of per-cgroup memory pressure controlling.
type: item
description: On Mon, 5 Dec 2011 19:34:56 -0200 Glauber Costa <glommer@parallels.com> wrote: > 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> > CC: David S. Miller <davem@davemloft.net> > CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com> > CC: Eric W. Biederman <ebiederm@xmission.com> > CC: Eric Dumazet <eric.dumazet@gmail.com> please get ack from network guys. from me. Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:24:38-00:00

Re: [PATCH v8 3/9] socket: initial cgroup code.
type: item
description: On Mon, 5 Dec 2011 19:34:57 -0200 Glauber Costa <glommer@parallels.com> wrote: > The goal of this work is to move the memory pressure tcp > controls to a cgroup, instead of just relying on global > conditions. > > To avoid excessive overhead in the network fast paths, > the code that accounts allocated memory to a cgroup is > hidden inside a static_branch(). This branch is patched out > until the first non-root cgroup is created. So when nobody > is using cgroups, even if it is mounted, no significant performance > penalty should be seen. > > This patch handles the generic part of the code, and has nothing > tcp-specific. > > Signed-off-by: Glauber Costa <glommer@parallels.com> > CC: Kirill A. Shutemov <kirill@shutemov.name> > CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtsu.com> > CC: David S. Miller <davem@davemloft.net> > CC: Eric W. Biederman <ebiederm@xmission.com> > CC: Eric Dumazet <eric.dumazet@gmail.com> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:49:01-00:00

Re: [PATCH v8 4/9] tcp memory pressure controls
type: item
description: On Mon, 5 Dec 2011 19:34:58 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch introduces memory pressure controls for the tcp > protocol. It uses the generic socket memory pressure code > introduced in earlier patches, and fills in the > necessary data in cg_proto struct. > > Signed-off-by: Glauber Costa <glommer@parallels.com> > CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtisu.com> > CC: Eric W. Biederman <ebiederm@xmission.com> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:51:07-00:00

Re: [PATCH v8 5/9] per-netns ipv4 sysctl_tcp_mem
type: item
description: On Mon, 5 Dec 2011 19:34:59 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch allows each namespace to independently set up > its levels for tcp memory pressure thresholds. This patch > alone does not buy much: we need to make this values > per group of process somehow. This is achieved in the > patches that follows in this patchset. > > Signed-off-by: Glauber Costa <glommer@parallels.com> > CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> > CC: David S. Miller <davem@davemloft.net> > CC: Eric W. Biederman <ebiederm@xmission.com> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:54:10-00:00

Re: [PATCH v8 6/9] tcp buffer limitation: per-cgroup limit
type: item
description: On Mon, 5 Dec 2011 19:35:00 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch uses the "tcp.limit_in_bytes" field of the kmem_cgroup to > effectively control the amount of kernel memory pinned by a cgroup. > > This value is ignored in the root cgroup, and in all others, > caps the value specified by the admin in the net namespaces' > view of tcp_sysctl_mem. > > If namespaces are being used, the admin is allowed to set a > value bigger than cgroup's maximum, the same way it is allowed > to set pretty much unlimited values in a real box. > > Signed-off-by: Glauber Costa <glommer@parallels.com> > CC: David S. Miller <davem@davemloft.net> > CC: Hiroyouki Kamezawa <kamezawa.hiroyu@jp.fujitsu.com> > CC: Eric W. Biederman <ebiederm@xmission.com> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:55:19-00:00

Re: [PATCH v8 7/9] Display current tcp memory allocation in kmem cgroup
type: item
description: On Mon, 5 Dec 2011 19:35:01 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch introduces kmem.tcp.usage_in_bytes file, living in the > kmem_cgroup filesystem. It is a simple read-only file that displays the > amount of kernel memory currently consumed by the cgroup. > > 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> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:56:47-00:00

Re: [PATCH v8 9/9] Display maximum tcp memory allocation in kmem cgroup
type: item
description: On Mon, 5 Dec 2011 19:35:03 -0200 Glauber Costa <glommer@parallels.com> wrote: > This patch introduces kmem.tcp.max_usage_in_bytes file, living in the > kmem_cgroup filesystem. The root cgroup will display a value equal > to RESOURCE_MAX. This is to avoid introducing any locking schemes in > the network paths when cgroups are not being actively used. > > All others, will see the maximum memory ever used by this cgroup. > > 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> Reviewed-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T01:57:42-00:00

Re: [PATCH v8 3/9] socket: initial cgroup code.
type: item
description: On Mon, 5 Dec 2011 19:34:57 -0200 Glauber Costa <glommer@parallels.com> wrote: > The goal of this work is to move the memory pressure tcp > controls to a cgroup, instead of just relying on global > conditions. > > To avoid excessive overhead in the network fast paths, > the code that accounts allocated memory to a cgroup is > hidden inside a static_branch(). This branch is patched out > until the first non-root cgroup is created. So when nobody > is using cgroups, even if it is mounted, no significant performance > penalty should be seen. > > This patch handles the generic part of the code, and has nothing > tcp-specific. > > Signed-off-by: Glauber Costa <glommer@parallels.com> > CC: Kirill A. Shutemov <kirill@shutemov.name> > CC: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujtsu.com> > CC: David S. Miller <davem@davemloft.net> > CC: Eric W. Biederman <ebiederm@xmission.com> > CC: Eric Dumazet <eric.dumazet@gmail.com> I already replied Reviewed-by: but... > +/* Writing them here to avoid exposing memcg's inner layout */ > +#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM > +#ifdef CONFIG_INET > +#include <net/sock.h> > + > +static bool mem_cgroup_is_root(struct mem_cgroup *memcg); > +void sock_update_memcg(struct sock *sk) > +{ > + /* A socket spends its whole life in the same cgroup */ > + if (sk->sk_cgrp) { > + WARN_ON(1); > + return; > + } > + if (static_branch(&memcg_socket_limit_enabled)) { > + struct mem_cgroup *memcg; > + > + BUG_ON(!sk->sk_prot->proto_cgroup); > + > + rcu_read_lock(); > + memcg = mem_cgroup_from_task(current); > + if (!mem_cgroup_is_root(memcg)) { > + mem_cgroup_get(memcg); > + sk->sk_cgrp = sk->sk_prot->proto_cgroup(memcg); > + } > + rcu_read_unlock(); > + } > +} Here, you do mem_cgroup_get() if !mem_cgroup_is_root(). > +EXPORT_SYMBOL(sock_update_memcg); > + > +void sock_release_memcg(struct sock *sk) > +{ > + if (static_branch(&memcg_socket_limit_enabled) && sk->sk_cgrp) { > + struct mem_cgroup *memcg; > + WARN_ON(!sk->sk_cgrp->memcg); > + memcg = sk->sk…
creator: KAMEZAWA Hiroyuki
date: 2011-12-09T02:05:50-00:00

Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: On 12/08/2011 11:21 PM, KAMEZAWA Hiroyuki wrote: > On Mon, 5 Dec 2011 19:34:55 -0200 > Glauber Costa<glommer@parallels.com> wrote: > >> This patch lays down the foundation for the kernel memory component >> of the Memory Controller. >> >> As of today, I am only laying down the following files: >> >> * memory.independent_kmem_limit >> * memory.kmem.limit_in_bytes (currently ignored) >> * memory.kmem.usage_in_bytes (always zero) >> >> Signed-off-by: Glauber Costa<glommer@parallels.com> >> Reviewed-by: Kirill A. Shutemov<kirill@shutemov.name> >> CC: Paul Menage<paul@paulmenage.org> >> CC: Greg Thelen<gthelen@google.com> > > As I wrote, please CC Johannes and Michal Hocko for memcg related parts. I forgot to add them to the patch itself, but they are in the CC list of the messages. So they did get the mail. > A few questions. > == >> + val = !!val; >> + >> + if (parent&& parent->use_hierarchy&& >> + (val != parent->kmem_independent_accounting)) >> + return -EINVAL; > == > Hm, why you check val != parent->kmem_independent_accounting ? > > if (parent&& parent->use_hierarchy) > return -EINVAL; > ? Because I thought that making sure that everybody in the chain is consistent, it will make things simpler for us. But I am happy to change that if you prefer. > BTW, you didn't check this cgroup has children or not. > I think > > if (this_cgroup->use_hierarchy&& > !list_empty(this_cgroup->childlen)) > return -EINVAL; > Noted. > == >> + /* >> + * TODO: We need to handle the case in which we are doing >> + * independent kmem accounting as authorized by our parent, >> + * but then our parent changes its parameter. >> + */ >> + cgroup_lock(); >> + memcg->kmem_independent_accounting = val; >> + cgroup_unlock(); > > Do we need cgroup_lock() here ? Well, I removed almost all instances of it from previous patches, so I guess this one can go as well.
creator: Glauber Costa
date: 2011-12-09T12:40:00-00:00

Re: [PATCH v8 2/9] foundations of per-cgroup memory pressure controlling.
type: item
description: On 12/08/2011 11:24 PM, KAMEZAWA Hiroyuki wrote: > On Mon, 5 Dec 2011 19:34:56 -0200 > Glauber Costa<glommer@parallels.com> wrote: > >> 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> >> CC: David S. Miller<davem@davemloft.net> >> CC: Hiroyouki Kamezawa<kamezawa.hiroyu@jp.fujitsu.com> >> CC: Eric W. Biederman<ebiederm@xmission.com> >> CC: Eric Dumazet<eric.dumazet@gmail.com> > > please get ack from network guys. > from me. > Reviewed-by: KAMEZAWA Hiroyuki<kamezawa.hiroyu@jp.fujitsu.com> > Ok. I think that now with all the Reviewed-by:'s I will resend it as a Request for Inclusion for Dave (plus fixing the problem you noted in patch 1)
creator: Glauber Costa
date: 2011-12-09T12:41:02-00:00

Re: [PATCH v8 3/9] socket: initial cgroup code.
type: item
description: On 12/09/2011 12:05 AM, KAMEZAWA Hiroyuki wrote: > On Mon, 5 Dec 2011 19:34:57 -0200 > Glauber Costa<glommer@parallels.com> wrote: > >> The goal of this work is to move the memory pressure tcp >> controls to a cgroup, instead of just relying on global >> conditions. >> >> To avoid excessive overhead in the network fast paths, >> the code that accounts allocated memory to a cgroup is >> hidden inside a static_branch(). This branch is patched out >> until the first non-root cgroup is created. So when nobody >> is using cgroups, even if it is mounted, no significant performance >> penalty should be seen. >> >> This patch handles the generic part of the code, and has nothing >> tcp-specific. >> >> Signed-off-by: Glauber Costa<glommer@parallels.com> >> CC: Kirill A. Shutemov<kirill@shutemov.name> >> CC: KAMEZAWA Hiroyuki<kamezawa.hiroyu@jp.fujtsu.com> >> CC: David S. Miller<davem@davemloft.net> >> CC: Eric W. Biederman<ebiederm@xmission.com> >> CC: Eric Dumazet<eric.dumazet@gmail.com> > > I already replied Reviewed-by: but... Feel free. Reviews, the more, the merrier. > > >> +/* Writing them here to avoid exposing memcg's inner layout */ >> +#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM >> +#ifdef CONFIG_INET >> +#include<net/sock.h> >> + >> +static bool mem_cgroup_is_root(struct mem_cgroup *memcg); >> +void sock_update_memcg(struct sock *sk) >> +{ >> + /* A socket spends its whole life in the same cgroup */ >> + if (sk->sk_cgrp) { >> + WARN_ON(1); >> + return; >> + } >> + if (static_branch(&memcg_socket_limit_enabled)) { >> + struct mem_cgroup *memcg; >> + >> + BUG_ON(!sk->sk_prot->proto_cgroup); >> + >> + rcu_read_lock(); >> + memcg = mem_cgroup_from_task(current); >> + if (!mem_cgroup_is_root(memcg)) { >> + mem_cgroup_get(memcg); >> + sk->sk_cgrp = sk->sk_prot->proto_cgroup(memcg); >> + } >> + rcu_read_unlock(); >> + } >> +} > > Here, you do mem_cgroup_get() if !mem_cgroup_is_root(). > > >> +EXPORT_SYMBOL(sock_update_memcg); >> + >> +void sock_release_memcg(struct sock *sk) …
creator: Glauber Costa
date: 2011-12-09T12:43:00-00:00

Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: On 12/08/2011 11:21 PM, KAMEZAWA Hiroyuki wrote: > Hm, why you check val != parent->kmem_independent_accounting ? > > if (parent&& parent->use_hierarchy) > return -EINVAL; > ? > > BTW, you didn't check this cgroup has children or not. > I think > > if (this_cgroup->use_hierarchy&& > !list_empty(this_cgroup->childlen)) > return -EINVAL; How about this? val = !!val; /* * This follows the same hierarchy restrictions than * mem_cgroup_hierarchy_write() */ if (!parent || !parent->use_hierarchy) { if (list_empty(&cgroup->children)) memcg->kmem_independent_accounting = val; else return -EBUSY; } else return -EINVAL; return 0;
creator: Glauber Costa
date: 2011-12-09T14:37:23-00:00

RE: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: > How about this? > > val = !!val; > > /* > * This follows the same hierarchy restrictions than > * mem_cgroup_hierarchy_write() > */ > if (!parent || !parent->use_hierarchy) { > if (list_empty(&cgroup->children)) > memcg->kmem_independent_accounting = val; > else > return -EBUSY; > } > else > return -EINVAL; > > return 0; Inverting the tests gives easier to read code: if (parent && parent->user_hierarchy) return -EINVAL; if (!list_empty(&cgroup->children)) return -EBUSY; memcg->kmem_independent_accounting = val != 0; return 0; NFI about the logic... On the face of it the tests don't seem related to each other or to the assignment! David
creator: David Laight
date: 2011-12-09T14:44:45-00:00

Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: On 12/09/2011 12:44 PM, David Laight wrote: > >> How about this? >> >> val = !!val; >> >> /* >> * This follows the same hierarchy restrictions than >> * mem_cgroup_hierarchy_write() >> */ >> if (!parent || !parent->use_hierarchy) { >> if (list_empty(&cgroup->children)) >> memcg->kmem_independent_accounting = val; >> else >> return -EBUSY; >> } >> else >> return -EINVAL; >> >> return 0; > > Inverting the tests gives easier to read code: > > if (parent&& parent->user_hierarchy) > return -EINVAL; > if (!list_empty(&cgroup->children)) > return -EBUSY; > memcg->kmem_independent_accounting = val != 0; > return 0; On the other hand, inconsistent with mem_cgroup_hierarchy_write(), which applies the logic in the same way I did here. > NFI about the logic... > On the face of it the tests don't seem related to each other > or to the assignment! How so? If parent's use_hierarchy is set, we can't set this value (we need to have a parent for that to even matter). We also can't set it if we already have any children - otherwise all the on-the-fly adjustments become hell-on-earth. As for = val != 0, sorry, but I completely disagree this is easier than !!val. Not to mention the !!val notation is already pretty widespread in the kernel. > David > > > > > -- > To unsubscribe, send a message with 'unsubscribe linux-mm' in > the body to majordomo@kvack.org. For more info on Linux MM, > see: http://www.linux-mm.org/ . > Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/ > Don't email:<a href=ilto:"dont@kvack.org"> email@kvack.org
creator: Glauber Costa
date: 2011-12-09T14:48:16-00:00

Re: [PATCH v8 3/9] socket: initial cgroup code.
type: item
description: On Fri, 9 Dec 2011 10:43:00 -0200 Glauber Costa <glommer@parallels.com> wrote: > On 12/09/2011 12:05 AM, KAMEZAWA Hiroyuki wrote: > > On Mon, 5 Dec 2011 19:34:57 -0200 > > Glauber Costa<glommer@parallels.com> wrote: > > > >> The goal of this work is to move the memory pressure tcp > >> controls to a cgroup, instead of just relying on global > >> conditions. > >> > >> To avoid excessive overhead in the network fast paths, > >> the code that accounts allocated memory to a cgroup is > >> hidden inside a static_branch(). This branch is patched out > >> until the first non-root cgroup is created. So when nobody > >> is using cgroups, even if it is mounted, no significant performance > >> penalty should be seen. > >> > >> This patch handles the generic part of the code, and has nothing > >> tcp-specific. > >> > >> Signed-off-by: Glauber Costa<glommer@parallels.com> > >> CC: Kirill A. Shutemov<kirill@shutemov.name> > >> CC: KAMEZAWA Hiroyuki<kamezawa.hiroyu@jp.fujtsu.com> > >> CC: David S. Miller<davem@davemloft.net> > >> CC: Eric W. Biederman<ebiederm@xmission.com> > >> CC: Eric Dumazet<eric.dumazet@gmail.com> > > > > I already replied Reviewed-by: but... > Feel free. Reviews, the more, the merrier. > > > > > > >> +/* Writing them here to avoid exposing memcg's inner layout */ > >> +#ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM > >> +#ifdef CONFIG_INET > >> +#include<net/sock.h> > >> + > >> +static bool mem_cgroup_is_root(struct mem_cgroup *memcg); > >> +void sock_update_memcg(struct sock *sk) > >> +{ > >> + /* A socket spends its whole life in the same cgroup */ > >> + if (sk->sk_cgrp) { > >> + WARN_ON(1); > >> + return; > >> + } > >> + if (static_branch(&memcg_socket_limit_enabled)) { > >> + struct mem_cgroup *memcg; > >> + > >> + BUG_ON(!sk->sk_prot->proto_cgroup); > >> + > >> + rcu_read_lock(); > >> + memcg = mem_cgroup_from_task(current); > >> + if (!mem_cgroup_is_root(memcg)) { > >> + mem_cgroup_get(memcg); > >> + sk->sk_cgrp = sk->sk_prot->proto_cgroup(memcg); > >> + } > …
creator: KAMEZAWA Hiroyuki
date: 2011-12-12T00:33:13-00:00

Re: [PATCH v8 1/9] Basic kernel memory functionality for the Memory Controller
type: item
description: On Fri, 9 Dec 2011 12:37:23 -0200 Glauber Costa <glommer@parallels.com> wrote: > On 12/08/2011 11:21 PM, KAMEZAWA Hiroyuki wrote: > > Hm, why you check val != parent->kmem_independent_accounting ? > > > > if (parent&& parent->use_hierarchy) > > return -EINVAL; > > ? > > > > BTW, you didn't check this cgroup has children or not. > > I think > > > > if (this_cgroup->use_hierarchy&& > > !list_empty(this_cgroup->childlen)) > > return -EINVAL; > > How about this? > > val = !!val; > > /* > * This follows the same hierarchy restrictions than > * mem_cgroup_hierarchy_write() > */ > if (!parent || !parent->use_hierarchy) { > if (list_empty(&cgroup->children)) > memcg->kmem_independent_accounting = val; > else > return -EBUSY; > } > else > return -EINVAL; > > return 0; > seems good to me. Thanks, -Kame
creator: KAMEZAWA Hiroyuki
date: 2011-12-12T00:34:48-00:00