lkml.org 
[lkml]   [2012]   [Feb]   [27]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH v3 18/21] mm: add to lruvec isolated pages counters
On Thu, 23 Feb 2012 17:53:14 +0400
Konstantin Khlebnikov <khlebnikov@openvz.org> wrote:

> This patch adds into struct lruvec counter of isolated pages.
> It is required for keeping lruvec alive till the isolated page putback.
> We cannot rely on resource counter in memory controller, because it
> does not account uncharged memory. And it much better to have common engine
> for dynamical lruvec management, than to tie all logic with memory cgroup magic.
> Plus this is useful information for memory reclaimer balancing.
>
> There also appears per-cpu page-vectors for putting isolated pages back,
> and function add_page_to_evictable_list(). It is similar to lru_cache_add_lru()
> but it reuse page reference from caller and can adjust isolated pages counters.
> There also new function free_isolated_page_list() which is used at the end of
> shrink_page_list() for freeing pages and adjusting counters of isolated pages.
>
> Memory cgroups code can shuffle pages between lruvecs without isolation
> if page is already isolated with someone else. Thus page lruvec reference is
> unstable even if page is isolated. It is stable only under lru_lock or if page
> reference count is zero. That's why we must always recheck page_lruvec() even
> on non-lumpy 0-order reclaim, where all pages are isolated from one lruvec.
>
> Memory controller at moving pege between cgroups now adjust isolated pages
> counter for old lruvec before inserting page to new lruvec.
> Locking lruvec->lru_lock in mem_cgroup_adjust_isolated() also effectively
> stabilizes PageLRU() sign, so nobody will see PageLRU() under old lru_lock
> while page is already moved into other lruvec.
>
> [ BTW, all lru-id arithmetic can be simplified if we devide unevictable list
> into file and anon parts. After that we can swap bits in page->flags and
> calculate lru-id with single instruction ]
>
> Signed-off-by: Konstantin Khlebnikov <khlebnikov@openvz.org>

Could you split the part showing statistics of isolated pages into another patch ?



