[PATCH] temporarily disable swap token on memory pressure

Some users (hi Zwane) have seen a problem when running a workload that
eats nearly all of physical memory - th system does an OOM kill, even
when there is still a lot of swap free.

The problem appears to be a very big task that is holding the swap
token, and the VM has a very hard time finding any other page in the
system that is swappable.

Instead of ignoring the swap token when sc->priority reaches 0, we could
simply take the swap token away from the memory hog and make sure we
don't give it back to the memory hog for a few seconds.

This patch resolves the problem Zwane ran into.

Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 9 insertions, 2 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 28130541270f..078cf920208a 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -407,7 +407,7 @@ static int shrink_list(struct list_head *page_list, struct scan_control *sc)
                 if (PageWriteback(page))
                         goto keep_locked;
 
-                referenced = page_referenced(page, 1, sc->priority <= 0);
+                referenced = page_referenced(page, 1);
                 /* In active use or really unfreeable?  Activate it. */
                 if (referenced && page_mapping_inuse(page))
                         goto activate_locked;
@@ -756,7 +756,7 @@ refill_inactive_zone(struct zone *zone, struct scan_control *sc)
                 if (page_mapped(page)) {
                         if (!reclaim_mapped ||
                             (total_swap_pages == 0 && PageAnon(page)) ||
-                            page_referenced(page, 0, sc->priority <= 0)) {
+                            page_referenced(page, 0)) {
                                 list_add(&page->lru, &l_active);
                                 continue;
                         }
@@ -960,6 +960,8 @@ int try_to_free_pages(struct zone **zones, gfp_t gfp_mask)
                 sc.nr_reclaimed = 0;
                 sc.priority = priority;
                 sc.swap_cluster_max = SWAP_CLUSTER_MAX;
+                if (!priority)
+                        disable_swap_token();
                 shrink_caches(zones, &sc);
                 shrink_slab(sc.nr_scanned, gfp_mask, lru_pages);
                 if (reclaim_state) {
@@ -1056,6 +1058,10 @@ loop_again:
                 int end_zone = 0;       /* Inclusive.  0 = ZONE_DMA */
                 unsigned long lru_pages = 0;
 
+                /* The swap token gets in the way of swapout... */
+                if (!priority)
+                        disable_swap_token();
+
                 all_zones_ok = 1;
 
                 if (nr_pages == 0) {
@@ -1360,6 +1366,7 @@ int zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
         sc.nr_reclaimed = 0;
         /* scan at the highest priority */
         sc.priority = 0;
+        disable_swap_token();
 
         if (nr_pages > SWAP_CLUSTER_MAX)
                 sc.swap_cluster_max = nr_pages;