Merge branch 'linus' into perf/urgent

Merge reason: Linus applied an overlapping commit:

  5f2e8e2b0bf0: kernel/watchdog.c: Use proper ANSI C prototypes

So merge it in to make sure we can iterate the file without conflicts.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

1 files changed, 79 insertions, 45 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 3f8bce264df6..2a00f17c3bf4 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -30,6 +30,7 @@
 #include <linux/pagevec.h>
 #include <linux/blkdev.h>
 #include <linux/slab.h>
+#include <linux/ratelimit.h>
 #include <linux/oom.h>
 #include <linux/notifier.h>
 #include <linux/topology.h>
@@ -39,6 +40,7 @@
 #include <linux/memory_hotplug.h>
 #include <linux/nodemask.h>
 #include <linux/vmalloc.h>
+#include <linux/vmstat.h>
 #include <linux/mempolicy.h>
 #include <linux/stop_machine.h>
 #include <linux/sort.h>
@@ -54,6 +56,7 @@
 #include <trace/events/kmem.h>
 #include <linux/ftrace_event.h>
 #include <linux/memcontrol.h>
+#include <linux/prefetch.h>
 
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
@@ -1734,6 +1737,45 @@ static inline bool should_suppress_show_mem(void)
         return ret;
 }
 
+static DEFINE_RATELIMIT_STATE(nopage_rs,
+                DEFAULT_RATELIMIT_INTERVAL,
+                DEFAULT_RATELIMIT_BURST);
+
+void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...)
+{
+        va_list args;
+        unsigned int filter = SHOW_MEM_FILTER_NODES;
+
+        if ((gfp_mask & __GFP_NOWARN) || !__ratelimit(&nopage_rs))
+                return;
+
+        /*
+         * This documents exceptions given to allocations in certain
+         * contexts that are allowed to allocate outside current's set
+         * of allowed nodes.
+         */
+        if (!(gfp_mask & __GFP_NOMEMALLOC))
+                if (test_thread_flag(TIF_MEMDIE) ||
+                    (current->flags & (PF_MEMALLOC | PF_EXITING)))
+                        filter &= ~SHOW_MEM_FILTER_NODES;
+        if (in_interrupt() || !(gfp_mask & __GFP_WAIT))
+                filter &= ~SHOW_MEM_FILTER_NODES;
+
+        if (fmt) {
+                printk(KERN_WARNING);
+                va_start(args, fmt);
+                vprintk(fmt, args);
+                va_end(args);
+        }
+
+        pr_warning("%s: page allocation failure: order:%d, mode:0x%x\n",
+                   current->comm, order, gfp_mask);
+
+        dump_stack();
+        if (!should_suppress_show_mem())
+                show_mem(filter);
+}
+
 static inline int
 should_alloc_retry(gfp_t gfp_mask, unsigned int order,
                                 unsigned long pages_reclaimed)
@@ -2064,6 +2106,7 @@ restart:
                 first_zones_zonelist(zonelist, high_zoneidx, NULL,
                                         &preferred_zone);
 
