lkml.org 
[lkml]   [2014]   [Nov]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 3.17 030/141] mm/page_alloc: restrict max order of merging on isolated pageblock
    Date
    3.17-stable review patch.  If anyone has any objections, please let me know.

    ------------------

    From: Joonsoo Kim <iamjoonsoo.kim@lge.com>

    commit 3c605096d3158216ba9326a16266f6ba128c2c8d upstream.

    Current pageblock isolation logic could isolate each pageblock
    individually. This causes freepage accounting problem if freepage with
    pageblock order on isolate pageblock is merged with other freepage on
    normal pageblock. We can prevent merging by restricting max order of
    merging to pageblock order if freepage is on isolate pageblock.

    A side-effect of this change is that there could be non-merged buddy
    freepage even if finishing pageblock isolation, because undoing
    pageblock isolation is just to move freepage from isolate buddy list to
    normal buddy list rather than to consider merging. So, the patch also
    makes undoing pageblock isolation consider freepage merge. When
    un-isolation, freepage with more than pageblock order and it's buddy are
    checked. If they are on normal pageblock, instead of just moving, we
    isolate the freepage and free it in order to get merged.

    Signed-off-by: Joonsoo Kim <iamjoonsoo.kim@lge.com>
    Acked-by: Vlastimil Babka <vbabka@suse.cz>
    Cc: "Kirill A. Shutemov" <kirill@shutemov.name>
    Cc: Mel Gorman <mgorman@suse.de>
    Cc: Johannes Weiner <hannes@cmpxchg.org>
    Cc: Minchan Kim <minchan@kernel.org>
    Cc: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
    Cc: Zhang Yanfei <zhangyanfei@cn.fujitsu.com>
    Cc: Tang Chen <tangchen@cn.fujitsu.com>
    Cc: Naoya Horiguchi <n-horiguchi@ah.jp.nec.com>
    Cc: Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>
    Cc: Wen Congyang <wency@cn.fujitsu.com>
    Cc: Marek Szyprowski <m.szyprowski@samsung.com>
    Cc: Michal Nazarewicz <mina86@mina86.com>
    Cc: Laura Abbott <lauraa@codeaurora.org>
    Cc: Heesub Shin <heesub.shin@samsung.com>
    Cc: "Aneesh Kumar K.V" <aneesh.kumar@linux.vnet.ibm.com>
    Cc: Ritesh Harjani <ritesh.list@gmail.com>
    Cc: Gioh Kim <gioh.kim@lge.com>
    Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
    Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
    Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

    ---
    mm/internal.h | 25 +++++++++++++++++++++++++
    mm/page_alloc.c | 41 ++++++++++++++---------------------------
    mm/page_isolation.c | 41 +++++++++++++++++++++++++++++++++++++++--
    3 files changed, 78 insertions(+), 29 deletions(-)

    --- a/mm/internal.h
    +++ b/mm/internal.h
    @@ -108,6 +108,31 @@ extern pmd_t *mm_find_pmd(struct mm_stru
    /*
    * in mm/page_alloc.c
    */
    +
    +/*
    + * Locate the struct page for both the matching buddy in our
    + * pair (buddy1) and the combined O(n+1) page they form (page).
    + *
    + * 1) Any buddy B1 will have an order O twin B2 which satisfies
    + * the following equation:
    + * B2 = B1 ^ (1 << O)
    + * For example, if the starting buddy (buddy2) is #8 its order
    + * 1 buddy is #10:
    + * B2 = 8 ^ (1 << 1) = 8 ^ 2 = 10
    + *
    + * 2) Any buddy B will have an order O+1 parent P which
    + * satisfies the following equation:
    + * P = B & ~(1 << O)
    + *
    + * Assumption: *_mem_map is contiguous at least up to MAX_ORDER
    + */
    +static inline unsigned long
    +__find_buddy_index(unsigned long page_idx, unsigned int order)
    +{
    + return page_idx ^ (1 << order);
    +}
    +
    +extern int __isolate_free_page(struct page *page, unsigned int order);
    extern void __free_pages_bootmem(struct page *page, unsigned int order);
    extern void prep_compound_page(struct page *page, unsigned long order);
    #ifdef CONFIG_MEMORY_FAILURE
    --- a/mm/page_alloc.c
    +++ b/mm/page_alloc.c
    @@ -468,29 +468,6 @@ static inline void rmv_page_order(struct
    }

    /*
    - * Locate the struct page for both the matching buddy in our
    - * pair (buddy1) and the combined O(n+1) page they form (page).
    - *
    - * 1) Any buddy B1 will have an order O twin B2 which satisfies
    - * the following equation:
    - * B2 = B1 ^ (1 << O)
    - * For example, if the starting buddy (buddy2) is #8 its order
    - * 1 buddy is #10:
    - * B2 = 8 ^ (1 << 1) = 8 ^ 2 = 10
    - *
    - * 2) Any buddy B will have an order O+1 parent P which
    - * satisfies the following equation:
    - * P = B & ~(1 << O)
    - *
    - * Assumption: *_mem_map is contiguous at least up to MAX_ORDER
    - */
    -static inline unsigned long
    -__find_buddy_index(unsigned long page_idx, unsigned int order)
    -{
    - return page_idx ^ (1 << order);
    -}
    -
    -/*
    * This function checks whether a page is free && is the buddy
    * we can do coalesce a page and its buddy if
    * (a) the buddy is not in a hole &&
    @@ -570,6 +547,7 @@ static inline void __free_one_page(struc
    unsigned long combined_idx;
    unsigned long uninitialized_var(buddy_idx);
    struct page *buddy;
    + int max_order = MAX_ORDER;

    VM_BUG_ON(!zone_is_initialized(zone));

    @@ -578,15 +556,24 @@ static inline void __free_one_page(struc
    return;

    VM_BUG_ON(migratetype == -1);
    - if (!is_migrate_isolate(migratetype))
    + if (is_migrate_isolate(migratetype)) {
    + /*
    + * We restrict max order of merging to prevent merge
    + * between freepages on isolate pageblock and normal
    + * pageblock. Without this, pageblock isolation
    + * could cause incorrect freepage accounting.
    + */
    + max_order = min(MAX_ORDER, pageblock_order + 1);
    + } else {
    __mod_zone_freepage_state(zone, 1 << order, migratetype);
    + }

    - page_idx = pfn & ((1 << MAX_ORDER) - 1);
    + page_idx = pfn & ((1 << max_order) - 1);

    VM_BUG_ON_PAGE(page_idx & ((1 << order) - 1), page);
    VM_BUG_ON_PAGE(bad_range(zone, page), page);

    - while (order < MAX_ORDER-1) {
    + while (order < max_order - 1) {
    buddy_idx = __find_buddy_index(page_idx, order);
    buddy = page + (buddy_idx - page_idx);
    if (!page_is_buddy(page, buddy, order))
    @@ -1487,7 +1474,7 @@ void split_page(struct page *page, unsig
    }
    EXPORT_SYMBOL_GPL(split_page);

    -static int __isolate_free_page(struct page *page, unsigned int order)
    +int __isolate_free_page(struct page *page, unsigned int order)
    {
    unsigned long watermark;
    struct zone *zone;
    --- a/mm/page_isolation.c
    +++ b/mm/page_isolation.c
    @@ -76,17 +76,54 @@ void unset_migratetype_isolate(struct pa
    {
    struct zone *zone;
    unsigned long flags, nr_pages;
    + struct page *isolated_page = NULL;
    + unsigned int order;
    + unsigned long page_idx, buddy_idx;
    + struct page *buddy;

    zone = page_zone(page);
    spin_lock_irqsave(&zone->lock, flags);
    if (get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
    goto out;
    - nr_pages = move_freepages_block(zone, page, migratetype);
    - __mod_zone_freepage_state(zone, nr_pages, migratetype);
    +
    + /*
    + * Because freepage with more than pageblock_order on isolated
    + * pageblock is restricted to merge due to freepage counting problem,
    + * it is possible that there is free buddy page.
    + * move_freepages_block() doesn't care of merge so we need other
    + * approach in order to merge them. Isolation and free will make
    + * these pages to be merged.
    + */
    + if (PageBuddy(page)) {
    + order = page_order(page);
    + if (order >= pageblock_order) {
    + page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1);
    + buddy_idx = __find_buddy_index(page_idx, order);
    + buddy = page + (buddy_idx - page_idx);
    +
    + if (!is_migrate_isolate_page(buddy)) {
    + __isolate_free_page(page, order);
    + set_page_refcounted(page);
    + isolated_page = page;
    + }
    + }
    + }
    +
    + /*
    + * If we isolate freepage with more than pageblock_order, there
    + * should be no freepage in the range, so we could avoid costly
    + * pageblock scanning for freepage moving.
    + */
    + if (!isolated_page) {
    + nr_pages = move_freepages_block(zone, page, migratetype);
    + __mod_zone_freepage_state(zone, nr_pages, migratetype);
    + }
    set_pageblock_migratetype(page, migratetype);
    zone->nr_isolate_pageblock--;
    out:
    spin_unlock_irqrestore(&zone->lock, flags);
    + if (isolated_page)
    + __free_pages(isolated_page, order);
    }

    static inline struct page *



    \
     
     \ /
      Last update: 2014-11-20 00:01    [W:2.704 / U:0.100 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site