Memory controller introduction
Subsystems (14)
cover Memory controller introduction
Resending with the patch numbering fixed and linux-mm copied
This patchset implements another version of the memory controller. These patches have been through a big churn, the first set of patches were posted last year and earlier this year at
http://lkml.org/lkml/2007/2/19/10
Ever since, the RSS controller has been through four revisions, the latest one being
http://lwn.net/Articles/236817/
This patchset draws from the patches listed above and from some of the contents of the patches posted by Vaidyanathan for page cache control.
http://lkml.org/lkml/2007/6/20/92
Pavel, Vaidy could you look at the patches and add your signed off by where relevant?
At OLS, the resource management BOF, it was discussed that we need to manage RSS and unmapped page cache together. This patchset is a step towards that
TODO's
1. Add memory controller water mark support. Reclaim on high water mark
2. Add support for shrinking on limit change
3. Add per zone per container LRU lists
4. Make page_referenced() container aware
5. Figure out a better CLUI for the controller
In case you have been using/testing the RSS controller, you'll find that this controller works slower than the RSS controller. The reason being that both swap cache and page cache is accounted for, so pages do go out to swap upon reclaim (they cannot live in the swap cache).
I've test compiled the framework without the controller enabled, tested the code on UML and minimally on a power box.
Any test output, feedback, comments, suggestions are welcome!
series
res_counters_infra.patch
mem-control-setup.patch
mem-control-accounting-setup.patch
mem-control-accounting.patch
mem-control-task-migration.patch
mem-control-lru-and-reclaim.patch
mem-control-out-of-memory.patch
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 1/7 Memory controller resource counters
Introduce generic structures and routines for resource accounting.
Each resource accounting container is supposed to aggregate it, container_subsystem_state and its resource-specific members within.
---
include/linux/res_counter.h | 102 +++++++++++++++++++++++++++++++++++++ init/Kconfig | 4 + kernel/Makefile | 1 kernel/res_counter.c | 121 ++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 228 insertions(+)
include/linux/res_counter.h new file +102 -0
@@ -0,0 +1,102 @@ +#ifndef __RES_COUNTER_H__ +#define __RES_COUNTER_H__ + +/* +* resource counters +* contain common data types and routines for resource accounting +* +* Copyright 2007 OpenVZ SWsoft Inc +* +* Author: Pavel Emelianov <[email protected]> +* +*/ + +#include <linux/container.h> + +/* +* the core object. the container that wishes to account for some +* resource may include this counter into its structures and use +* the helpers described beyond +*/ + +struct res_counter { +/* +* the current resource consumption level +*/ +unsigned long usage; +/* +* the limit that usage cannot exceed +*/ +unsigned long limit; +/* +* the number of insuccessful attempts to consume the resource +*/ +unsigned long failcnt; +/* +* the lock to protect all of the above. +* the routines below consider this to be IRQ-safe +*/ +spinlock_t lock; +}; + +/* +* helpers to interact with userspace +* res_counter_read/_write - put/get the specified fields from the +* res_counter struct to/from the user +* +* @cnt: the counter in question +* @member: the field to work with (see RES_xxx below) +* @buf: the buffer to opeate on,... +* @nbytes: its size... +* @pos: and the offset. +*/ + +ssize_t res_counter_read (struct res_counter *cnt,int member, +const char __user *buf,size_t nbytes,loff_t *pos); +ssize_t res_counter_write (struct res_counter *cnt,int member, +const char __user *buf,size_t nbytes,loff_t *pos); + +/* +* the field descriptors. one for each member of res_counter +*/ + +enum { +RES_USAGE , +RES_LIMIT , +RES_FAILCNT , +}; + +/* +* helpers for accounting +*/ + +void res_counter_init (struct res_counter *cnt); + +/* +* charge - try to consume more resource. +* +* @cnt: the counter +* @val: the amount of the resource. each controller defines its own +* units, e.g. numbers, bytes, Kbytes, etc +* +* returns 0 on success and <0 if the cnt->usage will exceed the cnt->limit +* _locked call expects the cnt->lock to be taken +*/ + +int res_counter_charge_locked (struct res_counter *cnt,unsigned long val); +int res_counter_charge (struct res_counter *cnt,unsigned long val); + +/* +* uncharge - tell that some portion of the resource is released +* +* @cnt: the counter +* @val: the amount of the resource +* +* these calls check for usage underflow and show a warning on the console +* _locked call expects the cnt->lock to be taken +*/ + +void res_counter_uncharge_locked (struct res_counter *cnt,unsigned long val); +void res_counter_uncharge (struct res_counter *cnt,unsigned long val); + +#endif
init/Kconfig renamed from init/Kconfig~res_counters_infra +4 -0
@@ -320,6 +320,10 @@ config CPUSETS Say N if unsure. +config RESOURCE_COUNTERS + bool + select CONTAINERS + config SYSFS_DEPRECATED bool "Create deprecated sysfs files" default y
kernel/Makefile renamed from kernel/Makefile~res_counters_infra +1 -0
@@ -58,6 +58,7 @@ obj-$(CONFIG_RELAY) += relay.o obj-$(CONFIG_SYSCTL) += utsname_sysctl.o obj-$(CONFIG_TASK_DELAY_ACCT) += delayacct.o obj-$(CONFIG_TASKSTATS) += taskstats.o tsacct.o +obj-$(CONFIG_RESOURCE_COUNTERS) += res_counter.o ifneq ($(CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER),y) # According to Alan Modra <[email protected]>, the -fno-omit-frame-pointer is
kernel/res_counter.c new file +121 -0
121 lines not on this page · raw message
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 2/7 Memory controller containers setup
In reply to Balbir SinghSetup the memory container and add basic hooks and controls to integrate and work with the container.
---
include/linux/container_subsys.h | 6 + include/linux/memcontrol.h | 19 +++++ init/Kconfig | 8 ++ mm/Makefile | 1 mm/memcontrol.c | 141 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 175 insertions(+)
include/linux/container_subsys.h renamed from include/linux/container_subsys.h~mem-control-setup +6 -0
@@ -30,3 +30,9 @@ SUBSYS(ns)#endif /* */ + +#ifdef CONFIG_CONTAINER_MEM_CONT +SUBSYS(mem_container) +#endif + +/* */
init/Kconfig renamed from init/Kconfig~mem-control-setup +8 -0
@@ -360,6 +360,14 @@ config CONTAINER_NS for instance virtual servers and checkpoint/restart jobs. +config CONTAINER_MEM_CONT + bool "Memory controller for containers" + select CONTAINERS + select RESOURCE_COUNTERS + help + Provides a memory controller that manages both page cache and + RSS memory. + config PROC_PID_CPUSET bool "Include legacy /proc/<pid>/cpuset file" depends on CPUSETS
mm/Makefile renamed from mm/Makefile~mem-control-setup +1 -0
@@ -30,4 +30,5 @@ obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_SMP) += allocpercpu.o obj-$(CONFIG_QUICKLIST) += quicklist.o +obj-$(CONFIG_CONTAINER_MEM_CONT) += memcontrol.o
mm/memcontrol.c new file +141 -0
141 lines not on this page · raw message
include/linux/memcontrol.h new file +19 -0
@@ -0,0 +1,19 @@ +/* memcontrol.h - Memory Controller +* +* Copyright IBM Corporation, 2007 +* Author Balbir Singh <[email protected]> +* +* This program is free software; you can redistribute it and/or modify it +* under the terms of version 2.1 of the GNU Lesser General Public License +* as published by the Free Software Foundation. +* +* This program is distributed in the hope that it would be useful, but +* WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +*/ + +#ifndef _LINUX_MEMCONTROL_H +#define _LINUX_MEMCONTROL_H + +#endif /* _LINUX_MEMCONTROL_H */ +
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 3/7 Memory controller accounting setup
In reply to Balbir SinghBasic setup routines, the mm_struct has a pointer to the container that it belongs to and the the page has a meta_page associated with it.
---
include/linux/memcontrol.h | 32 ++++++++++++++++++++++++++++++ include/linux/mm_types.h | 4 +++ include/linux/sched.h | 4 +++ kernel/fork.c | 10 ++++++--- mm/memcontrol.c | 47 ++++++++++++++++++++++++++++++++++++++++++--- 5 files changed, 91 insertions(+), 6 deletions(-)
include/linux/memcontrol.h renamed from include/linux/memcontrol.h~mem-control-accounting-setup +32 -0
@@ -15,5 +15,37 @@#ifndef _LINUX_MEMCONTROL_H#define _LINUX_MEMCONTROL_H +struct mem_container ; +struct meta_page ; + +#ifdef CONFIG_CONTAINER_MEM_CONT + +extern void mm_init_container (struct mm_struct *mm,struct task_struct *p); +extern void mm_free_container (struct mm_struct *mm); +extern void page_assign_meta_page (struct page *page,struct meta_page *mp); +extern struct meta_page *page_get_meta_page (struct page *page); + +#else /* CONFIG_CONTAINER_MEM_CONT */ +static inline void mm_init_container (struct mm_struct *mm, +struct task_struct *p) +{ +} + +static inline void mm_free_container (struct mm_struct *mm) +{ +} + +static inline void page_assign_meta_page (struct page *page, +struct meta_page *mp) +{ +} + +static inline struct meta_page *page_get_meta_page (struct page *page) +{ +return NULL ; +} + +#endif /* CONFIG_CONTAINER_MEM_CONT */ +#endif /* _LINUX_MEMCONTROL_H */
include/linux/mm_types.h renamed from include/linux/mm_types.h~mem-control-accounting-setup +4 -0
@@ -5,6 +5,7 @@#include <linux/threads.h> #include <linux/list.h> #include <linux/spinlock.h> +#include <linux/memcontrol.h> struct address_space ;
@@ -83,6 +84,9 @@ struct page {unsigned int gfp_mask;unsigned long trace[8 ];#endif +#ifdef CONFIG_CONTAINER_MEM_CONT +struct meta_page *meta_page; +#endif };#endif /* _LINUX_MM_TYPES_H */
include/linux/sched.h renamed from include/linux/sched.h~mem-control-accounting-setup +4 -0
@@ -87,6 +87,7 @@ struct sched_param {#include <linux/timer.h> #include <linux/hrtimer.h> #include <linux/task_io_accounting.h> +#include <linux/memcontrol.h> #include <asm/processor.h>
@@ -416,6 +417,9 @@ struct mm_struct {/* aio bits */ rwlock_t ioctx_list_lock;struct kioctx *ioctx_list; +#ifdef CONFIG_CONTAINER_MEM_CONT +struct mem_container *mem_container; +#endif };struct sighand_struct {
kernel/fork.c renamed from kernel/fork.c~mem-control-accounting-setup +7 -3
@@ -330,7 +330,7 @@ static inline void mm_free_pgd(struct mm#include <linux/init_task.h> -static struct mm_struct *mm_init (struct mm_struct * mm) +static struct mm_struct *mm_init (struct mm_struct * mm,struct task_struct *p) {atomic_set (&mm->mm_users,1 );atomic_set (&mm->mm_count,1 );
@@ -347,11 +347,14 @@ static struct mm_struct * mm_init(struct mm->ioctx_list =NULL ; mm->free_area_cache =TASK_UNMAPPED_BASE ; mm->cached_hole_size = ~0UL ; +mm_init_container (mm, p);if (likely (!mm_alloc_pgd (mm))) { mm->def_flags =0 ;return mm; } + +mm_free_container (mm);free_mm (mm);return NULL ; }
@@ -366,7 +369,7 @@ struct mm_struct * mm_alloc(void) mm =allocate_mm ();if (mm) {memset (mm,0 ,sizeof (*mm)); - mm =mm_init (mm); + mm =mm_init (mm, current); }return mm; }
@@ -380,6 +383,7 @@ void fastcall __mmdrop(struct mm_struct {BUG_ON (mm == &init_mm);mm_free_pgd (mm); +mm_free_container (mm);destroy_context (mm);free_mm (mm); }
@@ -500,7 +504,7 @@ static struct mm_struct *dup_mm(struct t mm->token_priority =0 ; mm->last_interval =0 ; -if (!mm_init (mm)) +if (!mm_init (mm, tsk)) goto fail_nomem;if (init_new_context (tsk, mm))
mm/memcontrol.c renamed from mm/memcontrol.c~mem-control-accounting-setup +44 -3
80 lines not on this page · raw message
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 4/7 Memory controller memory accounting
In reply to Balbir SinghAdd the accounting hooks. The accounting is carried out for RSS and Page Cache (unmapped) pages. There is now a common limit and accounting for both. The RSS accounting is accounted at page_add_*_rmap() and page_remove_rmap() time. Page cache is accounted at add_to_page_cache(), __delete_from_page_cache(). Swap cache is also accounted for.
Each page's meta_page is protected with a bit in page flags, this makes handling of race conditions involving simultaneous mappings of a page easier. A reference count is kept in the meta_page to deal with cases where a page might be unmapped from the RSS of all tasks, but still lives in the page cache.
---
fs/exec.c | 1 include/linux/memcontrol.h | 11 +++ include/linux/page-flags.h | 3 + mm/filemap.c | 8 ++ mm/memcontrol.c | 132 ++++++++++++++++++++++++++++++++++++++++++++- mm/memory.c | 22 +++++++ mm/migrate.c | 6 ++ mm/page_alloc.c | 3 + mm/rmap.c | 2 mm/swap_state.c | 8 ++ mm/swapfile.c | 40 +++++++------ 11 files changed, 218 insertions(+), 18 deletions(-)
fs/exec.c renamed from fs/exec.c~mem-control-accounting +1 -0
@@ -51,6 +51,7 @@#include <linux/cn_proc.h> #include <linux/audit.h> #include <linux/signalfd.h> +#include <linux/memcontrol.h> #include <asm/uaccess.h> #include <asm/mmu_context.h>
include/linux/memcontrol.h renamed from include/linux/memcontrol.h~mem-control-accounting +11 -0
@@ -24,6 +24,8 @@ extern void mm_init_container(struct mm_extern void mm_free_container (struct mm_struct *mm);extern void page_assign_meta_page (struct page *page,struct meta_page *mp);extern struct meta_page *page_get_meta_page (struct page *page); +extern int mem_container_charge (struct page *page,struct mm_struct *mm); +extern void mem_container_uncharge (struct meta_page *mp);#else /* CONFIG_CONTAINER_MEM_CONT */ static inline void mm_init_container(struct mm_struct *mm,
@@ -45,6 +47,15 @@ static inline struct meta_page *page_getreturn NULL ; } +static inline int mem_container_charge (struct page *page,struct mm_struct *mm) +{ +return 0 ; +} + +static inline void mem_container_uncharge (struct meta_page *mp) +{ +} +#endif /* CONFIG_CONTAINER_MEM_CONT */ #endif /* _LINUX_MEMCONTROL_H */
include/linux/page-flags.h renamed from include/linux/page-flags.h~mem-control-accounting +3 -0
@@ -98,6 +98,9 @@#define PG_checked PG_owner_priv_1/* Used by some filesystems */ #define PG_pinned PG_owner_priv_1/* Xen pinned pagetable */ +#define PG_metapage 21/* Used for checking if a meta_page */ +/* is associated with a page */ +#if (BITS_PER_LONG >32 )/* * 64-bit-only flags build down from bit 31
mm/filemap.c renamed from mm/filemap.c~mem-control-accounting +8 -0
@@ -31,6 +31,7 @@#include <linux/syscalls.h> #include <linux/cpuset.h> #include <linux/hardirq.h> /* for BUG_ON(!in_atomic()) only */ +#include <linux/memcontrol.h> #include "internal.h" /*
@@ -116,6 +117,7 @@ void __remove_from_page_cache(struct pag {struct address_space *mapping = page->mapping; +mem_container_uncharge (page_get_meta_page (page));radix_tree_delete (&mapping->page_tree, page->index); page->mapping =NULL ; mapping->nrpages--;
@@ -442,6 +444,11 @@ int add_to_page_cache(struct page *page,int error =radix_tree_preload (gfp_mask & ~__GFP_HIGHMEM);if (error ==0 ) { + + error =mem_container_charge (page, current->mm); +if (error) + goto out; +write_lock_irq (&mapping->tree_lock); error =radix_tree_insert (&mapping->page_tree, offset, page);if (!error) {
@@ -455,6 +462,7 @@ int add_to_page_cache(struct page *page,write_unlock_irq (&mapping->tree_lock);radix_tree_preload_end (); } +out:return error; }EXPORT_SYMBOL (add_to_page_cache);
mm/memcontrol.c renamed from mm/memcontrol.c~mem-control-accounting +131 -1
162 lines not on this page · raw message
mm/memory.c renamed from mm/memory.c~mem-control-accounting +22 -0
@@ -50,6 +50,7 @@#include <linux/delayacct.h> #include <linux/init.h> #include <linux/writeback.h> +#include <linux/memcontrol.h> #include <asm/pgalloc.h> #include <asm/uaccess.h>
@@ -1226,6 +1227,10 @@ static int insert_page(struct mm_structpte_t *pte;spinlock_t *ptl; + retval =mem_container_charge (page, mm); +if (retval) + goto out; + retval = -EINVAL ;if (PageAnon (page)) goto out;
@@ -1731,6 +1736,9 @@ gotten:cow_user_page (new_page, old_page, address, vma); } +if (mem_container_charge (new_page, mm)) + goto oom; +/* * Re-check the pte - we dropped the lock */
@@ -2188,6 +2196,11 @@ static int do_swap_page(struct mm_struct }delayacct_clear_flag (DELAYACCT_PF_SWAPIN ); +if (mem_container_charge (page, mm)) { + ret =VM_FAULT_OOM ; + goto out; + } +mark_page_accessed (page);lock_page (page);
@@ -2255,6 +2268,7 @@ static int do_anonymous_page(struct mm_spte_t entry;if (write_access) { +/* Allocate our own private page. */ pte_unmap (page_table);
@@ -2264,6 +2278,9 @@ static int do_anonymous_page(struct mm_sif (!page) goto oom; +if (mem_container_charge (page, mm)) + goto oom; + entry =mk_pte (page, vma->vm_page_prot); entry =maybe_mkwrite (pte_mkdirty (entry), vma);
@@ -2397,6 +2414,11 @@ static int __do_fault(struct mm_struct * } +if (mem_container_charge (page, mm)) { + fdata.type =VM_FAULT_OOM ; + goto out; + } + page_table =pte_offset_map_lock (mm, pmd, address, &ptl);/*
mm/migrate.c renamed from mm/migrate.c~mem-control-accounting +6 -0
@@ -28,6 +28,7 @@#include <linux/mempolicy.h> #include <linux/vmalloc.h> #include <linux/security.h> +#include <linux/memcontrol.h> #include "internal.h"
@@ -157,6 +158,11 @@ static void remove_migration_pte(structreturn ; } +if (mem_container_charge (page, mm)) { +pte_unmap (ptep); +return ; + } + ptl =pte_lockptr (mm, pmd);spin_lock (ptl); pte = *ptep;
mm/page_alloc.c renamed from mm/page_alloc.c~mem-control-accounting +3 -0
@@ -41,6 +41,7 @@#include <linux/pfn.h> #include <linux/backing-dev.h> #include <linux/fault-inject.h> +#include <linux/memcontrol.h> #include <asm/tlbflush.h> #include <asm/div64.h>
@@ -1015,6 +1016,7 @@ static void fastcall free_hot_cold_page(if (!PageHighMem (page))debug_check_no_locks_freed (page_address (page),PAGE_SIZE ); +page_assign_meta_page (page,NULL );arch_free_page (page,0 );kernel_map_pages (page,1 ,0 );
@@ -2576,6 +2578,7 @@ void __meminit memmap_init_zone(unsignedset_page_links (page, zone, nid, pfn);init_page_count (page);reset_page_mapcount (page); +page_assign_meta_page (page,NULL );SetPageReserved (page);/*
mm/rmap.c renamed from mm/rmap.c~mem-control-accounting +2 -0
@@ -643,6 +643,8 @@ void page_remove_rmap(struct page *page,page_clear_dirty (page);set_page_dirty (page); } + +mem_container_uncharge (page_get_meta_page (page));__dec_zone_page_state (page,PageAnon (page) ?NR_ANON_PAGES :NR_FILE_MAPPED ); }
mm/swapfile.c renamed from mm/swapfile.c~mem-control-accounting +23 -17
@@ -506,9 +506,12 @@ unsigned int count_swap_pages(int type,* just let do_wp_page work it out if a write is requested later - to * force COW, vm_page_prot omits write permission from any private vma. */ -static void unuse_pte (struct vm_area_struct *vma,pte_t *pte, +static int unuse_pte (struct vm_area_struct *vma,pte_t *pte,unsigned long addr,swp_entry_t entry,struct page *page) { +if (mem_container_charge (page, vma->vm_mm)) +return -ENOMEM ; +inc_mm_counter (vma->vm_mm, anon_rss);get_page (page); set_pte_at(vma->vm_mm, addr, pte,
@@ -520,6 +523,7 @@ static void unuse_pte(struct vm_area_str* immediately swapped out again after swapon. */ activate_page (page); +return 1 ; } static int unuse_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
@@ -529,7 +533,7 @@ static int unuse_pte_range(struct vm_arepte_t swp_pte =swp_entry_to_pte (entry);pte_t *pte;spinlock_t *ptl; -int found =0 ; +int ret =0 ; pte =pte_offset_map_lock (vma->vm_mm, pmd, addr, &ptl); do {
@@ -538,13 +542,12 @@ static int unuse_pte_range(struct vm_are* Test inline before going to call unuse_pte. */ if (unlikely (pte_same (*pte, swp_pte))) { -unuse_pte (vma, pte++, addr, entry, page); - found =1 ; + ret =unuse_pte (vma, pte++, addr, entry, page);break ; } }while (pte++, addr +=PAGE_SIZE , addr != end);pte_unmap_unlock (pte -1 , ptl); -return found; +return ret; } static inline int unuse_pmd_range(struct vm_area_struct *vma, pud_t *pud,
@@ -553,14 +556,16 @@ static inline int unuse_pmd_range(struct {pmd_t *pmd;unsigned long next; +int ret; pmd =pmd_offset (pud, addr);do { next =pmd_addr_end (addr, end);if (pmd_none_or_clear_bad (pmd))continue ; -if (unuse_pte_range (vma, pmd, addr, next, entry, page)) -return 1 ; + ret =unuse_pte_range (vma, pmd, addr, next, entry, page); +if (ret) +return ret; }while (pmd++, addr = next, addr != end);return 0 ; }
@@ -571,14 +576,16 @@ static inline int unuse_pud_range(struct {pud_t *pud;unsigned long next; +int ret; pud =pud_offset (pgd, addr);do { next =pud_addr_end (addr, end);if (pud_none_or_clear_bad (pud))continue ; -if (unuse_pmd_range (vma, pud, addr, next, entry, page)) -return 1 ; + ret =unuse_pmd_range (vma, pud, addr, next, entry, page); +if (ret) +return ret; }while (pud++, addr = next, addr != end);return 0 ; }
@@ -588,6 +595,7 @@ static int unuse_vma(struct vm_area_stru {pgd_t *pgd;unsigned long addr, end, next; +int ret;if (page->mapping) { addr =page_address_in_vma (page, vma);
@@ -605,8 +613,9 @@ static int unuse_vma(struct vm_area_stru next =pgd_addr_end (addr, end);if (pgd_none_or_clear_bad (pgd))continue ; -if (unuse_pud_range (vma, pgd, addr, next, entry, page)) -return 1 ; + ret =unuse_pud_range (vma, pgd, addr, next, entry, page); +if (ret) +return ret; }while (pgd++, addr = next, addr != end);return 0 ; }
@@ -615,6 +624,7 @@ static int unuse_mm(struct mm_struct *mm swp_entry_t entry, struct page *page) { struct vm_area_struct *vma; +int ret =0 ;if (!down_read_trylock (&mm->mmap_sem)) {/*
@@ -627,15 +637,11 @@ static int unuse_mm(struct mm_struct *mmlock_page (page); }for (vma = mm->mmap; vma; vma = vma->vm_next) { -if (vma->anon_vma &&unuse_vma (vma, entry, page)) +if (vma->anon_vma && (ret =unuse_vma (vma, entry, page)))break ; }up_read (&mm->mmap_sem); -/* -* Currently unuse_mm cannot fail, but leave error handling -* at call sites for now, since we change it from time to time. -*/ -return 0 ; +return ret; }/*
mm/swap_state.c renamed from mm/swap_state.c~mem-control-accounting +8 -0
@@ -17,6 +17,7 @@#include <linux/backing-dev.h> #include <linux/pagevec.h> #include <linux/migrate.h> +#include <linux/memcontrol.h> #include <asm/pgtable.h>
@@ -79,6 +80,11 @@ static int __add_to_swap_cache(struct paBUG_ON (PagePrivate (page)); error =radix_tree_preload (gfp_mask);if (!error) { + + error =mem_container_charge (page, current->mm); +if (error) + goto out; +write_lock_irq (&swapper_space.tree_lock); error =radix_tree_insert (&swapper_space.page_tree, entry.val, page);
@@ -93,6 +99,7 @@ static int __add_to_swap_cache(struct pawrite_unlock_irq (&swapper_space.tree_lock);radix_tree_preload_end (); } +out:return error; }
@@ -129,6 +136,7 @@ void __delete_from_swap_cache(struct pagBUG_ON (PageWriteback (page));BUG_ON (PagePrivate (page)); +mem_container_uncharge (page->meta_page);radix_tree_delete (&swapper_space.page_tree,page_private (page));set_page_private (page,0 );ClearPageSwapCache (page);
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Re: [-mm PATCH 4/7] Memory controller memory accounting
Quoted 28 lines · Balbir Singh
Add the accounting hooks. The accounting is carried out for RSS and Page Cache (unmapped) pages. There is now a common limit and accounting for both. The RSS accounting is accounted at page_add_*_rmap() and
page_remove_rmap()time. Page cache is accounted atadd_to_page_cache(),__delete_from_page_cache(). Swap cache is also accounted for.Each page's
meta_pageis protected with a bit in page flags, this makes handling of race conditions involving simultaneous mappings of a page easier. A reference count is kept in themeta_pageto deal with cases where a page might be unmapped from the RSS of all tasks, but still lives in the page cache.Signed-off-by Balbir Singh <[email protected]>---
fs/exec.c | 1 include/linux/memcontrol.h | 11 +++ include/linux/page-flags.h | 3 + mm/filemap.c | 8 ++ mm/memcontrol.c | 132 ++++++++++++++++++++++++++++++++++++++++++++- mm/memory.c | 22 +++++++ mm/migrate.c | 6 ++ mm/page_alloc.c | 3 + mm/rmap.c | 2 mm/swap_state.c | 8 ++ mm/swapfile.c | 40 +++++++------ 11 files changed, 218 insertions(+), 18 deletions(-)
[snip]
Quoted 12 lines
diff -puN
mm/migrate.c~mem-control-accountingmm/migrate.cmm/migrate.c renamed from mm/migrate.c~mem-control-accounting +1
-0@@ -28,6 +28,7 @@#include <linux/mempolicy.h> #include <linux/vmalloc.h> #include <linux/security.h> +#include <linux/memcontrol.h> #include "internal.h"
mm/migrate.c static void remove_migration_pte(struct · line 161
Quoted 4 lines
mm/migrate.c renamed from mm/migrate.c~mem-control-accounting +1
-0@@ -157,6 +158,11 @@ static void remove_migration_pte(structreturn ; } +if (mem_container_charge (page, mm)) {
Minor correction. The above line should be
if (mem_container_charge(new, mm)) {
to avoid compilation error.
--Vaidy
[snip]
Re: [-mm PATCH 4/7] Memory controller memory accounting
Quoted 5 lines · Vaidyanathan Srinivasan
Review
Quoted 2 lines
(quoted diff) +1
-0+ if (mem_container_charge(page, mm)) {Minor correction. The above line should be
Quoted 7 lines
if (
mem_container_charge(new, mm)) {to avoid compilation error.
--Vaidy
[snip]
Thanks, Vaidy,
Patch incorporated.
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 5/7 Memory controller task migration
In reply to Balbir SinghAllow tasks to migrate from one container to the other. We migrate mm_struct's mem_container only when the thread group id migrates.
---
mm/memcontrol.c | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)
mm/memcontrol.c renamed from mm/memcontrol.c~mem-control-task-migration +35 -0
@@ -302,11 +302,46 @@ err:return rc; } +static void mem_container_move_task (struct container_subsys *ss, +struct container *cont, +struct container *old_cont, +struct task_struct *p) +{ +struct mm_struct *mm; +struct mem_container *mem, *old_mem; + + mm =get_task_mm (p); +if (mm ==NULL ) +return ; + + mem =mem_container_from_cont (cont); + old_mem =mem_container_from_cont (old_cont); + +if (mem == old_mem) + goto out; + +/* +* Only thread group leaders are allowed to migrate, the mm_struct is +* in effect owned by the leader +*/ +if (p->tgid != p->pid) + goto out; + +css_get (&mem->css); +rcu_assign_pointer (mm->mem_container, mem); +css_put (&old_mem->css); + +out: +mmput (mm); +return ; +} +struct container_subsys mem_container_subsys = { .name ="mem_container" , .subsys_id = mem_container_subsys_id, .create = mem_container_create, .destroy = mem_container_destroy, .populate = mem_container_populate, + .attach = mem_container_move_task, .early_init =1 , };
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 6/7 Memory controller add per container LRU and reclaim
In reply to Balbir SinghAdd the meta_page to the per container LRU. The reclaim algorithm has been modified to make the isolate_lru_pages() as a pluggable component. The scan_control data structure now accepts the container on behalf of which reclaims are carried out. try_to_free_pages() has been extended to become container aware.
---
include/linux/memcontrol.h | 11 +++ include/linux/res_counter.h | 23 +++++++ include/linux/swap.h | 3 + mm/memcontrol.c | 88 +++++++++++++++++++++++++++++- mm/swap.c | 2 mm/vmscan.c | 129 +++++++++++++++++++++++++++++++++++--------- 6 files changed, 230 insertions(+), 26 deletions(-)
include/linux/memcontrol.h renamed from include/linux/memcontrol.h~mem-control-lru-and-reclaim +11 -0
@@ -26,6 +26,13 @@ extern void page_assign_meta_page(structextern struct meta_page *page_get_meta_page (struct page *page);extern int mem_container_charge (struct page *page,struct mm_struct *mm);extern void mem_container_uncharge (struct meta_page *mp); +extern void mem_container_move_lists (struct meta_page *mp,bool active); +extern unsigned long mem_container_isolate_pages (unsigned long nr_to_scan, +struct list_head *dst, +unsigned long *scanned,int order, +int mode,struct zone *z, +struct mem_container *mem_cont, +int active);#else /* CONFIG_CONTAINER_MEM_CONT */ static inline void mm_init_container(struct mm_struct *mm,
@@ -56,6 +63,10 @@ static inline void mem_container_uncharg { } +static inline void mem_container_move_lists (struct meta_page *mp,bool active) +{ +} +#endif /* CONFIG_CONTAINER_MEM_CONT */ #endif /* _LINUX_MEMCONTROL_H */
include/linux/swap.h renamed from include/linux/swap.h~mem-control-lru-and-reclaim +3 -0
@@ -6,6 +6,7 @@#include <linux/mmzone.h> #include <linux/list.h> #include <linux/sched.h> +#include <linux/memcontrol.h> #include <asm/atomic.h> #include <asm/page.h>
@@ -191,6 +192,8 @@ extern void swap_setup(void);/* linux/mm/vmscan.c */ extern unsigned long try_to_free_pages (struct zone **zones,int order,gfp_t gfp_mask); +extern unsigned long try_to_free_mem_container_pages (struct mem_container *mem); +extern int __isolate_lru_page (struct page *page,int mode);extern unsigned long shrink_all_memory (unsigned long nr_pages);extern int vm_swappiness;extern int remove_mapping (struct address_space *mapping,struct page *page);
mm/memcontrol.c renamed from mm/memcontrol.c~mem-control-lru-and-reclaim +87 -1
125 lines not on this page · raw message
mm/swap.c renamed from mm/swap.c~mem-control-lru-and-reclaim +2 -0
@@ -31,6 +31,7 @@#include <linux/cpu.h> #include <linux/notifier.h> #include <linux/init.h> +#include <linux/memcontrol.h> /* How many pages do we try to swap or page in/out together? */ int page_cluster;
@@ -148,6 +149,7 @@ void fastcall activate_page(struct pageSetPageActive (page);add_page_to_active_list (zone, page);__count_vm_event (PGACTIVATE ); +mem_container_move_lists (page_get_meta_page (page), true); }spin_unlock_irq (&zone->lru_lock); }
mm/vmscan.c renamed from mm/vmscan.c~mem-control-lru-and-reclaim +104 -25
238 lines not on this page · raw message
include/linux/res_counter.h renamed from include/linux/res_counter.h~mem-control-lru-and-reclaim +23 -0
@@ -99,4 +99,27 @@ int res_counter_charge(struct res_countevoid res_counter_uncharge_locked (struct res_counter *cnt,unsigned long val);void res_counter_uncharge (struct res_counter *cnt,unsigned long val); +static inline bool res_counter_limit_check_locked (struct res_counter *cnt) +{ +if (cnt->usage < cnt->limit) +return true; + +return false; +} + +/* +* Helper function to detect if the container is within it's limit or +* not. It's currently called from container_rss_prepare() +*/ +static inline bool res_counter_check_under_limit (struct res_counter *cnt) +{ +bool ret; +unsigned long flags; + +spin_lock_irqsave (&cnt->lock, flags); + ret =res_counter_limit_check_locked (cnt); +spin_unlock_irqrestore (&cnt->lock, flags); +return ret; +} +#endif
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
PATCH 7/7 Memory controller OOM handling
In reply to Balbir SinghOut of memory handling for containers over their limit. A task from the container over limit is chosen using the existing OOM logic and killed.
TODO:
1. As discussed in the OLS BOF session, consider implementing a user space policy for OOM handling.
---
include/linux/memcontrol.h | 1 + mm/memcontrol.c | 1 + mm/oom_kill.c | 42 ++++++++++++++++++++++++++++++++++++++---- 3 files changed, 40 insertions(+), 4 deletions(-)
include/linux/memcontrol.h renamed from include/linux/memcontrol.h~mem-control-out-of-memory +1 -0
@@ -33,6 +33,7 @@ extern unsigned long mem_container_isola int mode, struct zone *z, struct mem_container *mem_cont, int active); +extern void mem_cont_out_of_memory (struct mem_container *mem);#else /* CONFIG_CONTAINER_MEM_CONT */ static inline void mm_init_container(struct mm_struct *mm,
mm/memcontrol.c renamed from mm/memcontrol.c~mem-control-out-of-memory +1 -0
@@ -240,6 +240,7 @@ int mem_container_charge(struct page *paif (res_counter_check_under_limit (&mem->res))continue ; +mem_cont_out_of_memory (mem); goto free_mp; }
mm/oom_kill.c renamed from mm/oom_kill.c~mem-control-out-of-memory +38 -4
84 lines not on this page · raw message
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 9 lines · Balbir Singh
Resending with the patch numbering fixed and linux-mm copied
This patchset implements another version of the memory controller. These patches have been through a big churn, the first set of patches were posted last year and earlier this year at
http://lkml.org/lkml/2007/2/19/10Ever since, the RSS controller has been through four revisions, the latest one being
Quoted 8 lines
http://lwn.net/Articles/236817/This patchset draws from the patches listed above and from some of the contents of the patches posted by Vaidyanathan for page cache control.
http://lkml.org/lkml/2007/6/20/92Pavel, Vaidy could you look at the patches and add your signed off by where relevant?
As far as I remember at OLS we decided to implement per-zone RLU lists and reuse the lru lock as well. This will remove all the problems with per-container lists inconsistency.
Separate limits for RSS and RSS+pagecache are also a must.
BTW, if you send smb. else's patches you may include a 'From: xxx' line into the letter to address the original author.
Quoted 31 lines
At OLS, the resource management BOF, it was discussed that we need to manage RSS and unmapped page cache together. This patchset is a step towards that
TODO's
1. Add memory controller water mark support. Reclaim on high water mark
2. Add support for shrinking on limit change
3. Add per zone per container LRU lists
4. Makepage_referenced()container aware
5. Figure out a better CLUI for the controllerIn case you have been using/testing the RSS controller, you'll find that this controller works slower than the RSS controller. The reason being that both swap cache and page cache is accounted for, so pages do go out to swap upon reclaim (they cannot live in the swap cache).
I've test compiled the framework without the controller enabled, tested the code on UML and minimally on a power box.
Any test output, feedback, comments, suggestions are welcome!
series
res_counters_infra.patch
mem-control-setup.patch
mem-control-accounting-setup.patch
mem-control-accounting.patch
mem-control-task-migration.patch
mem-control-lru-and-reclaim.patch
mem-control-out-of-memory.patch
Hi, Pavel,
Quoted 6 lines · Pavel Emelianov
Balbir Singh wrote:
As far as I remember at OLS we decided to implement per-zone RLU lists and reuse the lru lock as well. This will remove all the problems with per-container lists inconsistency.
It's there in the TODO list. It is easy to implement. I can do that in the next revision. We are re-using the LRU lock, since the isolate_pages callback is called under the zone's LRU lock.
Quoted 2 lines
Separate limits for RSS and RSS+pagecache are also a must.
I remember that we discussed having one limit, but we can come up with a configuration parameter to do it. I'll do that in the next release.
Quoted 3 lines
BTW, if you send smb. else's patches you may include a 'From: xxx' line into the letter to address the original author.
I'll do that for the res_counters_infra patch. Although I had used res_counter, the hooks in mm_struct earlier (http://lkml.org/lkml/2007/2/19/12).
A lot of the code for the reclaim logic and the meta_page is yours. Please do identify patches where you would like to see your signed-off-by and where you think the entire patch is completely yours.
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Peter Zijlstra
maintainerQuoted 1 line · Pavel Emelianov
Separate limits for RSS and RSS+pagecache are also a must.
This I still disagree upon. Page-cache limits are orthogonal to containers and not a requirement for containers. If you want such a feature get it in Linux proper and don't sneak it in the backdoor via containers.
Quoted 8 lines · Peter Zijlstra
Quoted 1 line · Pavel Emelianov
Separate limits for RSS and RSS+pagecache are also a must.
This I still disagree upon. Page-cache limits are orthogonal to containers and not a requirement for containers. If you want such a feature get it in Linux proper and don't sneak it in the backdoor via containers.
What I wanted to say is that *iff* we need limit for booth the RSS and the page cache, then we do need a separate limit for the RSS only. I do not vote for the page cache limit either, but I do not vote _against_ it as well, and agree to take part in its development.
Thanks,
Pavel.
Quoted 11 lines · Peter Zijlstra
Quoted 1 line · Pavel Emelianov
Separate limits for RSS and RSS+pagecache are also a must.
This I still disagree upon. Page-cache limits are orthogonal to containers and not a requirement for containers. If you want such a feature get it in Linux proper and don't sneak it in the backdoor via containers.
Peter,
In these patches, we provide memory control that includes mapped pages and unmapped pages (as discussed in the BOF). All memory is treated uniformly. We will not have separate page cache control, what we can have is control for either mapped pages or control for a combination of mapped and unmapped pages together.
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL