Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost

[deliverable/linux.git] / mm / page_alloc.c

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index e0a39d328ca1881db18147640099cad79fb5d522..7633c503a116c221e7447614c6d10ebaa38a0b1c 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -59,6 +59,7 @@
 #include <linux/page_ext.h>
 #include <linux/hugetlb.h>
 #include <linux/sched/rt.h>
+#include <linux/page_owner.h>
 
 #include <asm/sections.h>
 #include <asm/tlbflush.h>
@@ -110,6 +111,7 @@ static DEFINE_SPINLOCK(managed_page_count_lock);
 
 unsigned long totalram_pages __read_mostly;
 unsigned long totalreserve_pages __read_mostly;
+unsigned long totalcma_pages __read_mostly;
 /*
  * When calculating the number of globally allowed dirty pages, there
  * is a certain number of per-zone reserves that should not be
@@ -425,15 +427,35 @@ static inline void prep_zero_page(struct page *page, unsigned int order,
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
 unsigned int _debug_guardpage_minorder;
+bool _debug_pagealloc_enabled __read_mostly;
 bool _debug_guardpage_enabled __read_mostly;
 
+static int __init early_debug_pagealloc(char *buf)
+{
+       if (!buf)
+               return -EINVAL;
+
+       if (strcmp(buf, "on") == 0)
+               _debug_pagealloc_enabled = true;
+
+       return 0;
+}
+early_param("debug_pagealloc", early_debug_pagealloc);
+
 static bool need_debug_guardpage(void)
 {
+       /* If we don't use debug_pagealloc, we don't need guard page */
+       if (!debug_pagealloc_enabled())
+               return false;
+
        return true;
 }
 
 static void init_debug_guardpage(void)
 {
+       if (!debug_pagealloc_enabled())
+               return;
+
        _debug_guardpage_enabled = true;
 }
 
@@ -793,6 +815,8 @@ static bool free_pages_prepare(struct page *page, unsigned int order)
        if (bad)
                return false;
 
+       reset_page_owner(page, order);
+
        if (!PageHighMem(page)) {
                debug_check_no_locks_freed(page_address(page),
                                           PAGE_SIZE << order);
@@ -968,6 +992,8 @@ static int prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags)
        if (order && (gfp_flags & __GFP_COMP))
                prep_compound_page(page, order);
 
+       set_page_owner(page, order, gfp_flags);
+
        return 0;
 }
 
@@ -1540,8 +1566,11 @@ void split_page(struct page *page, unsigned int order)
                split_page(virt_to_page(page[0].shadow), order);
 #endif
 
-       for (i = 1; i < (1 << order); i++)
+       set_page_owner(page, 0, 0);
+       for (i = 1; i < (1 << order); i++) {
                set_page_refcounted(page + i);
+               set_page_owner(page + i, 0, 0);
+       }
 }
 EXPORT_SYMBOL_GPL(split_page);
 
@@ -1581,6 +1610,7 @@ int __isolate_free_page(struct page *page, unsigned int order)
                }
        }
 
+       set_page_owner(page, order, 0);
        return 1UL << order;
 }
 
@@ -4908,16 +4938,18 @@ static void __paginginit free_area_init_core(struct pglist_data *pgdat,
                 * and per-cpu initialisations
                 */
                memmap_pages = calc_memmap_size(size, realsize);
-               if (freesize >= memmap_pages) {
-                       freesize -= memmap_pages;
-                       if (memmap_pages)
-                               printk(KERN_DEBUG
-                                      "  %s zone: %lu pages used for memmap\n",
-                                      zone_names[j], memmap_pages);
-               } else
-                       printk(KERN_WARNING
-                               "  %s zone: %lu pages exceeds freesize %lu\n",
-                               zone_names[j], memmap_pages, freesize);
+               if (!is_highmem_idx(j)) {
+                       if (freesize >= memmap_pages) {
+                               freesize -= memmap_pages;
+                               if (memmap_pages)
+                                       printk(KERN_DEBUG
+                                              "  %s zone: %lu pages used for memmap\n",
+                                              zone_names[j], memmap_pages);
+                       } else
+                               printk(KERN_WARNING
+                                       "  %s zone: %lu pages exceeds freesize %lu\n",
+                                       zone_names[j], memmap_pages, freesize);
+               }
 
                /* Account for reserved pages */
                if (j == 0 && freesize > dma_reserve) {
@@ -5555,7 +5587,7 @@ void __init mem_init_print_info(const char *str)
 
        pr_info("Memory: %luK/%luK available "
               "(%luK kernel code, %luK rwdata, %luK rodata, "
-              "%luK init, %luK bss, %luK reserved"
+              "%luK init, %luK bss, %luK reserved, %luK cma-reserved"
 #ifdef CONFIG_HIGHMEM
               ", %luK highmem"
 #endif
@@ -5563,7 +5595,8 @@ void __init mem_init_print_info(const char *str)
               nr_free_pages() << (PAGE_SHIFT-10), physpages << (PAGE_SHIFT-10),
               codesize >> 10, datasize >> 10, rosize >> 10,
               (init_data_size + init_code_size) >> 10, bss_size >> 10,
-              (physpages - totalram_pages) << (PAGE_SHIFT-10),
+              (physpages - totalram_pages - totalcma_pages) << (PAGE_SHIFT-10),
+              totalcma_pages << (PAGE_SHIFT-10),
 #ifdef CONFIG_HIGHMEM
               totalhigh_pages << (PAGE_SHIFT-10),
 #endif
@@ -6255,9 +6288,9 @@ bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
                if (!PageLRU(page))
                        found++;
                /*
-                * If there are RECLAIMABLE pages, we need to check it.
-                * But now, memory offline itself doesn't call shrink_slab()
-                * and it still to be fixed.
+                * If there are RECLAIMABLE pages, we need to check
+                * it.  But now, memory offline itself doesn't call
+                * shrink_node_slabs() and it still to be fixed.
                 */
                /*
                 * If the page is not RAM, page_count()should be 0.