4 files changed, 41 insertions, 8 deletions

diff --git a/mm/bootmem.c b/mm/bootmem.c
index 58c66cc5056a..142c84a54993 100644
--- a/mm/bootmem.c
+++ b/mm/bootmem.c
@@ -833,15 +833,24 @@ static void * __init ___alloc_bootmem_node(bootmem_data_t *bdata,
 void * __init __alloc_bootmem_node(pg_data_t *pgdat, unsigned long size,
                                    unsigned long align, unsigned long goal)
 {
+        void *ptr;
+
         if (WARN_ON_ONCE(slab_is_available()))
                 return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
 
 #ifdef CONFIG_NO_BOOTMEM
-        return __alloc_memory_core_early(pgdat->node_id, size, align,
+        ptr = __alloc_memory_core_early(pgdat->node_id, size, align,
+                                         goal, -1ULL);
+        if (ptr)
+                return ptr;
+
+        ptr = __alloc_memory_core_early(MAX_NUMNODES, size, align,
                                          goal, -1ULL);
 #else
-        return ___alloc_bootmem_node(pgdat->bdata, size, align, goal, 0);
+        ptr = ___alloc_bootmem_node(pgdat->bdata, size, align, goal, 0);
 #endif
+
+        return ptr;
 }
 
 void * __init __alloc_bootmem_node_high(pg_data_t *pgdat, unsigned long size,
@@ -977,14 +986,21 @@ void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
 void * __init __alloc_bootmem_low_node(pg_data_t *pgdat, unsigned long size,
                                        unsigned long align, unsigned long goal)
 {
+        void *ptr;
+
         if (WARN_ON_ONCE(slab_is_available()))
                 return kzalloc_node(size, GFP_NOWAIT, pgdat->node_id);
 
 #ifdef CONFIG_NO_BOOTMEM
-        return __alloc_memory_core_early(pgdat->node_id, size, align,
+        ptr = __alloc_memory_core_early(pgdat->node_id, size, align,
+                                goal, ARCH_LOW_ADDRESS_LIMIT);
+        if (ptr)
+                return ptr;
+        ptr = __alloc_memory_core_early(MAX_NUMNODES, size, align,
                                 goal, ARCH_LOW_ADDRESS_LIMIT);
 #else
-        return ___alloc_bootmem_node(pgdat->bdata, size, align,
+        ptr = ___alloc_bootmem_node(pgdat->bdata, size, align,
                                 goal, ARCH_LOW_ADDRESS_LIMIT);
 #endif
+        return ptr;
 }
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 431214b941ac..9bd339eb04c6 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3634,6 +3634,9 @@ void * __init __alloc_memory_core_early(int nid, u64 size, u64 align,
         int i;
         void *ptr;
 
+        if (limit > get_max_mapped())
+                limit = get_max_mapped();
+
         /* need to go over early_node_map to find out good range for node */
         for_each_active_range_index_in_nid(i, nid) {
                 u64 addr;
@@ -3659,6 +3662,11 @@ void * __init __alloc_memory_core_early(int nid, u64 size, u64 align,
                 ptr = phys_to_virt(addr);
                 memset(ptr, 0, size);
                 reserve_early_without_check(addr, addr + size, "BOOTMEM");
+                /*
+                 * The min_count is set to 0 so that bootmem allocated blocks
+                 * are never reported as leaks.
+                 */
+                kmemleak_alloc(ptr, size, 0, 0);
                 return ptr;
         }
 
diff --git a/mm/page_cgroup.c b/mm/page_cgroup.c
index 6c0081441a32..5bffada7cde1 100644
--- a/mm/page_cgroup.c
+++ b/mm/page_cgroup.c
@@ -9,6 +9,7 @@
 #include <linux/vmalloc.h>
 #include <linux/cgroup.h>
 #include <linux/swapops.h>
+#include <linux/kmemleak.h>
 
 static void __meminit
 __init_page_cgroup(struct page_cgroup *pc, unsigned long pfn)
@@ -126,6 +127,12 @@ static int __init_refok init_section_page_cgroup(unsigned long pfn)
                         if (!base)
                                 base = vmalloc(table_size);
                 }
+                /*
+                 * The value stored in section->page_cgroup is (base - pfn)
+                 * and it does not point to the memory block allocated above,
+                 * causing kmemleak false positives.
+                 */
+                kmemleak_not_leak(base);
         } else {
                 /*
                  * We don't have to allocate page_cgroup again, but
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 9c7e57cc63a3..b94fe1b3da43 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -213,8 +213,9 @@ unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
         list_for_each_entry(shrinker, &shrinker_list, list) {
                 unsigned long long delta;
                 unsigned long total_scan;
-                unsigned long max_pass = (*shrinker->shrink)(0, gfp_mask);
+                unsigned long max_pass;
 
+                max_pass = (*shrinker->shrink)(shrinker, 0, gfp_mask);
                 delta = (4 * scanned) / shrinker->seeks;
                 delta *= max_pass;
                 do_div(delta, lru_pages + 1);
@@ -242,8 +243,9 @@ unsigned long shrink_slab(unsigned long scanned, gfp_t gfp_mask,
                         int shrink_ret;
                         int nr_before;
 
-                        nr_before = (*shrinker->shrink)(0, gfp_mask);
-                        shrink_ret = (*shrinker->shrink)(this_scan, gfp_mask);
+                        nr_before = (*shrinker->shrink)(shrinker, 0, gfp_mask);
+                        shrink_ret = (*shrinker->shrink)(shrinker, this_scan,
+                                                                gfp_mask);
                         if (shrink_ret == -1)
                                 break;
                         if (shrink_ret < nr_before)
@@ -296,7 +298,7 @@ static int may_write_to_queue(struct backing_dev_info *bdi)
 static void handle_write_error(struct address_space *mapping,
                                 struct page *page, int error)
 {
-        lock_page(page);
+        lock_page_nosync(page);
         if (page_mapping(page) == mapping)
                 mapping_set_error(mapping, error);
         unlock_page(page);