The patch titled memcg: add cgroupfs interface to memcg dirty limits has been removed from the -mm tree. Its filename was memcg-add-cgroupfs-interface-to-memcg-dirty-limits.patch This patch was dropped because an updated version will be merged The current -mm tree may be found at http://userweb.kernel.org/~akpm/mmotm/ ------------------------------------------------------ Subject: memcg: add cgroupfs interface to memcg dirty limits From: Greg Thelen <gthelen@xxxxxxxxxx> 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@xxxxxxxxxxx> Signed-off-by: Balbir Singh <balbir@xxxxxxxxxxxxxxxxxx> Signed-off-by: Greg Thelen <gthelen@xxxxxxxxxx> Acked-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@xxxxxxxxxxxxxx> Cc: Daisuke Nishimura <nishimura@xxxxxxxxxxxxxxxxx> Cc: Minchan Kim <minchan.kim@xxxxxxxxx> Cc: Johannes Weiner <hannes@xxxxxxxxxxx> Cc: David Rientjes <rientjes@xxxxxxxxxx> Cc: Wu Fengguang <fengguang.wu@xxxxxxxxx> Cc: Chad Talbott <ctalbott@xxxxxxxxxx> Cc: Justin TerAvest <teravest@xxxxxxxxxx> Signed-off-by: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx> --- mm/memcontrol.c | 114 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) diff -puN mm/memcontrol.c~memcg-add-cgroupfs-interface-to-memcg-dirty-limits mm/memcontrol.c --- a/mm/memcontrol.c~memcg-add-cgroupfs-interface-to-memcg-dirty-limits +++ a/mm/memcontrol.c @@ -113,6 +113,13 @@ enum mem_cgroup_events_target { #define THRESHOLDS_EVENTS_TARGET (128) #define SOFTLIMIT_EVENTS_TARGET (1024) +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]; @@ -4391,6 +4398,89 @@ static int mem_cgroup_oom_control_write( 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", @@ -4454,6 +4544,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 _ Patches currently in -mm which might be from gthelen@xxxxxxxxxx are origin.patch memcg-add-dirty-limiting-routines.patch memcg-check-memcg-dirty-limits-in-page-writeback.patch memcg-make-background-writeback-memcg-aware.patch -- To unsubscribe from this list: send the line "unsubscribe mm-commits" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html