> ---
> include/linux/mmzone.h | 11 ++++-
> include/linux/swap.h | 4 +-
> mm/compaction.c | 1
> mm/huge_memory.c | 4 ++
> mm/internal.h | 6 ++
> mm/ksm.c | 2 -
> mm/memcontrol.c | 39 ++++++++++++++--
> mm/migrate.c | 2 -
> mm/rmap.c | 2 -
> mm/swap.c | 76 +++++++++++++++++++++++++++++++
> mm/vmscan.c | 116 +++++++++++++++++++++++++++++++++++-------------
> 11 files changed, 218 insertions(+), 45 deletions(-)
>
> diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
> index 82d5ff3..2e3a298 100644
> --- a/include/linux/mmzone.h
> +++ b/include/linux/mmzone.h
> @@ -137,13 +137,20 @@ enum lru_list {
> LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
> LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
> LRU_UNEVICTABLE,
> - NR_LRU_LISTS
> + NR_EVICTABLE_LRU_LISTS = LRU_UNEVICTABLE,
> + NR_LRU_LISTS,
> + LRU_ISOLATED = NR_LRU_LISTS,
> + LRU_ISOLATED_ANON = LRU_ISOLATED,
> + LRU_ISOLATED_FILE,
> + NR_LRU_COUNTERS,
> };
>
> #define for_each_lru(lru) for (lru = 0; lru < NR_LRU_LISTS; lru++)
>
> #define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)
>
> +#define for_each_lru_counter(cnt) for (cnt = 0; cnt < NR_LRU_COUNTERS; cnt++)
> +
> static inline int is_file_lru(enum lru_list lru)
> {
> return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
> @@ -298,7 +305,7 @@ struct zone_reclaim_stat {
>
> struct lruvec {
> struct list_head pages_lru[NR_LRU_LISTS];
> - unsigned long pages_count[NR_LRU_LISTS];
> + unsigned long pages_count[NR_LRU_COUNTERS];
>
> struct zone_reclaim_stat reclaim_stat;
>
> diff --git a/include/linux/swap.h b/include/linux/swap.h
> index 8630354..3a3ff2c 100644
> --- a/include/linux/swap.h
> +++ b/include/linux/swap.h
> @@ -234,7 +234,9 @@ extern void rotate_reclaimable_page(struct page *page);
> extern void deactivate_page(struct page *page);
> extern void swap_setup(void);
>
> -extern void add_page_to_unevictable_list(struct page *page);
> +extern void add_page_to_unevictable_list(struct page *page, bool isolated);
> +extern void add_page_to_evictable_list(struct page *page,
> + enum lru_list lru, bool isolated);
>
> /**
> * lru_cache_add: add a page to the page lists
> diff --git a/mm/compaction.c b/mm/compaction.c
> index 54340e4..fa74cbe 100644
> --- a/mm/compaction.c
> +++ b/mm/compaction.c
> @@ -384,6 +384,7 @@ static isolate_migrate_t isolate_migratepages(struct zone *zone,
>
> /* Successfully isolated */
> del_page_from_lru_list(lruvec, page, page_lru(page));
> + lruvec->pages_count[LRU_ISOLATED + page_is_file_cache(page)]++;
> list_add(&page->lru, migratelist);
> cc->nr_migratepages++;
> nr_isolated++;
> diff --git a/mm/huge_memory.c b/mm/huge_memory.c
> index 74996b8..46d9f44 100644
> --- a/mm/huge_memory.c
> +++ b/mm/huge_memory.c
> @@ -1316,6 +1316,10 @@ static void __split_huge_page_refcount(struct page *page)
> __dec_zone_page_state(page, NR_ANON_TRANSPARENT_HUGEPAGES);
> __mod_zone_page_state(lruvec_zone(lruvec), NR_ANON_PAGES, HPAGE_PMD_NR);
>
> + /* Fixup isolated pages counter if head page currently isolated */
> + if (!PageLRU(page))
> + lruvec->pages_count[LRU_ISOLATED_ANON] -= HPAGE_PMD_NR-1;
> +
> ClearPageCompound(page);
> compound_unlock(page);
> unlock_lruvec_irq(lruvec);
> diff --git a/mm/internal.h b/mm/internal.h
> index 9454752..6dd2e70 100644
> --- a/mm/internal.h
> +++ b/mm/internal.h
> @@ -265,7 +265,11 @@ extern unsigned long highest_memmap_pfn;
> * in mm/vmscan.c:
> */
> extern int isolate_lru_page(struct page *page);
> -extern void putback_lru_page(struct page *page);
> +extern void __putback_lru_page(struct page *page, bool isolated);
> +static inline void putback_lru_page(struct page *page)
> +{
> + __putback_lru_page(page, true);
> +}
>
> /*
> * in mm/page_alloc.c
> diff --git a/mm/ksm.c b/mm/ksm.c
> index e20de58..109e6ec 100644
> --- a/mm/ksm.c
> +++ b/mm/ksm.c
> @@ -1592,7 +1592,7 @@ struct page *ksm_does_need_to_copy(struct page *page,
> if (page_evictable(new_page, vma))
> lru_cache_add_lru(new_page, LRU_ACTIVE_ANON);
> else
> - add_page_to_unevictable_list(new_page);
> + add_page_to_unevictable_list(new_page, false);
> }
>
> return new_page;
> diff --git a/mm/memcontrol.c b/mm/memcontrol.c
> index 230f434..4de8044 100644
> --- a/mm/memcontrol.c
> +++ b/mm/memcontrol.c
> @@ -697,7 +697,7 @@ mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg, int nid, int zid,
>
> mz = mem_cgroup_zoneinfo(memcg, nid, zid);
>
> - for_each_lru(lru) {
> + for_each_lru_counter(lru) {
> if (BIT(lru) & lru_mask)
> ret += mz->lruvec.pages_count[lru];
> }
> @@ -2354,6 +2354,17 @@ void mem_cgroup_split_huge_fixup(struct page *head)
> }
> #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
>
> +static void mem_cgroup_adjust_isolated(struct lruvec *lruvec,
> + struct page *page, int delta)
> +{
> + int file = page_is_file_cache(page);
> + unsigned long flags;
> +
> + lock_lruvec(lruvec, &flags);
> + lruvec->pages_count[LRU_ISOLATED + file] += delta;
> + unlock_lruvec(lruvec, &flags);
> +}
> +
> /**
> * mem_cgroup_move_account - move account of the page
> * @page: the page
> @@ -2452,6 +2463,7 @@ static int mem_cgroup_move_parent(struct page *page,
> struct mem_cgroup *parent;
> unsigned int nr_pages;
> unsigned long uninitialized_var(flags);
> + struct lruvec *lruvec;
> int ret;
>
> /* Is ROOT ? */
> @@ -2471,6 +2483,8 @@ static int mem_cgroup_move_parent(struct page *page,
> if (ret)
> goto put_back;
>
> + lruvec = page_lruvec(page);
> +
> if (nr_pages > 1)
> flags = compound_lock_irqsave(page);
>
> @@ -2480,8 +2494,11 @@ static int mem_cgroup_move_parent(struct page *page,
>
> if (nr_pages > 1)
> compound_unlock_irqrestore(page, flags);
> + if (!ret)
> + /* This also stabilize PageLRU() sign for lruvec lock holder. */
> + mem_cgroup_adjust_isolated(lruvec, page, -nr_pages);
> put_back:
> - putback_lru_page(page);
> + __putback_lru_page(page, !ret);
> put:
> put_page(page);
> out:
> @@ -3879,6 +3896,8 @@ enum {
> MCS_INACTIVE_FILE,
> MCS_ACTIVE_FILE,
> MCS_UNEVICTABLE,
> + MCS_ISOLATED_ANON,
> + MCS_ISOLATED_FILE,
> NR_MCS_STAT,
> };
>
> @@ -3902,7 +3921,9 @@ struct {
> {"active_anon", "total_active_anon"},
> {"inactive_file", "total_inactive_file"},
> {"active_file", "total_active_file"},
> - {"unevictable", "total_unevictable"}
> + {"unevictable", "total_unevictable"},
> + {"isolated_anon", "total_isolated_anon"},
> + {"isolated_file", "total_isolated_file"},
> };
>
>
> @@ -3942,6 +3963,10 @@ mem_cgroup_get_local_stat(struct mem_cgroup *memcg, struct mcs_total_stat *s)
> s->stat[MCS_ACTIVE_FILE] += val * PAGE_SIZE;
> val = mem_cgroup_nr_lru_pages(memcg, BIT(LRU_UNEVICTABLE));
> s->stat[MCS_UNEVICTABLE] += val * PAGE_SIZE;
> + val = mem_cgroup_nr_lru_pages(memcg, BIT(LRU_ISOLATED_ANON));
> + s->stat[MCS_ISOLATED_ANON] += val * PAGE_SIZE;
> + val = mem_cgroup_nr_lru_pages(memcg, BIT(LRU_ISOLATED_FILE));
> + s->stat[MCS_ISOLATED_FILE] += val * PAGE_SIZE;
> }
>
> static void
> @@ -5243,6 +5268,7 @@ retry:
> struct page *page;
> struct page_cgroup *pc;
> swp_entry_t ent;
> + struct lruvec *lruvec;
>
> if (!mc.precharge)
> break;
> @@ -5253,14 +5279,17 @@ retry:
> page = target.page;
> if (isolate_lru_page(page))
> goto put;
> + lruvec = page_lruvec(page);
> pc = lookup_page_cgroup(page);
> if (!mem_cgroup_move_account(page, 1, pc,
> mc.from, mc.to, false)) {
> mc.precharge--;
> /* we uncharge from mc.from later. */
> mc.moved_charge++;
> - }
> - putback_lru_page(page);
> + mem_cgroup_adjust_isolated(lruvec, page, -1);
> + __putback_lru_page(page, false);
> + } else
> + __putback_lru_page(page, true);
> put: /* is_target_pte_for_mc() gets the page */
> put_page(page);
> break;
> diff --git a/mm/migrate.c b/mm/migrate.c
> index df141f6..de13a0e 100644
> --- a/mm/migrate.c
> +++ b/mm/migrate.c
> @@ -868,7 +868,7 @@ out:
> * Move the new page to the LRU. If migration was not successful
> * then this will free the page.
> */
> - putback_lru_page(newpage);
> + __putback_lru_page(newpage, false);
> if (result) {
> if (rc)
> *result = rc;
> diff --git a/mm/rmap.c b/mm/rmap.c
> index aa547d4..06b5def9 100644
> --- a/mm/rmap.c
> +++ b/mm/rmap.c
> @@ -1139,7 +1139,7 @@ void page_add_new_anon_rmap(struct page *page,
> if (page_evictable(page, vma))
> lru_cache_add_lru(page, LRU_ACTIVE_ANON);
> else
> - add_page_to_unevictable_list(page);
> + add_page_to_unevictable_list(page, false);
> }
>
> /**
> diff --git a/mm/swap.c b/mm/swap.c
> index 3689e3d..998c71c 100644
> --- a/mm/swap.c
> +++ b/mm/swap.c
> @@ -37,6 +37,8 @@
> int page_cluster;
>
> static DEFINE_PER_CPU(struct pagevec[NR_LRU_LISTS], lru_add_pvecs);
> +static DEFINE_PER_CPU(struct pagevec[NR_EVICTABLE_LRU_LISTS],
> + lru_add_isolated_pvecs);
> static DEFINE_PER_CPU(struct pagevec, lru_rotate_pvecs);
> static DEFINE_PER_CPU(struct pagevec, lru_deactivate_pvecs);
>
> @@ -381,6 +383,67 @@ void lru_cache_add_lru(struct page *page, enum lru_list lru)
> __lru_cache_add(page, lru);
> }
>
> +static void __lru_add_isolated_fn(struct lruvec *lruvec,
> + struct page *page, void *arg)
> +{
> + enum lru_list lru = (enum lru_list)arg;
> +
> + VM_BUG_ON(PageActive(page));
> + VM_BUG_ON(PageUnevictable(page));
> + VM_BUG_ON(PageLRU(page));
> +
> + SetPageLRU(page);
> + if (is_active_lru(lru))
> + SetPageActive(page);
> + update_page_reclaim_stat(lruvec, lru);
> + add_page_to_lru_list(lruvec, page, lru);
> + lruvec->pages_count[LRU_ISOLATED + is_file_lru(lru)] -=
> + hpage_nr_pages(page);
> +}
> +
> +static void __lru_add_isolated(struct pagevec *pvec, enum lru_list lru)
> +{
> + VM_BUG_ON(is_unevictable_lru(lru));
> + pagevec_lru_move_fn(pvec, __lru_add_isolated_fn, (void *)lru);
> +}
> +
> +/**
> + * add_page_to_evictable_list - add page to lru list
> + * @page the page to be added into the lru list
> + * @lru lru list id
> + * @isolated need to adjust isolated pages counter
> + *
> + * Like lru_cache_add_lru() but reuses caller's reference to page and
> + * taking care about isolated pages counter on lruvec if isolated = true.
> + */
> +void add_page_to_evictable_list(struct page *page,
> + enum lru_list lru, bool isolated)
> +{
> + struct pagevec *pvec;
> +
> + if (PageActive(page)) {
> + VM_BUG_ON(PageUnevictable(page));
> + ClearPageActive(page);
> + } else if (PageUnevictable(page)) {
> + VM_BUG_ON(PageActive(page));
> + ClearPageUnevictable(page);
> + }
> +
> + VM_BUG_ON(PageLRU(page) || PageActive(page) || PageUnevictable(page));
> +
> + preempt_disable();
> + if (isolated) {
> + pvec = __this_cpu_ptr(lru_add_isolated_pvecs + lru);
> + if (!pagevec_add(pvec, page))
> + __lru_add_isolated(pvec, lru);
> + } else {
> + pvec = __this_cpu_ptr(lru_add_pvecs + lru);
> + if (!pagevec_add(pvec, page))
> + __pagevec_lru_add(pvec, lru);
> + }
> + preempt_enable();
> +}
> +
> /**
> * add_page_to_unevictable_list - add a page to the unevictable list
> * @page: the page to be added to the unevictable list
> @@ -391,7 +454,7 @@ void lru_cache_add_lru(struct page *page, enum lru_list lru)
> * while it's locked or otherwise "invisible" to other tasks. This is
> * difficult to do when using the pagevec cache, so bypass that.
> */
> -void add_page_to_unevictable_list(struct page *page)
> +void add_page_to_unevictable_list(struct page *page, bool isolated)
> {
> struct lruvec *lruvec;
>
> @@ -399,6 +462,10 @@ void add_page_to_unevictable_list(struct page *page)
> SetPageUnevictable(page);
> SetPageLRU(page);
> add_page_to_lru_list(lruvec, page, LRU_UNEVICTABLE);
> + if (isolated) {
> + int type = LRU_ISOLATED + page_is_file_cache(page);
> + lruvec->pages_count[type] -= hpage_nr_pages(page);
> + }
> unlock_lruvec_irq(lruvec);
> }
>
> @@ -485,6 +552,13 @@ static void drain_cpu_pagevecs(int cpu)
> __pagevec_lru_add(pvec, lru);
> }
>
> + pvecs = per_cpu(lru_add_isolated_pvecs, cpu);
> + for_each_evictable_lru(lru) {
> + pvec = &pvecs[lru];
> + if (pagevec_count(pvec))
> + __lru_add_isolated(pvec, lru);
> + }
> +
> pvec = &per_cpu(lru_rotate_pvecs, cpu);
> if (pagevec_count(pvec)) {
> unsigned long flags;
> diff --git a/mm/vmscan.c b/mm/vmscan.c
> index 6eeeb4b..a1ff010 100644
> --- a/mm/vmscan.c
> +++ b/mm/vmscan.c
> @@ -42,6 +42,7 @@
> #include <linux/sysctl.h>
> #include <linux/oom.h>
> #include <linux/prefetch.h>
> +#include <trace/events/kmem.h>
>
> #include <asm/tlbflush.h>
> #include <asm/div64.h>
> @@ -585,15 +586,16 @@ int remove_mapping(struct address_space *mapping, struct page *page)
> }
>
> /**
> - * putback_lru_page - put previously isolated page onto appropriate LRU list
> + * __putback_lru_page - put previously isolated page onto appropriate LRU list
> * @page: page to be put back to appropriate lru list
> + * @isolated: isolated pages counter update required
> *
> * Add previously isolated @page to appropriate LRU list.
> * Page may still be unevictable for other reasons.
> *
> * lru_lock must not be held, interrupts must be enabled.
> */
> -void putback_lru_page(struct page *page)
> +void __putback_lru_page(struct page *page, bool isolated)
> {
> int lru;
> int active = !!TestClearPageActive(page);
> @@ -612,14 +614,16 @@ redo:
> * We know how to handle that.
> */
> lru = active + page_lru_base_type(page);
> - lru_cache_add_lru(page, lru);
> + add_page_to_evictable_list(page, lru, isolated);
> + if (was_unevictable)
> + count_vm_event(UNEVICTABLE_PGRESCUED);
> } else {
> /*
> * Put unevictable pages directly on zone's unevictable
> * list.
> */
> lru = LRU_UNEVICTABLE;
> - add_page_to_unevictable_list(page);
> + add_page_to_unevictable_list(page, isolated);
> /*
> * When racing with an mlock or AS_UNEVICTABLE clearing
> * (page is unlocked) make sure that if the other thread
> @@ -631,30 +635,26 @@ redo:
> * The other side is TestClearPageMlocked() or shmem_lock().
> */
> smp_mb();
> - }
> -
> - /*
> - * page's status can change while we move it among lru. If an evictable
> - * page is on unevictable list, it never be freed. To avoid that,
> - * check after we added it to the list, again.
> - */
> - if (lru == LRU_UNEVICTABLE && page_evictable(page, NULL)) {
> - if (!isolate_lru_page(page)) {
> - put_page(page);
> - goto redo;
> - }
> - /* This means someone else dropped this page from LRU
> - * So, it will be freed or putback to LRU again. There is
> - * nothing to do here.
> + /*
> + * page's status can change while we move it among lru.
> + * If an evictable page is on unevictable list, it never be freed.
> + * To avoid that, check after we added it to the list, again.
> */
> + if (page_evictable(page, NULL)) {
> + if (!isolate_lru_page(page)) {
> + isolated = true;
> + put_page(page);
> + goto redo;
> + }
> + /* This means someone else dropped this page from LRU
> + * So, it will be freed or putback to LRU again. There is
> + * nothing to do here.
> + */
> + }
> + put_page(page); /* drop ref from isolate */
> + if (!was_unevictable)
> + count_vm_event(UNEVICTABLE_PGCULLED);
> }
> -
> - if (was_unevictable && lru != LRU_UNEVICTABLE)
> - count_vm_event(UNEVICTABLE_PGRESCUED);
> - else if (!was_unevictable && lru == LRU_UNEVICTABLE)
> - count_vm_event(UNEVICTABLE_PGCULLED);
> -
> - put_page(page); /* drop ref from isolate */
> }
>
> enum page_references {
> @@ -724,6 +724,48 @@ static enum page_references page_check_references(struct page *page,
> }
>
> /*
> + * Free a list of isolated 0-order pages
> + */
> +static void free_isolated_page_list(struct lruvec *lruvec,
> + struct list_head *list, int cold)
> +{
> + struct page *page, *next;
> + unsigned long nr_pages[2];
> + struct list_head queue;
> +
> +again:
> + INIT_LIST_HEAD(&queue);
> + nr_pages[0] = nr_pages[1] = 0;
> +
> + list_for_each_entry_safe(page, next, list, lru) {
> + if (unlikely(lruvec != page_lruvec(page))) {
> + list_add_tail(&page->lru, &queue);
> + continue;
> + }
> + nr_pages[page_is_file_cache(page)]++;
> + trace_mm_page_free_batched(page, cold);
> + free_hot_cold_page(page, cold);
> + }
> +
> + lock_lruvec_irq(lruvec);
> + lruvec->pages_count[LRU_ISOLATED_ANON] -= nr_pages[0];
> + lruvec->pages_count[LRU_ISOLATED_FILE] -= nr_pages[1];
> + unlock_lruvec_irq(lruvec);


Is it guaranteed that all pages are from the same lruvec ?

Thanks,
-Kame

> +
> + /*
> + * Usually there will be only one iteration, because
> + * at 0-order reclaim all pages are from one lruvec
> + * if we didn't raced with memory cgroup shuffling.
> + */
> + if (unlikely(!list_empty(&queue))) {
> + list_replace(&queue, list);
> + lruvec = page_lruvec(list_first_entry(list,
> + struct page, lru));
> + goto again;
> + }
> +}
> +
> +/*
> * shrink_page_list() returns the number of reclaimed pages
> */
> static unsigned long shrink_page_list(struct list_head *page_list,
> @@ -986,7 +1028,7 @@ keep_lumpy:
> if (nr_dirty && nr_dirty == nr_congested && global_reclaim(sc))
> zone_set_flag(lruvec_zone(lruvec), ZONE_CONGESTED);
>
> - free_hot_cold_page_list(&free_pages, 1);
> + free_isolated_page_list(lruvec, &free_pages, 1);
>
> list_splice(&ret_pages, page_list);
> count_vm_events(PGACTIVATE, pgactivate);
> @@ -1206,11 +1248,14 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
> if (__isolate_lru_page(cursor_page, mode, file) == 0) {
> unsigned int isolated_pages;
> int cursor_lru = page_lru(cursor_page);
> + int cur_file = page_is_file_cache(cursor_page);
>
> list_move(&cursor_page->lru, dst);
> isolated_pages = hpage_nr_pages(cursor_page);
> cursor_lruvec->pages_count[cursor_lru] -=
> isolated_pages;
> + cursor_lruvec->pages_count[LRU_ISOLATED +
> + cur_file] += isolated_pages;
> VM_BUG_ON((long)cursor_lruvec->
> pages_count[cursor_lru] < 0);
> nr_taken += isolated_pages;
> @@ -1248,6 +1293,7 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
> }
>
> lruvec->pages_count[lru] -= nr_taken - nr_lumpy_taken;
> + lruvec->pages_count[LRU_ISOLATED + file] += nr_taken - nr_lumpy_taken;
> VM_BUG_ON((long)lruvec->pages_count[lru] < 0);
>
> *nr_scanned = scan;
> @@ -1296,11 +1342,14 @@ int isolate_lru_page(struct page *page)
>
> lruvec = lock_page_lruvec_irq(page);
> if (PageLRU(page)) {
> + int file = page_is_file_cache(page);
> int lru = page_lru(page);
> ret = 0;
> get_page(page);
> ClearPageLRU(page);
> del_page_from_lru_list(lruvec, page, lru);
> + lruvec->pages_count[LRU_ISOLATED + file] +=
> + hpage_nr_pages(page);
> }
> unlock_lruvec_irq(lruvec);
> }
> @@ -1347,7 +1396,7 @@ putback_inactive_pages(struct lruvec *lruvec,
> */
> while (!list_empty(page_list)) {
> struct page *page = lru_to_page(page_list);
> - int lru;
> + int numpages, lru, file;
>
> VM_BUG_ON(PageLRU(page));
> list_del(&page->lru);
> @@ -1363,13 +1412,13 @@ putback_inactive_pages(struct lruvec *lruvec,
>
> SetPageLRU(page);
> lru = page_lru(page);
> + file = is_file_lru(lru);
> + numpages = hpage_nr_pages(page);
>
> add_page_to_lru_list(lruvec, page, lru);
> - if (is_active_lru(lru)) {
> - int file = is_file_lru(lru);
> - int numpages = hpage_nr_pages(page);
> + lruvec->pages_count[LRU_ISOLATED + file] -= numpages;
> + if (is_active_lru(lru))
> reclaim_stat->recent_rotated[file] += numpages;
> - }
> if (put_page_testzero(page)) {
> __ClearPageLRU(page);
> __ClearPageActive(page);
> @@ -1656,6 +1705,9 @@ move_active_pages_to_lru(struct lruvec *lruvec,
> list_move(&page->lru, &lruvec->pages_lru[lru]);
> numpages = hpage_nr_pages(page);
> lruvec->pages_count[lru] += numpages;
> + /* There should be no mess between file and anon pages */
> + lruvec->pages_count[LRU_ISOLATED +
> + is_file_lru(lru)] -= numpages;
> pgmoved += numpages;
>
> if (put_page_testzero(page)) {
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at http://www.tux.org/lkml/
>



\
 
 \ /
  Last update: 2012-02-28 02:43    [from the cache]
©2003-2011 Jasper Spaans