+rebalance:
         /* This is the last chance, in general, before the goto nopage. */
         page = get_page_from_freelist(gfp_mask, nodemask, order, zonelist,
                         high_zoneidx, alloc_flags & ~ALLOC_NO_WATERMARKS,
@@ -2071,7 +2114,6 @@ restart:
         if (page)
                 goto got_pg;
 
-rebalance:
         /* Allocate without watermarks if the context allows */
         if (alloc_flags & ALLOC_NO_WATERMARKS) {
                 page = __alloc_pages_high_priority(gfp_mask, order,
@@ -2105,7 +2147,7 @@ rebalance:
                                         sync_migration);
         if (page)
                 goto got_pg;
-        sync_migration = !(gfp_mask & __GFP_NO_KSWAPD);
+        sync_migration = true;
 
         /* Try direct reclaim and then allocating */
         page = __alloc_pages_direct_reclaim(gfp_mask, order,
@@ -2176,27 +2218,7 @@ rebalance:
         }
 
 nopage:
-        if (!(gfp_mask & __GFP_NOWARN) && printk_ratelimit()) {
-                unsigned int filter = SHOW_MEM_FILTER_NODES;
-
-                /*
-                 * This documents exceptions given to allocations in certain
-                 * contexts that are allowed to allocate outside current's set
-                 * of allowed nodes.
-                 */
-                if (!(gfp_mask & __GFP_NOMEMALLOC))
-                        if (test_thread_flag(TIF_MEMDIE) ||
-                            (current->flags & (PF_MEMALLOC | PF_EXITING)))
-                                filter &= ~SHOW_MEM_FILTER_NODES;
-                if (in_interrupt() || !wait)
-                        filter &= ~SHOW_MEM_FILTER_NODES;
-
-                pr_warning("%s: page allocation failure. order:%d, mode:0x%x\n",
-                        current->comm, order, gfp_mask);
-                dump_stack();
-                if (!should_suppress_show_mem())
-                        show_mem(filter);
-        }
+        warn_alloc_failed(gfp_mask, order, NULL);
         return page;
 got_pg:
         if (kmemcheck_enabled)
@@ -2225,6 +2247,10 @@ __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,
 
         if (should_fail_alloc_page(gfp_mask, order))
                 return NULL;
+#ifndef CONFIG_ZONE_DMA
+        if (WARN_ON_ONCE(gfp_mask & __GFP_DMA))
+                return NULL;
+#endif
 
         /*
          * Check the zones suitable for the gfp_mask contain at least one
@@ -2472,10 +2498,10 @@ void si_meminfo_node(struct sysinfo *val, int nid)
 #endif
 
 /*
- * Determine whether the zone's node should be displayed or not, depending on
- * whether SHOW_MEM_FILTER_NODES was passed to __show_free_areas().
+ * Determine whether the node should be displayed or not, depending on whether
+ * SHOW_MEM_FILTER_NODES was passed to show_free_areas().
  */
-static bool skip_free_areas_zone(unsigned int flags, const struct zone *zone)
+bool skip_free_areas_node(unsigned int flags, int nid)
 {
         bool ret = false;
 
@@ -2483,8 +2509,7 @@ static bool skip_free_areas_zone(unsigned int flags, const struct zone *zone)
                 goto out;
 
         get_mems_allowed();
-        ret = !node_isset(zone->zone_pgdat->node_id,
-                                cpuset_current_mems_allowed);
+        ret = !node_isset(nid, cpuset_current_mems_allowed);
         put_mems_allowed();
 out:
         return ret;
@@ -2499,13 +2524,13 @@ out:
  * Suppresses nodes that are not allowed by current's cpuset if
  * SHOW_MEM_FILTER_NODES is passed.
  */
-void __show_free_areas(unsigned int filter)
+void show_free_areas(unsigned int filter)
 {
         int cpu;
         struct zone *zone;
 
         for_each_populated_zone(zone) {
-                if (skip_free_areas_zone(filter, zone))
+                if (skip_free_areas_node(filter, zone_to_nid(zone)))
                         continue;
                 show_node(zone);
                 printk("%s per-cpu:\n", zone->name);
@@ -2548,7 +2573,7 @@ void __show_free_areas(unsigned int filter)
         for_each_populated_zone(zone) {
                 int i;
 
-                if (skip_free_areas_zone(filter, zone))
+                if (skip_free_areas_node(filter, zone_to_nid(zone)))
                         continue;
                 show_node(zone);
                 printk("%s"
@@ -2617,7 +2642,7 @@ void __show_free_areas(unsigned int filter)
         for_each_populated_zone(zone) {
                 unsigned long nr[MAX_ORDER], flags, order, total = 0;
 
-                if (skip_free_areas_zone(filter, zone))
+                if (skip_free_areas_node(filter, zone_to_nid(zone)))
                         continue;
                 show_node(zone);
                 printk("%s: ", zone->name);
@@ -2638,11 +2663,6 @@ void __show_free_areas(unsigned int filter)
         show_swap_cache_info();
 }
 
-void show_free_areas(void)
-{
-        __show_free_areas(0);
-}
-
 static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)
 {
         zoneref->zone = zone;
@@ -3313,6 +3333,20 @@ static inline unsigned long wait_table_bits(unsigned long size)
 #define LONG_ALIGN(x) (((x)+(sizeof(long))-1)&~((sizeof(long))-1))
 
 /*
+ * Check if a pageblock contains reserved pages
+ */
+static int pageblock_is_reserved(unsigned long start_pfn, unsigned long end_pfn)
+{
+        unsigned long pfn;
+
+        for (pfn = start_pfn; pfn < end_pfn; pfn++) {
+                if (!pfn_valid_within(pfn) || PageReserved(pfn_to_page(pfn)))
+                        return 1;
+        }
+        return 0;
+}
+
+/*
  * Mark a number of pageblocks as MIGRATE_RESERVE. The number
  * of blocks reserved is based on min_wmark_pages(zone). The memory within
  * the reserve will tend to store contiguous free pages. Setting min_free_kbytes
@@ -3321,7 +3355,7 @@ static inline unsigned long wait_table_bits(unsigned long size)
  */
 static void setup_zone_migrate_reserve(struct zone *zone)
 {
-        unsigned long start_pfn, pfn, end_pfn;
+        unsigned long start_pfn, pfn, end_pfn, block_end_pfn;
         struct page *page;
         unsigned long block_migratetype;
         int reserve;
@@ -3351,7 +3385,8 @@ static void setup_zone_migrate_reserve(struct zone *zone)
                         continue;
 
                 /* Blocks with reserved pages will never free, skip them. */
-                if (PageReserved(page))
+                block_end_pfn = min(pfn + pageblock_nr_pages, end_pfn);
+                if (pageblock_is_reserved(pfn, block_end_pfn))
                         continue;
 
                 block_migratetype = get_pageblock_migratetype(page);
@@ -3540,7 +3575,7 @@ static void setup_pagelist_highmark(struct per_cpu_pageset *p,
                 pcp->batch = PAGE_SHIFT * 8;
 }
 
-static __meminit void setup_zone_pageset(struct zone *zone)
+static void setup_zone_pageset(struct zone *zone)
 {
         int cpu;
 
@@ -5099,7 +5134,7 @@ void setup_per_zone_wmarks(void)
  *    1TB     101        10GB
  *   10TB     320        32GB
  */
-void calculate_zone_inactive_ratio(struct zone *zone)
+static void __meminit calculate_zone_inactive_ratio(struct zone *zone)
 {
         unsigned int gb, ratio;
 
@@ -5113,7 +5148,7 @@ void calculate_zone_inactive_ratio(struct zone *zone)
         zone->inactive_ratio = ratio;
 }
 
-static void __init setup_per_zone_inactive_ratio(void)
+static void __meminit setup_per_zone_inactive_ratio(void)
 {
         struct zone *zone;
 
@@ -5145,7 +5180,7 @@ static void __init setup_per_zone_inactive_ratio(void)
  * 8192MB:      11584k
  * 16384MB:     16384k
  */
-static int __init init_per_zone_wmark_min(void)
+int __meminit init_per_zone_wmark_min(void)
 {
         unsigned long lowmem_kbytes;
 
@@ -5157,6 +5192,7 @@ static int __init init_per_zone_wmark_min(void)
         if (min_free_kbytes > 65536)
                 min_free_kbytes = 65536;
         setup_per_zone_wmarks();
+        refresh_zone_stat_thresholds();
         setup_per_zone_lowmem_reserve();
         setup_per_zone_inactive_ratio();
         return 0;
@@ -5507,10 +5543,8 @@ int set_migratetype_isolate(struct page *page)
         struct memory_isolate_notify arg;
         int notifier_ret;
         int ret = -EBUSY;
-        int zone_idx;
 
         zone = page_zone(page);
-        zone_idx = zone_idx(zone);
 
         spin_lock_irqsave(&zone->lock, flags);