1 files changed, 39 insertions, 11 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index f90b76086ffa..208071c48bf2 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1734,7 +1734,7 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
                         if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
                                 continue;
 
-                        lru_pages += zone_lru_pages(zone);
+                        lru_pages += zone_reclaimable_pages(zone);
                 }
         }
 
@@ -1951,7 +1951,7 @@ loop_again:
                 for (i = 0; i <= end_zone; i++) {
                         struct zone *zone = pgdat->node_zones + i;
 
-                        lru_pages += zone_lru_pages(zone);
+                        lru_pages += zone_reclaimable_pages(zone);
                 }
 
                 /*
@@ -1995,7 +1995,7 @@ loop_again:
                         if (zone_is_all_unreclaimable(zone))
                                 continue;
                         if (nr_slab == 0 && zone->pages_scanned >=
-                                                (zone_lru_pages(zone) * 6))
+                                        (zone_reclaimable_pages(zone) * 6))
                                         zone_set_flag(zone,
                                                       ZONE_ALL_UNRECLAIMABLE);
                         /*
@@ -2162,12 +2162,39 @@ void wakeup_kswapd(struct zone *zone, int order)
         wake_up_interruptible(&pgdat->kswapd_wait);
 }
 
-unsigned long global_lru_pages(void)
+/*
+ * The reclaimable count would be mostly accurate.
+ * The less reclaimable pages may be
+ * - mlocked pages, which will be moved to unevictable list when encountered
+ * - mapped pages, which may require several travels to be reclaimed
+ * - dirty pages, which is not "instantly" reclaimable
+ */
+unsigned long global_reclaimable_pages(void)
 {
-        return global_page_state(NR_ACTIVE_ANON)
-                + global_page_state(NR_ACTIVE_FILE)
-                + global_page_state(NR_INACTIVE_ANON)
-                + global_page_state(NR_INACTIVE_FILE);
+        int nr;
+
+        nr = global_page_state(NR_ACTIVE_FILE) +
+             global_page_state(NR_INACTIVE_FILE);
+
+        if (nr_swap_pages > 0)
+                nr += global_page_state(NR_ACTIVE_ANON) +
+                      global_page_state(NR_INACTIVE_ANON);
+
+        return nr;
+}
+
+unsigned long zone_reclaimable_pages(struct zone *zone)
+{
+        int nr;
+
+        nr = zone_page_state(zone, NR_ACTIVE_FILE) +
+             zone_page_state(zone, NR_INACTIVE_FILE);
+
+        if (nr_swap_pages > 0)
+                nr += zone_page_state(zone, NR_ACTIVE_ANON) +
+                      zone_page_state(zone, NR_INACTIVE_ANON);
+
+        return nr;
 }
 
 #ifdef CONFIG_HIBERNATION
@@ -2239,7 +2266,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
         current->reclaim_state = &reclaim_state;
 
-        lru_pages = global_lru_pages();
+        lru_pages = global_reclaimable_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) {
@@ -2281,7 +2308,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
                         reclaim_state.reclaimed_slab = 0;
                         shrink_slab(sc.nr_scanned, sc.gfp_mask,
-                                        global_lru_pages());
+                                    global_reclaimable_pages());
                         sc.nr_reclaimed += reclaim_state.reclaimed_slab;
                         if (sc.nr_reclaimed >= nr_pages)
                                 goto out;
@@ -2298,7 +2325,8 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
         if (!sc.nr_reclaimed) {
                 do {
                         reclaim_state.reclaimed_slab = 0;
-                        shrink_slab(nr_pages, sc.gfp_mask, global_lru_pages());
+                        shrink_slab(nr_pages, sc.gfp_mask,
+                                    global_reclaimable_pages());
                         sc.nr_reclaimed += reclaim_state.reclaimed_slab;
                 } while (sc.nr_reclaimed < nr_pages &&
                                 reclaim_state.reclaimed_slab > 0);