From: Greg Thelen <gthelen@google.com> To: Andrew Morton <akpm@linux-foundation.org> Cc: linux-kernel@vger.kernel.org, linux-mm@kvack.org, containers@lists.osdl.org, Andrea Righi <arighi@develer.com>, Balbir Singh <balbir@linux.vnet.ibm.com>, KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>, Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>, Minchan Kim <minchan.kim@gmail.com>, Ciju Rajan K <ciju@linux.vnet.ibm.com>, David Rientjes <rientjes@google.com>, Wu Fengguang <fengguang.wu@intel.com>, Chad Talbott <ctalbott@google.com>, Justin TerAvest <teravest@google.com>, Vivek Goyal <vgoyal@redhat.com>, Greg Thelen <gthelen@google.com> Subject: [PATCH v5 8/9] memcg: add cgroupfs interface to memcg dirty limits Date: Fri, 25 Feb 2011 13:35:59 -0800 [thread overview] Message-ID: <1298669760-26344-9-git-send-email-gthelen@google.com> (raw) In-Reply-To: <1298669760-26344-1-git-send-email-gthelen@google.com> Add cgroupfs interface to memcg dirty page limits: Direct write-out is controlled with: - memory.dirty_ratio - memory.dirty_limit_in_bytes Background write-out is controlled with: - memory.dirty_background_ratio - memory.dirty_background_limit_bytes Other memcg cgroupfs files support 'M', 'm', 'k', 'K', 'g' and 'G' suffixes for byte counts. This patch provides the same functionality for memory.dirty_limit_in_bytes and memory.dirty_background_limit_bytes. Signed-off-by: Andrea Righi <arighi@develer.com> Signed-off-by: Balbir Singh <balbir@linux.vnet.ibm.com> Signed-off-by: Greg Thelen <gthelen@google.com> Acked-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> --- Changelog since v3: - Make use of new routine, __mem_cgroup_has_dirty_limit(), to disable memcg dirty limits when use_hierarchy=1. Changelog since v1: - Renamed newly created proc files: - memory.dirty_bytes -> memory.dirty_limit_in_bytes - memory.dirty_background_bytes -> memory.dirty_background_limit_in_bytes - Allow [kKmMgG] suffixes for newly created dirty limit value cgroupfs files. mm/memcontrol.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 114 insertions(+), 0 deletions(-) diff --git a/mm/memcontrol.c b/mm/memcontrol.c index bc86329..6c8885b 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -109,6 +109,13 @@ enum mem_cgroup_events_index { MEM_CGROUP_EVENTS_NSTATS, }; +enum { + MEM_CGROUP_DIRTY_RATIO, + MEM_CGROUP_DIRTY_LIMIT_IN_BYTES, + MEM_CGROUP_DIRTY_BACKGROUND_RATIO, + MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES, +}; + struct mem_cgroup_stat_cpu { long count[MEM_CGROUP_STAT_NSTATS]; unsigned long events[MEM_CGROUP_EVENTS_NSTATS]; @@ -4518,6 +4525,89 @@ static int mem_cgroup_oom_control_write(struct cgroup *cgrp, return 0; } +static u64 mem_cgroup_dirty_read(struct cgroup *cgrp, struct cftype *cft) +{ + struct mem_cgroup *mem = mem_cgroup_from_cont(cgrp); + bool use_sys = !__mem_cgroup_has_dirty_limit(mem); + + switch (cft->private) { + case MEM_CGROUP_DIRTY_RATIO: + return use_sys ? vm_dirty_ratio : mem->dirty_param.dirty_ratio; + case MEM_CGROUP_DIRTY_LIMIT_IN_BYTES: + return use_sys ? vm_dirty_bytes : mem->dirty_param.dirty_bytes; + case MEM_CGROUP_DIRTY_BACKGROUND_RATIO: + return use_sys ? dirty_background_ratio : + mem->dirty_param.dirty_background_ratio; + case MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES: + return use_sys ? dirty_background_bytes : + mem->dirty_param.dirty_background_bytes; + default: + BUG(); + } +} + +static int +mem_cgroup_dirty_write_string(struct cgroup *cgrp, struct cftype *cft, + const char *buffer) +{ + struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp); + int type = cft->private; + int ret = -EINVAL; + unsigned long long val; + + if (!__mem_cgroup_has_dirty_limit(memcg)) + return ret; + + switch (type) { + case MEM_CGROUP_DIRTY_LIMIT_IN_BYTES: + /* This function does all necessary parse...reuse it */ + ret = res_counter_memparse_write_strategy(buffer, &val); + if (ret) + break; + memcg->dirty_param.dirty_bytes = val; + memcg->dirty_param.dirty_ratio = 0; + break; + case MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES: + ret = res_counter_memparse_write_strategy(buffer, &val); + if (ret) + break; + memcg->dirty_param.dirty_background_bytes = val; + memcg->dirty_param.dirty_background_ratio = 0; + break; + default: + BUG(); + break; + } + return ret; +} + +static int +mem_cgroup_dirty_write(struct cgroup *cgrp, struct cftype *cft, u64 val) +{ + struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp); + int type = cft->private; + + if (!__mem_cgroup_has_dirty_limit(memcg)) + return -EINVAL; + if ((type == MEM_CGROUP_DIRTY_RATIO || + type == MEM_CGROUP_DIRTY_BACKGROUND_RATIO) && val > 100) + return -EINVAL; + switch (type) { + case MEM_CGROUP_DIRTY_RATIO: + memcg->dirty_param.dirty_ratio = val; + memcg->dirty_param.dirty_bytes = 0; + break; + case MEM_CGROUP_DIRTY_BACKGROUND_RATIO: + memcg->dirty_param.dirty_background_ratio = val; + memcg->dirty_param.dirty_background_bytes = 0; + break; + default: + BUG(); + break; + } + return 0; +} + static struct cftype mem_cgroup_files[] = { { .name = "usage_in_bytes", @@ -4581,6 +4671,30 @@ static struct cftype mem_cgroup_files[] = { .unregister_event = mem_cgroup_oom_unregister_event, .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL), }, + { + .name = "dirty_ratio", + .read_u64 = mem_cgroup_dirty_read, + .write_u64 = mem_cgroup_dirty_write, + .private = MEM_CGROUP_DIRTY_RATIO, + }, + { + .name = "dirty_limit_in_bytes", + .read_u64 = mem_cgroup_dirty_read, + .write_string = mem_cgroup_dirty_write_string, + .private = MEM_CGROUP_DIRTY_LIMIT_IN_BYTES, + }, + { + .name = "dirty_background_ratio", + .read_u64 = mem_cgroup_dirty_read, + .write_u64 = mem_cgroup_dirty_write, + .private = MEM_CGROUP_DIRTY_BACKGROUND_RATIO, + }, + { + .name = "dirty_background_limit_in_bytes", + .read_u64 = mem_cgroup_dirty_read, + .write_string = mem_cgroup_dirty_write_string, + .private = MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES, + }, }; #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP -- 1.7.3.1 -- 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=mailto:"dont@kvack.org"> email@kvack.org </a>
WARNING: multiple messages have this Message-ID (diff)
From: Greg Thelen <gthelen@google.com> To: Andrew Morton <akpm@linux-foundation.org> Cc: linux-kernel@vger.kernel.org, linux-mm@kvack.org, containers@lists.osdl.org, Andrea Righi <arighi@develer.com>, Balbir Singh <balbir@linux.vnet.ibm.com>, KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>, Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>, Minchan Kim <minchan.kim@gmail.com>, Ciju Rajan K <ciju@linux.vnet.ibm.com>, David Rientjes <rientjes@google.com>, Wu Fengguang <fengguang.wu@intel.com>, Chad Talbott <ctalbott@google.com>, Justin TerAvest <teravest@google.com>, Vivek Goyal <vgoyal@redhat.com>, Greg Thelen <gthelen@google.com> Subject: [PATCH v5 8/9] memcg: add cgroupfs interface to memcg dirty limits Date: Fri, 25 Feb 2011 13:35:59 -0800 [thread overview] Message-ID: <1298669760-26344-9-git-send-email-gthelen@google.com> (raw) In-Reply-To: <1298669760-26344-1-git-send-email-gthelen@google.com> Add cgroupfs interface to memcg dirty page limits: Direct write-out is controlled with: - memory.dirty_ratio - memory.dirty_limit_in_bytes Background write-out is controlled with: - memory.dirty_background_ratio - memory.dirty_background_limit_bytes Other memcg cgroupfs files support 'M', 'm', 'k', 'K', 'g' and 'G' suffixes for byte counts. This patch provides the same functionality for memory.dirty_limit_in_bytes and memory.dirty_background_limit_bytes. Signed-off-by: Andrea Righi <arighi@develer.com> Signed-off-by: Balbir Singh <balbir@linux.vnet.ibm.com> Signed-off-by: Greg Thelen <gthelen@google.com> Acked-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com> --- Changelog since v3: - Make use of new routine, __mem_cgroup_has_dirty_limit(), to disable memcg dirty limits when use_hierarchy=1. Changelog since v1: - Renamed newly created proc files: - memory.dirty_bytes -> memory.dirty_limit_in_bytes - memory.dirty_background_bytes -> memory.dirty_background_limit_in_bytes - Allow [kKmMgG] suffixes for newly created dirty limit value cgroupfs files. mm/memcontrol.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 114 insertions(+), 0 deletions(-) diff --git a/mm/memcontrol.c b/mm/memcontrol.c index bc86329..6c8885b 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -109,6 +109,13 @@ enum mem_cgroup_events_index { MEM_CGROUP_EVENTS_NSTATS, }; +enum { + MEM_CGROUP_DIRTY_RATIO, + MEM_CGROUP_DIRTY_LIMIT_IN_BYTES, + MEM_CGROUP_DIRTY_BACKGROUND_RATIO, + MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES, +}; + struct mem_cgroup_stat_cpu { long count[MEM_CGROUP_STAT_NSTATS]; unsigned long events[MEM_CGROUP_EVENTS_NSTATS]; @@ -4518,6 +4525,89 @@ static int mem_cgroup_oom_control_write(struct cgroup *cgrp, return 0; } +static u64 mem_cgroup_dirty_read(struct cgroup *cgrp, struct cftype *cft) +{ + struct mem_cgroup *mem = mem_cgroup_from_cont(cgrp); + bool use_sys = !__mem_cgroup_has_dirty_limit(mem); + + switch (cft->private) { + case MEM_CGROUP_DIRTY_RATIO: + return use_sys ? vm_dirty_ratio : mem->dirty_param.dirty_ratio; + case MEM_CGROUP_DIRTY_LIMIT_IN_BYTES: + return use_sys ? vm_dirty_bytes : mem->dirty_param.dirty_bytes; + case MEM_CGROUP_DIRTY_BACKGROUND_RATIO: + return use_sys ? dirty_background_ratio : + mem->dirty_param.dirty_background_ratio; + case MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES: + return use_sys ? dirty_background_bytes : + mem->dirty_param.dirty_background_bytes; + default: + BUG(); + } +} + +static int +mem_cgroup_dirty_write_string(struct cgroup *cgrp, struct cftype *cft, + const char *buffer) +{ + struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp); + int type = cft->private; + int ret = -EINVAL; + unsigned long long val; + + if (!__mem_cgroup_has_dirty_limit(memcg)) + return ret; + + switch (type) { + case MEM_CGROUP_DIRTY_LIMIT_IN_BYTES: + /* This function does all necessary parse...reuse it */ + ret = res_counter_memparse_write_strategy(buffer, &val); + if (ret) + break; + memcg->dirty_param.dirty_bytes = val; + memcg->dirty_param.dirty_ratio = 0; + break; + case MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES: + ret = res_counter_memparse_write_strategy(buffer, &val); + if (ret) + break; + memcg->dirty_param.dirty_background_bytes = val; + memcg->dirty_param.dirty_background_ratio = 0; + break; + default: + BUG(); + break; + } + return ret; +} + +static int +mem_cgroup_dirty_write(struct cgroup *cgrp, struct cftype *cft, u64 val) +{ + struct mem_cgroup *memcg = mem_cgroup_from_cont(cgrp); + int type = cft->private; + + if (!__mem_cgroup_has_dirty_limit(memcg)) + return -EINVAL; + if ((type == MEM_CGROUP_DIRTY_RATIO || + type == MEM_CGROUP_DIRTY_BACKGROUND_RATIO) && val > 100) + return -EINVAL; + switch (type) { + case MEM_CGROUP_DIRTY_RATIO: + memcg->dirty_param.dirty_ratio = val; + memcg->dirty_param.dirty_bytes = 0; + break; + case MEM_CGROUP_DIRTY_BACKGROUND_RATIO: + memcg->dirty_param.dirty_background_ratio = val; + memcg->dirty_param.dirty_background_bytes = 0; + break; + default: + BUG(); + break; + } + return 0; +} + static struct cftype mem_cgroup_files[] = { { .name = "usage_in_bytes", @@ -4581,6 +4671,30 @@ static struct cftype mem_cgroup_files[] = { .unregister_event = mem_cgroup_oom_unregister_event, .private = MEMFILE_PRIVATE(_OOM_TYPE, OOM_CONTROL), }, + { + .name = "dirty_ratio", + .read_u64 = mem_cgroup_dirty_read, + .write_u64 = mem_cgroup_dirty_write, + .private = MEM_CGROUP_DIRTY_RATIO, + }, + { + .name = "dirty_limit_in_bytes", + .read_u64 = mem_cgroup_dirty_read, + .write_string = mem_cgroup_dirty_write_string, + .private = MEM_CGROUP_DIRTY_LIMIT_IN_BYTES, + }, + { + .name = "dirty_background_ratio", + .read_u64 = mem_cgroup_dirty_read, + .write_u64 = mem_cgroup_dirty_write, + .private = MEM_CGROUP_DIRTY_BACKGROUND_RATIO, + }, + { + .name = "dirty_background_limit_in_bytes", + .read_u64 = mem_cgroup_dirty_read, + .write_string = mem_cgroup_dirty_write_string, + .private = MEM_CGROUP_DIRTY_BACKGROUND_LIMIT_IN_BYTES, + }, }; #ifdef CONFIG_CGROUP_MEM_RES_CTLR_SWAP -- 1.7.3.1
next prev parent reply other threads:[~2011-02-25 21:35 UTC|newest] Thread overview: 59+ messages / expand[flat|nested] mbox.gz Atom feed top 2011-02-25 21:35 [PATCH v5 0/9] memcg: per cgroup dirty page accounting Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-25 21:35 ` [PATCH v5 1/9] memcg: document cgroup dirty memory interfaces Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-28 2:27 ` KAMEZAWA Hiroyuki 2011-02-28 2:27 ` KAMEZAWA Hiroyuki 2011-03-11 10:19 ` Balbir Singh 2011-03-11 10:19 ` Balbir Singh 2011-02-25 21:35 ` [PATCH v5 2/9] memcg: add page_cgroup flags for dirty page tracking Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-27 15:56 ` Minchan Kim 2011-02-27 15:56 ` Minchan Kim 2011-02-25 21:35 ` [PATCH v5 3/9] writeback: convert variables to unsigned Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-27 16:07 ` Minchan Kim 2011-02-27 16:07 ` Minchan Kim 2011-02-28 23:52 ` Greg Thelen 2011-02-28 23:52 ` Greg Thelen 2011-03-01 4:50 ` Minchan Kim 2011-03-01 4:50 ` Minchan Kim 2011-03-01 4:50 ` Minchan Kim 2011-02-28 2:28 ` KAMEZAWA Hiroyuki 2011-02-28 2:28 ` KAMEZAWA Hiroyuki 2011-02-25 21:35 ` [PATCH v5 4/9] writeback: create dirty_info structure Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-27 16:38 ` Minchan Kim 2011-02-27 16:38 ` Minchan Kim 2011-03-01 21:13 ` Greg Thelen 2011-03-01 21:13 ` Greg Thelen 2011-02-25 21:35 ` [PATCH v5 5/9] memcg: add dirty page accounting infrastructure Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-27 16:47 ` Minchan Kim 2011-02-27 16:47 ` Minchan Kim 2011-02-28 2:34 ` KAMEZAWA Hiroyuki 2011-02-28 2:34 ` KAMEZAWA Hiroyuki 2011-02-25 21:35 ` [PATCH v5 6/9] memcg: add kernel calls for memcg dirty page stats Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-27 17:01 ` Minchan Kim 2011-02-27 17:01 ` Minchan Kim 2011-02-28 2:40 ` KAMEZAWA Hiroyuki 2011-02-28 2:40 ` KAMEZAWA Hiroyuki 2011-03-10 16:18 ` Greg Thelen 2011-03-10 16:18 ` Greg Thelen 2011-02-25 21:35 ` [PATCH v5 7/9] memcg: add dirty limits to mem_cgroup Greg Thelen 2011-02-25 21:35 ` Greg Thelen 2011-02-28 2:46 ` KAMEZAWA Hiroyuki 2011-02-28 2:46 ` KAMEZAWA Hiroyuki 2011-02-25 21:35 ` Greg Thelen [this message] 2011-02-25 21:35 ` [PATCH v5 8/9] memcg: add cgroupfs interface to memcg dirty limits Greg Thelen 2011-02-25 21:36 ` [PATCH v5 9/9] memcg: check memcg dirty limits in page writeback Greg Thelen 2011-02-25 21:36 ` Greg Thelen 2011-03-01 4:44 ` Minchan Kim 2011-03-01 4:44 ` Minchan Kim 2011-03-02 23:17 ` Vivek Goyal 2011-03-02 23:17 ` Vivek Goyal 2011-03-04 0:30 ` Greg Thelen 2011-03-04 0:30 ` Greg Thelen 2011-02-26 4:16 ` [PATCH v5 0/9] memcg: per cgroup dirty page accounting Greg Thelen 2011-02-26 4:16 ` Greg Thelen
Reply instructions: You may reply publicly to this message via plain-text email using any one of the following methods: * Save the following mbox file, import it into your mail client, and reply-to-all from there: mbox Avoid top-posting and favor interleaved quoting: https://en.wikipedia.org/wiki/Posting_style#Interleaved_style * Reply using the --to, --cc, and --in-reply-to switches of git-send-email(1): git send-email \ --in-reply-to=1298669760-26344-9-git-send-email-gthelen@google.com \ --to=gthelen@google.com \ --cc=akpm@linux-foundation.org \ --cc=arighi@develer.com \ --cc=balbir@linux.vnet.ibm.com \ --cc=ciju@linux.vnet.ibm.com \ --cc=containers@lists.osdl.org \ --cc=ctalbott@google.com \ --cc=fengguang.wu@intel.com \ --cc=kamezawa.hiroyu@jp.fujitsu.com \ --cc=linux-kernel@vger.kernel.org \ --cc=linux-mm@kvack.org \ --cc=minchan.kim@gmail.com \ --cc=nishimura@mxp.nes.nec.co.jp \ --cc=rientjes@google.com \ --cc=teravest@google.com \ --cc=vgoyal@redhat.com \ /path/to/YOUR_REPLY https://kernel.org/pub/software/scm/git/docs/git-send-email.html * If your mail client supports setting the In-Reply-To header via mailto: links, try the mailto: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.