5 files changed, 38 insertions, 26 deletions

diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 6969cfb33901..b278b8d60eee 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -61,12 +61,6 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
         }
 
         /*
-         * swapoff can easily use up all memory, so kill those first.
-         */
-        if (p->flags & PF_SWAPOFF)
-                return ULONG_MAX;
-
-        /*
          * The memory size of the process is the basis for the badness.
          */
         points = mm->total_vm;
@@ -77,6 +71,12 @@ unsigned long badness(struct task_struct *p, unsigned long uptime)
         task_unlock(p);
 
         /*
+         * swapoff can easily use up all memory, so kill those first.
+         */
+        if (p->flags & PF_SWAPOFF)
+                return ULONG_MAX;
+
+        /*
          * Processes which fork a lot of child processes are likely
          * a good choice. We add half the vmsize of the children if they
          * have an own mm. This prevents forking servers to flood the
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 8c1a116875bc..a49f96b7ea43 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -711,6 +711,9 @@ static void __drain_pages(unsigned int cpu)
         for_each_zone(zone) {
                 struct per_cpu_pageset *pset;
 
+                if (!populated_zone(zone))
+                        continue;
+
                 pset = zone_pcp(zone, cpu);
                 for (i = 0; i < ARRAY_SIZE(pset->pcp); i++) {
                         struct per_cpu_pages *pcp;
@@ -3321,6 +3324,10 @@ void *__init alloc_large_system_hash(const char *tablename,
                         numentries >>= (scale - PAGE_SHIFT);
                 else
                         numentries <<= (PAGE_SHIFT - scale);
+
+                /* Make sure we've got at least a 0-order allocation.. */
+                if (unlikely((numentries * bucketsize) < PAGE_SIZE))
+                        numentries = PAGE_SIZE / bucketsize;
         }
         numentries = roundup_pow_of_two(numentries);
 
diff --git a/mm/slab.c b/mm/slab.c
index 0d4e57431de4..c6100628a6ef 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -3281,7 +3281,7 @@ retry:
                                         flags | GFP_THISNODE, nid);
         }
 
-        if (!obj) {
+        if (!obj && !(flags & __GFP_NO_GROW)) {
                 /*
                  * This allocation will be performed within the constraints
                  * of the current cpuset / memory policy requirements.
@@ -3310,7 +3310,7 @@ retry:
                                          */
                                         goto retry;
                         } else {
-                                kmem_freepages(cache, obj);
+                                /* cache_grow already freed obj */
                                 obj = NULL;
                         }
                 }
diff --git a/mm/swapfile.c b/mm/swapfile.c
index b9fc0e5de6d5..a2d9bb4e80df 100644
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -434,7 +434,7 @@ void free_swap_and_cache(swp_entry_t entry)
  *
  * This is needed for the suspend to disk (aka swsusp).
  */
-int swap_type_of(dev_t device, sector_t offset)
+int swap_type_of(dev_t device, sector_t offset, struct block_device **bdev_p)
 {
         struct block_device *bdev = NULL;
         int i;
@@ -450,6 +450,9 @@ int swap_type_of(dev_t device, sector_t offset)
                         continue;
 
                 if (!bdev) {
+                        if (bdev_p)
+                                *bdev_p = sis->bdev;
+
                         spin_unlock(&swap_lock);
                         return i;
                 }
@@ -459,6 +462,9 @@ int swap_type_of(dev_t device, sector_t offset)
                         se = list_entry(sis->extent_list.next,
                                         struct swap_extent, list);
                         if (se->start_block == offset) {
+                                if (bdev_p)
+                                        *bdev_p = sis->bdev;
+
                                 spin_unlock(&swap_lock);
                                 bdput(bdev);
                                 return i;
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 40fea4918390..7430df68cb64 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1406,6 +1406,16 @@ static unsigned long shrink_all_zones(unsigned long nr_pages, int prio,
         return ret;
 }
 
+static unsigned long count_lru_pages(void)
+{
+        struct zone *zone;
+        unsigned long ret = 0;
+
+        for_each_zone(zone)
+                ret += zone->nr_active + zone->nr_inactive;
+        return ret;
+}
+
 /*
  * Try to free `nr_pages' of memory, system-wide, and return the number of
  * freed pages.
@@ -1420,7 +1430,6 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
         unsigned long ret = 0;
         int pass;
         struct reclaim_state reclaim_state;
-        struct zone *zone;
         struct scan_control sc = {
                 .gfp_mask = GFP_KERNEL,
                 .may_swap = 0,
@@ -1431,10 +1440,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
         current->reclaim_state = &reclaim_state;
 
-        lru_pages = 0;
-        for_each_zone(zone)
-                lru_pages += zone->nr_active + zone->nr_inactive;
-
+        lru_pages = count_lru_pages();
         nr_slab = global_page_state(NR_SLAB_RECLAIMABLE);
         /* If slab caches are huge, it's better to hit them first */
         while (nr_slab >= lru_pages) {
@@ -1461,13 +1467,6 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
         for (pass = 0; pass < 5; pass++) {
                 int prio;
 
-                /* Needed for shrinking slab caches later on */
-                if (!lru_pages)
-                        for_each_zone(zone) {
-                                lru_pages += zone->nr_active;
-                                lru_pages += zone->nr_inactive;
-                        }
-
                 /* Force reclaiming mapped pages in the passes #3 and #4 */
                 if (pass > 2) {
                         sc.may_swap = 1;
@@ -1483,7 +1482,8 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
                                 goto out;
 
                         reclaim_state.reclaimed_slab = 0;
-                        shrink_slab(sc.nr_scanned, sc.gfp_mask, lru_pages);
+                        shrink_slab(sc.nr_scanned, sc.gfp_mask,
+                                        count_lru_pages());
                         ret += reclaim_state.reclaimed_slab;
                         if (ret >= nr_pages)
                                 goto out;
@@ -1491,20 +1491,19 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
                         if (sc.nr_scanned && prio < DEF_PRIORITY - 2)
                                 congestion_wait(WRITE, HZ / 10);
                 }
-
-                lru_pages = 0;
         }
 
         /*
          * If ret = 0, we could not shrink LRUs, but there may be something
          * in slab caches
          */
-        if (!ret)
+        if (!ret) {
                 do {
                         reclaim_state.reclaimed_slab = 0;
-                        shrink_slab(nr_pages, sc.gfp_mask, lru_pages);
+                        shrink_slab(nr_pages, sc.gfp_mask, count_lru_pages());
                         ret += reclaim_state.reclaimed_slab;
                 } while (ret < nr_pages && reclaim_state.reclaimed_slab > 0);
+        }
 
 out:
         current->reclaim_state = NULL;