[PATCH][memcg+dirtylimit] Fix overwriting global vm dirty limit setting by memcg (Re: [PATCH v3 00/11] memcg: per cgroup dirty page accounting

KAMEZAWA Hiroyuki
2010-10-20T03:27:23Z

One bug fix here.
==
From: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>

Now, at calculating dirty limit, vm_dirty_param() is called.
This function returns dirty-limit related parameters considering
memory cgroup settings.

Now, assume that vm_dirty_bytes=100M (global dirty limit) and
memory cgroup has 1G of pages and 40 dirty_ratio, dirtyable memory is
500MB.

In this case, global_dirty_limits will consider dirty_limt as
500 *0.4 = 200MB. This is bad...memory cgroup is not back door.

This patch limits the return value of vm_dirty_param() considring
global settings.

Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
---
include/linux/memcontrol.h | 4 ++--
mm/memcontrol.c | 29 ++++++++++++++++++++++++++++-
mm/page-writeback.c | 2 +-
3 files changed, 31 insertions(+), 4 deletions(-)

Index: dirty_limit_new/mm/memcontrol.c
===================================================================
--- dirty_limit_new.orig/mm/memcontrol.c
+++ dirty_limit_new/mm/memcontrol.c
@@ -1171,9 +1171,10 @@ static void __mem_cgroup_dirty_param(str
* can be moved after our access and writeback tends to take long time. At
* least, "memcg" will not be freed while holding rcu_read_lock().
*/
-void vm_dirty_param(struct vm_dirty_param *param)
+void vm_dirty_param(struct vm_dirty_param *param, unsigned long mem)
{
struct mem_cgroup *memcg;
+ u64 limit, bglimit;

if (mem_cgroup_disabled()) {
global_vm_dirty_param(param);
@@ -1183,6 +1184,32 @@ void vm_dirty_param(struct vm_dirty_para
rcu_read_lock();
memcg = mem_cgroup_from_task(current);
__mem_cgroup_dirty_param(param, memcg);
+ /*
+ * A limitation under memory cgroup is under global vm, too.
+ */
+ if (vm_dirty_ratio)
+ limit = mem * vm_dirty_ratio / 100;
+ else
+ limit = vm_dirty_bytes;
+ if (param->dirty_ratio) {
+ param->dirty_bytes = mem * param->dirty_ratio / 100;
+ param->dirty_ratio = 0;
+ }
+ if (param->dirty_bytes > limit)
+ param->dirty_bytes = limit;
+
+ if (dirty_background_ratio)
+ bglimit = mem * dirty_background_ratio / 100;
+ else
+ bglimit = dirty_background_bytes;
+
+ if (param->dirty_background_ratio) {
+ param->dirty_background_bytes =
+ mem * param->dirty_background_ratio /100;
+ param->dirty_background_ratio = 0;
+ }
+ if (param->dirty_background_bytes > bglimit)
+ param->dirty_background_bytes = bglimit;
rcu_read_unlock();
}

Index: dirty_limit_new/include/linux/memcontrol.h
===================================================================
--- dirty_limit_new.orig/include/linux/memcontrol.h
+++ dirty_limit_new/include/linux/memcontrol.h
@@ -171,7 +171,7 @@ static inline void mem_cgroup_dec_page_s
}

bool mem_cgroup_has_dirty_limit(void);
-void vm_dirty_param(struct vm_dirty_param *param);
+void vm_dirty_param(struct vm_dirty_param *param, u64 mem);
s64 mem_cgroup_page_stat(enum mem_cgroup_nr_pages_item item);

unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
@@ -360,7 +360,7 @@ static inline bool mem_cgroup_has_dirty_
return false;
}

-static inline void vm_dirty_param(struct vm_dirty_param *param)
+static inline void vm_dirty_param(struct vm_dirty_param *param, u64 mem)
{
global_vm_dirty_param(param);
}
Index: dirty_limit_new/mm/page-writeback.c
===================================================================
--- dirty_limit_new.orig/mm/page-writeback.c
+++ dirty_limit_new/mm/page-writeback.c
@@ -466,7 +466,7 @@ void global_dirty_limits(unsigned long *
struct task_struct *tsk;
struct vm_dirty_param dirty_param;

- vm_dirty_param(&dirty_param);
+ vm_dirty_param(&dirty_param, avialable_memory);

if (dirty_param.dirty_bytes)
dirty = DIV_ROUND_UP(dirty_param.dirty_bytes, PAGE_SIZE);