1 files changed, 45 insertions, 7 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 6be2068f61c8..1024979d6589 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -1212,6 +1212,7 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
         unsigned long pgscanned;
         unsigned long vm_flags;
         LIST_HEAD(l_hold);      /* The pages which were snipped off */
+        LIST_HEAD(l_active);
         LIST_HEAD(l_inactive);
         struct page *page;
         struct pagevec pvec;
@@ -1251,28 +1252,42 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
 
                 /* page_referenced clears PageReferenced */
                 if (page_mapping_inuse(page) &&
-                    page_referenced(page, 0, sc->mem_cgroup, &vm_flags))
+                    page_referenced(page, 0, sc->mem_cgroup, &vm_flags)) {
                         pgmoved++;
+                        /*
+                         * Identify referenced, file-backed active pages and
+                         * give them one more trip around the active list. So
+                         * that executable code get better chances to stay in
+                         * memory under moderate memory pressure.  Anon pages
+                         * are not likely to be evicted by use-once streaming
+                         * IO, plus JVM can create lots of anon VM_EXEC pages,
+                         * so we ignore them here.
+                         */
+                        if ((vm_flags & VM_EXEC) && !PageAnon(page)) {
+                                list_add(&page->lru, &l_active);
+                                continue;
+                        }
+                }
 
                 list_add(&page->lru, &l_inactive);
         }
 
         /*
-         * Move the pages to the [file or anon] inactive list.
+         * Move pages back to the lru list.
          */
         pagevec_init(&pvec, 1);
-        lru = LRU_BASE + file * LRU_FILE;
 
         spin_lock_irq(&zone->lru_lock);
         /*
-         * Count referenced pages from currently used mappings as
-         * rotated, even though they are moved to the inactive list.
-         * This helps balance scan pressure between file and anonymous
-         * pages in get_scan_ratio.
+         * Count referenced pages from currently used mappings as rotated,
+         * even though only some of them are actually re-activated.  This
+         * helps balance scan pressure between file and anonymous pages in
+         * get_scan_ratio.
          */
         reclaim_stat->recent_rotated[!!file] += pgmoved;
 
         pgmoved = 0;  /* count pages moved to inactive list */
+        lru = LRU_BASE + file * LRU_FILE;
         while (!list_empty(&l_inactive)) {
                 page = lru_to_page(&l_inactive);
                 prefetchw_prev_lru_page(page, &l_inactive, flags);
@@ -1295,6 +1310,29 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
         __mod_zone_page_state(zone, NR_LRU_BASE + lru, pgmoved);
         __count_zone_vm_events(PGREFILL, zone, pgscanned);
         __count_vm_events(PGDEACTIVATE, pgmoved);
+
+        pgmoved = 0;  /* count pages moved back to active list */
+        lru = LRU_ACTIVE + file * LRU_FILE;
+        while (!list_empty(&l_active)) {
+                page = lru_to_page(&l_active);
+                prefetchw_prev_lru_page(page, &l_active, flags);
+                VM_BUG_ON(PageLRU(page));
+                SetPageLRU(page);
+                VM_BUG_ON(!PageActive(page));
+
+                list_move(&page->lru, &zone->lru[lru].list);
+                mem_cgroup_add_lru_list(page, lru);
+                pgmoved++;
+                if (!pagevec_add(&pvec, page)) {
+                        spin_unlock_irq(&zone->lru_lock);
+                        if (buffer_heads_over_limit)
+                                pagevec_strip(&pvec);
+                        __pagevec_release(&pvec);
+                        spin_lock_irq(&zone->lru_lock);
+                }
+        }
+        __mod_zone_page_state(zone, NR_LRU_BASE + lru, pgmoved);
+
         spin_unlock_irq(&zone->lru_lock);
         if (buffer_heads_over_limit)
                 pagevec_strip(&pvec);