1 files changed, 725 insertions, 266 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 1ff1a58e7c10..c141b3e78071 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -39,6 +39,7 @@
 #include <linux/freezer.h>
 #include <linux/memcontrol.h>
 #include <linux/delayacct.h>
+#include <linux/sysctl.h>
 
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
@@ -78,7 +79,7 @@ struct scan_control {
         unsigned long (*isolate_pages)(unsigned long nr, struct list_head *dst,
                         unsigned long *scanned, int order, int mode,
                         struct zone *z, struct mem_cgroup *mem_cont,
-                        int active);
+                        int active, int file);
 };
 
 #define lru_to_page(_head) (list_entry((_head)->prev, struct page, lru))
@@ -470,6 +471,85 @@ int remove_mapping(struct address_space *mapping, struct page *page)
         return 0;
 }
 
+/**
+ * putback_lru_page - put previously isolated page onto appropriate LRU list
+ * @page: page to be put back to appropriate lru list
+ *
+ * Add previously isolated @page to appropriate LRU list.
+ * Page may still be unevictable for other reasons.
+ *
+ * lru_lock must not be held, interrupts must be enabled.
+ */
+#ifdef CONFIG_UNEVICTABLE_LRU
+void putback_lru_page(struct page *page)
+{
+        int lru;
+        int active = !!TestClearPageActive(page);
+        int was_unevictable = PageUnevictable(page);
+
+        VM_BUG_ON(PageLRU(page));
+
+redo:
+        ClearPageUnevictable(page);
+
+        if (page_evictable(page, NULL)) {
+                /*
+                 * For evictable pages, we can use the cache.
+                 * In event of a race, worst case is we end up with an
+                 * unevictable page on [in]active list.
+                 * We know how to handle that.
+                 */
+                lru = active + page_is_file_cache(page);
+                lru_cache_add_lru(page, lru);
+        } else {
+                /*
+                 * Put unevictable pages directly on zone's unevictable
+                 * list.
+                 */
+                lru = LRU_UNEVICTABLE;
+                add_page_to_unevictable_list(page);
+        }
+        mem_cgroup_move_lists(page, lru);
+
+        /*
+         * page's status can change while we move it among lru. If an evictable
+         * page is on unevictable list, it never be freed. To avoid that,
+         * check after we added it to the list, again.
+         */
+        if (lru == LRU_UNEVICTABLE && page_evictable(page, NULL)) {
+                if (!isolate_lru_page(page)) {
+                        put_page(page);
+                        goto redo;
+                }
+                /* This means someone else dropped this page from LRU
+                 * So, it will be freed or putback to LRU again. There is
+                 * nothing to do here.
+                 */
+        }
+
+        if (was_unevictable && lru != LRU_UNEVICTABLE)
+                count_vm_event(UNEVICTABLE_PGRESCUED);
+        else if (!was_unevictable && lru == LRU_UNEVICTABLE)
+                count_vm_event(UNEVICTABLE_PGCULLED);
+
+        put_page(page);         /* drop ref from isolate */
+}
+
+#else /* CONFIG_UNEVICTABLE_LRU */
+
+void putback_lru_page(struct page *page)
+{
+        int lru;
+        VM_BUG_ON(PageLRU(page));
+
+        lru = !!TestClearPageActive(page) + page_is_file_cache(page);
+        lru_cache_add_lru(page, lru);
+        mem_cgroup_move_lists(page, lru);
+        put_page(page);
+}
+#endif /* CONFIG_UNEVICTABLE_LRU */
+
+
 /*
  * shrink_page_list() returns the number of reclaimed pages
  */
@@ -503,6 +583,9 @@ static unsigned long shrink_page_list(struct list_head *page_list,
 
                 sc->nr_scanned++;
 
+                if (unlikely(!page_evictable(page, NULL)))
+                        goto cull_mlocked;
+
                 if (!sc->may_swap && page_mapped(page))
                         goto keep_locked;
 
@@ -539,9 +622,19 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                  * Anonymous process memory has backing store?
                  * Try to allocate it some swap space here.
                  */
-                if (PageAnon(page) && !PageSwapCache(page))
+                if (PageAnon(page) && !PageSwapCache(page)) {
+                        switch (try_to_munlock(page)) {
+                        case SWAP_FAIL:         /* shouldn't happen */
+                        case SWAP_AGAIN:
+                                goto keep_locked;
+                        case SWAP_MLOCK:
+                                goto cull_mlocked;
+                        case SWAP_SUCCESS:
+                                ; /* fall thru'; add to swap cache */
+                        }
                         if (!add_to_swap(page, GFP_ATOMIC))
                                 goto activate_locked;
+                }
 #endif /* CONFIG_SWAP */
 
                 mapping = page_mapping(page);
@@ -556,6 +649,8 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                                 goto activate_locked;
                         case SWAP_AGAIN:
                                 goto keep_locked;
+                        case SWAP_MLOCK:
+                                goto cull_mlocked;
                         case SWAP_SUCCESS:
                                 ; /* try to free the page below */
                         }
@@ -602,7 +697,7 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                  * possible for a page to have PageDirty set, but it is actually
                  * clean (all its buffers are clean).  This happens if the
                  * buffers were written out directly, with submit_bh(). ext3
-                 * will do this, as well as the blockdev mapping. 
+                 * will do this, as well as the blockdev mapping.
                  * try_to_release_page() will discover that cleanness and will
                  * drop the buffers and mark the page clean - it can be freed.
                  *
@@ -637,7 +732,14 @@ static unsigned long shrink_page_list(struct list_head *page_list,
                 if (!mapping || !__remove_mapping(mapping, page))
                         goto keep_locked;
 
-                unlock_page(page);
+                /*
+                 * At this point, we have no other references and there is
+                 * no way to pick any more up (removed from LRU, removed
+                 * from pagecache). Can use non-atomic bitops now (and
+                 * we obviously don't have to worry about waking up a process
+                 * waiting on the page lock, because there are no references.
+                 */
+                __clear_page_locked(page);
 free_it:
                 nr_reclaimed++;
                 if (!pagevec_add(&freed_pvec, page)) {
@@ -646,14 +748,23 @@ free_it:
                 }
                 continue;
 
+cull_mlocked:
+                unlock_page(page);
+                putback_lru_page(page);
+                continue;
+
 activate_locked:
+                /* Not a candidate for swapping, so reclaim swap space. */
+                if (PageSwapCache(page) && vm_swap_full())
+                        remove_exclusive_swap_page_ref(page);
+                VM_BUG_ON(PageActive(page));
                 SetPageActive(page);
                 pgactivate++;
 keep_locked:
                 unlock_page(page);
 keep:
                 list_add(&page->lru, &ret_pages);
-                VM_BUG_ON(PageLRU(page));
+                VM_BUG_ON(PageLRU(page) || PageUnevictable(page));
         }
         list_splice(&ret_pages, page_list);
         if (pagevec_count(&freed_pvec))
@@ -677,7 +788,7 @@ keep:
  *
  * returns 0 on success, -ve errno on failure.
  */
-int __isolate_lru_page(struct page *page, int mode)
+int __isolate_lru_page(struct page *page, int mode, int file)
 {
         int ret = -EINVAL;
 
@@ -693,6 +804,17 @@ int __isolate_lru_page(struct page *page, int mode)
         if (mode != ISOLATE_BOTH && (!PageActive(page) != !mode))
                 return ret;
 
+        if (mode != ISOLATE_BOTH && (!page_is_file_cache(page) != !file))
+                return ret;
+
+        /*
+         * When this function is being called for lumpy reclaim, we
+         * initially look into all LRU pages, active, inactive and
+         * unevictable; only give shrink_page_list evictable pages.
+         */
+        if (PageUnevictable(page))
+                return ret;
+
         ret = -EBUSY;
         if (likely(get_page_unless_zero(page))) {
                 /*
@@ -723,12 +845,13 @@ int __isolate_lru_page(struct page *page, int mode)
  * @scanned:    The number of pages that were scanned.
  * @order:      The caller's attempted allocation order
  * @mode:       One of the LRU isolation modes
+ * @file:       True [1] if isolating file [!anon] pages
  *
  * returns how many pages were moved onto *@dst.
  */
 static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
                 struct list_head *src, struct list_head *dst,
-                unsigned long *scanned, int order, int mode)
+                unsigned long *scanned, int order, int mode, int file)
 {
         unsigned long nr_taken = 0;
         unsigned long scan;
@@ -745,7 +868,7 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
 
                 VM_BUG_ON(!PageLRU(page));
 
-                switch (__isolate_lru_page(page, mode)) {
+                switch (__isolate_lru_page(page, mode, file)) {
                 case 0:
                         list_move(&page->lru, dst);
                         nr_taken++;
@@ -788,10 +911,11 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
                                 break;
 
                         cursor_page = pfn_to_page(pfn);
+
                         /* Check that we have not crossed a zone boundary. */
                         if (unlikely(page_zone_id(cursor_page) != zone_id))
                                 continue;
-                        switch (__isolate_lru_page(cursor_page, mode)) {
+                        switch (__isolate_lru_page(cursor_page, mode, file)) {
                         case 0:
                                 list_move(&cursor_page->lru, dst);
                                 nr_taken++;
@@ -802,7 +926,7 @@ static unsigned long isolate_lru_pages(unsigned long nr_to_scan,
                                 /* else it is being freed elsewhere */
                                 list_move(&cursor_page->lru, src);
                         default:
-                                break;
+                                break;  /* ! on LRU or wrong list */
                         }
                 }
         }
@@ -816,40 +940,93 @@ static unsigned long isolate_pages_global(unsigned long nr,
                                         unsigned long *scanned, int order,
                                         int mode, struct zone *z,
                                         struct mem_cgroup *mem_cont,
-                                        int active)
+                                        int active, int file)
 {
+        int lru = LRU_BASE;
         if (active)
-                return isolate_lru_pages(nr, &z->active_list, dst,
-                                                scanned, order, mode);
-        else
-                return isolate_lru_pages(nr, &z->inactive_list, dst,
-                                                scanned, order, mode);
+                lru += LRU_ACTIVE;
+        if (file)
+                lru += LRU_FILE;
+        return isolate_lru_pages(nr, &z->lru[lru].list, dst, scanned, order,
+                                                                mode, !!file);
 }
 
 /*
  * clear_active_flags() is a helper for shrink_active_list(), clearing
  * any active bits from the pages in the list.
  */
-static unsigned long clear_active_flags(struct list_head *page_list)
+static unsigned long clear_active_flags(struct list_head *page_list,
+                                        unsigned int *count)
 {
         int nr_active = 0;
+        int lru;
         struct page *page;
 
-        list_for_each_entry(page, page_list, lru)
+        list_for_each_entry(page, page_list, lru) {
+                lru = page_is_file_cache(page);
                 if (PageActive(page)) {
+                        lru += LRU_ACTIVE;
                         ClearPageActive(page);
                         nr_active++;
                 }
+                count[lru]++;
+        }
 
         return nr_active;
 }
 
+/**
+ * isolate_lru_page - tries to isolate a page from its LRU list
+ * @page: page to isolate from its LRU list
+ *
+ * Isolates a @page from an LRU list, clears PageLRU and adjusts the
+ * vmstat statistic corresponding to whatever LRU list the page was on.
+ *
+ * Returns 0 if the page was removed from an LRU list.
+ * Returns -EBUSY if the page was not on an LRU list.
+ *
+ * The returned page will have PageLRU() cleared.  If it was found on
+ * the active list, it will have PageActive set.  If it was found on
+ * the unevictable list, it will have the PageUnevictable bit set. That flag
+ * may need to be cleared by the caller before letting the page go.
+ *
+ * The vmstat statistic corresponding to the list on which the page was
+ * found will be decremented.
+ *
+ * Restrictions:
+ * (1) Must be called with an elevated refcount on the page. This is a
+ *     fundamentnal difference from isolate_lru_pages (which is called
+ *     without a stable reference).
+ * (2) the lru_lock must not be held.
+ * (3) interrupts must be enabled.
+ */
+int isolate_lru_page(struct page *page)
+{
+        int ret = -EBUSY;
+
+        if (PageLRU(page)) {
+                struct zone *zone = page_zone(page);
+
+                spin_lock_irq(&zone->lru_lock);
+                if (PageLRU(page) && get_page_unless_zero(page)) {
+                        int lru = page_lru(page);
+                        ret = 0;
+                        ClearPageLRU(page);
+
+                        del_page_from_lru_list(zone, page, lru);
+                }
+                spin_unlock_irq(&zone->lru_lock);
+        }
+        return ret;
+}
+
 /*
  * shrink_inactive_list() is a helper for shrink_zone().  It returns the number
  * of reclaimed pages
  */
 static unsigned long shrink_inactive_list(unsigned long max_scan,
-                                struct zone *zone, struct scan_control *sc)
+                        struct zone *zone, struct scan_control *sc,
+                        int priority, int file)
 {
         LIST_HEAD(page_list);
         struct pagevec pvec;
@@ -866,20 +1043,43 @@ static unsigned long shrink_inactive_list(unsigned long max_scan,
                 unsigned long nr_scan;
                 unsigned long nr_freed;
                 unsigned long nr_active;
+                unsigned int count[NR_LRU_LISTS] = { 0, };
+                int mode = ISOLATE_INACTIVE;
+
+                /*
+                 * If we need a large contiguous chunk of memory, or have
+                 * trouble getting a small set of contiguous pages, we
+                 * will reclaim both active and inactive pages.
+                 *
+                 * We use the same threshold as pageout congestion_wait below.
+                 */
+                if (sc->order > PAGE_ALLOC_COSTLY_ORDER)
+                        mode = ISOLATE_BOTH;
+                else if (sc->order && priority < DEF_PRIORITY - 2)
+                        mode = ISOLATE_BOTH;
 
                 nr_taken = sc->isolate_pages(sc->swap_cluster_max,
-                             &page_list, &nr_scan, sc->order,
-                             (sc->order > PAGE_ALLOC_COSTLY_ORDER)?
-                                             ISOLATE_BOTH : ISOLATE_INACTIVE,
-                                zone, sc->mem_cgroup, 0);
-                nr_active = clear_active_flags(&page_list);
+                             &page_list, &nr_scan, sc->order, mode,
+                                zone, sc->mem_cgroup, 0, file);
+                nr_active = clear_active_flags(&page_list, count);
                 __count_vm_events(PGDEACTIVATE, nr_active);
 
-                __mod_zone_page_state(zone, NR_ACTIVE, -nr_active);
-                __mod_zone_page_state(zone, NR_INACTIVE,
-                                                -(nr_taken - nr_active));
-                if (scan_global_lru(sc))
+                __mod_zone_page_state(zone, NR_ACTIVE_FILE,
+                                                -count[LRU_ACTIVE_FILE]);
+                __mod_zone_page_state(zone, NR_INACTIVE_FILE,
+                                                -count[LRU_INACTIVE_FILE]);
+                __mod_zone_page_state(zone, NR_ACTIVE_ANON,
+                                                -count[LRU_ACTIVE_ANON]);
+                __mod_zone_page_state(zone, NR_INACTIVE_ANON,
+                                                -count[LRU_INACTIVE_ANON]);
+
+                if (scan_global_lru(sc)) {
                         zone->pages_scanned += nr_scan;
+                        zone->recent_scanned[0] += count[LRU_INACTIVE_ANON];
+                        zone->recent_scanned[0] += count[LRU_ACTIVE_ANON];
+                        zone->recent_scanned[1] += count[LRU_INACTIVE_FILE];
+                        zone->recent_scanned[1] += count[LRU_ACTIVE_FILE];
+                }
                 spin_unlock_irq(&zone->lru_lock);
 
                 nr_scanned += nr_scan;
@@ -899,7 +1099,7 @@ static unsigned long shrink_inactive_list(unsigned long max_scan,
                          * The attempt at page out may have made some
                          * of the pages active, mark them inactive again.
                          */
-                        nr_active = clear_active_flags(&page_list);
+                        nr_active = clear_active_flags(&page_list, count);
                         count_vm_events(PGDEACTIVATE, nr_active);
 
                         nr_freed += shrink_page_list(&page_list, sc,
@@ -924,14 +1124,24 @@ static unsigned long shrink_inactive_list(unsigned long max_scan,
                  * Put back any unfreeable pages.
                  */
                 while (!list_empty(&page_list)) {
+                        int lru;
                         page = lru_to_page(&page_list);
                         VM_BUG_ON(PageLRU(page));
-                        SetPageLRU(page);
                         list_del(&page->lru);
-                        if (PageActive(page))
-                                add_page_to_active_list(zone, page);
-                        else
-                                add_page_to_inactive_list(zone, page);
+                        if (unlikely(!page_evictable(page, NULL))) {
+                                spin_unlock_irq(&zone->lru_lock);
+                                putback_lru_page(page);
+                                spin_lock_irq(&zone->lru_lock);
+                                continue;
+                        }
+                        SetPageLRU(page);
+                        lru = page_lru(page);
+                        add_page_to_lru_list(zone, page, lru);
+                        mem_cgroup_move_lists(page, lru);
+                        if (PageActive(page) && scan_global_lru(sc)) {
+                                int file = !!page_is_file_cache(page);
+                                zone->recent_rotated[file]++;
+                        }
                         if (!pagevec_add(&pvec, page)) {
                                 spin_unlock_irq(&zone->lru_lock);
                                 __pagevec_release(&pvec);
@@ -962,115 +1172,7 @@ static inline void note_zone_scanning_priority(struct zone *zone, int priority)
 
 static inline int zone_is_near_oom(struct zone *zone)
 {
-        return zone->pages_scanned >= (zone_page_state(zone, NR_ACTIVE)
-                                + zone_page_state(zone, NR_INACTIVE))*3;
-}
-
-/*
- * Determine we should try to reclaim mapped pages.
- * This is called only when sc->mem_cgroup is NULL.
- */
-static int calc_reclaim_mapped(struct scan_control *sc, struct zone *zone,
-                                int priority)
-{
-        long mapped_ratio;
-        long distress;
-        long swap_tendency;
-        long imbalance;
-        int reclaim_mapped = 0;
-        int prev_priority;
-
-        if (scan_global_lru(sc) && zone_is_near_oom(zone))
-                return 1;
-        /*
-         * `distress' is a measure of how much trouble we're having
-         * reclaiming pages.  0 -> no problems.  100 -> great trouble.
-         */
-        if (scan_global_lru(sc))
-                prev_priority = zone->prev_priority;
-        else
-                prev_priority = mem_cgroup_get_reclaim_priority(sc->mem_cgroup);
-
-        distress = 100 >> min(prev_priority, priority);
-
-        /*
-         * The point of this algorithm is to decide when to start
-         * reclaiming mapped memory instead of just pagecache.  Work out
-         * how much memory
-         * is mapped.
-         */
-        if (scan_global_lru(sc))
-                mapped_ratio = ((global_page_state(NR_FILE_MAPPED) +
-                                global_page_state(NR_ANON_PAGES)) * 100) /
-                                        vm_total_pages;
-        else
-                mapped_ratio = mem_cgroup_calc_mapped_ratio(sc->mem_cgroup);
-
-        /*
-         * Now decide how much we really want to unmap some pages.  The
-         * mapped ratio is downgraded - just because there's a lot of
-         * mapped memory doesn't necessarily mean that page reclaim
-         * isn't succeeding.
-         *
-         * The distress ratio is important - we don't want to start
-         * going oom.
-         *
-         * A 100% value of vm_swappiness overrides this algorithm
-         * altogether.
-         */
-        swap_tendency = mapped_ratio / 2 + distress + sc->swappiness;
-
-        /*
-         * If there's huge imbalance between active and inactive
-         * (think active 100 times larger than inactive) we should
-         * become more permissive, or the system will take too much
-         * cpu before it start swapping during memory pressure.
-         * Distress is about avoiding early-oom, this is about
-         * making swappiness graceful despite setting it to low
-         * values.
-         *
-         * Avoid div by zero with nr_inactive+1, and max resulting
-         * value is vm_total_pages.
-         */
-        if (scan_global_lru(sc)) {
-                imbalance  = zone_page_state(zone, NR_ACTIVE);
-                imbalance /= zone_page_state(zone, NR_INACTIVE) + 1;
-        } else
-                imbalance = mem_cgroup_reclaim_imbalance(sc->mem_cgroup);
-
-        /*
-         * Reduce the effect of imbalance if swappiness is low,
-         * this means for a swappiness very low, the imbalance
-         * must be much higher than 100 for this logic to make
-         * the difference.
-         *
-         * Max temporary value is vm_total_pages*100.
-         */
-        imbalance *= (vm_swappiness + 1);
-        imbalance /= 100;
-
-        /*
-         * If not much of the ram is mapped, makes the imbalance
-         * less relevant, it's high priority we refill the inactive
-         * list with mapped pages only in presence of high ratio of
-         * mapped pages.
-         *
-         * Max temporary value is vm_total_pages*100.
-         */
-        imbalance *= mapped_ratio;
-        imbalance /= 100;
-
-        /* apply imbalance feedback to swap_tendency */
-        swap_tendency += imbalance;
-
-        /*
-         * Now use this metric to decide whether to start moving mapped
-         * memory onto the inactive list.
-         */
-        if (swap_tendency >= 100)
-                reclaim_mapped = 1;
-
-        return reclaim_mapped;
+        return zone->pages_scanned >= (zone_lru_pages(zone) * 3);
 }
 
 /*
@@ -1093,53 +1195,71 @@ static int calc_reclaim_mapped(struct scan_control *sc, struct zone *zone,
 
 
 static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
-                                struct scan_control *sc, int priority)
+                        struct scan_control *sc, int priority, int file)
 {
         unsigned long pgmoved;
         int pgdeactivate = 0;
         unsigned long pgscanned;
         LIST_HEAD(l_hold);      /* The pages which were snipped off */
-        LIST_HEAD(l_inactive);  /* Pages to go onto the inactive_list */
-        LIST_HEAD(l_active);    /* Pages to go onto the active_list */
+        LIST_HEAD(l_inactive);
         struct page *page;
         struct pagevec pvec;
-        int reclaim_mapped = 0;
-
-        if (sc->may_swap)
-                reclaim_mapped = calc_reclaim_mapped(sc, zone, priority);
+        enum lru_list lru;
 
         lru_add_drain();
         spin_lock_irq(&zone->lru_lock);
         pgmoved = sc->isolate_pages(nr_pages, &l_hold, &pgscanned, sc->order,
                                         ISOLATE_ACTIVE, zone,
-                                        sc->mem_cgroup, 1);
+                                        sc->mem_cgroup, 1, file);
         /*
          * zone->pages_scanned is used for detect zone's oom
          * mem_cgroup remembers nr_scan by itself.
          */
-        if (scan_global_lru(sc))
+        if (scan_global_lru(sc)) {
                 zone->pages_scanned += pgscanned;
+                zone->recent_scanned[!!file] += pgmoved;
+        }
 
-        __mod_zone_page_state(zone, NR_ACTIVE, -pgmoved);
+        if (file)
+                __mod_zone_page_state(zone, NR_ACTIVE_FILE, -pgmoved);
+        else
+                __mod_zone_page_state(zone, NR_ACTIVE_ANON, -pgmoved);
         spin_unlock_irq(&zone->lru_lock);
 
+        pgmoved = 0;
         while (!list_empty(&l_hold)) {
                 cond_resched();
                 page = lru_to_page(&l_hold);
                 list_del(&page->lru);
-                if (page_mapped(page)) {
-                        if (!reclaim_mapped ||
-                            (total_swap_pages == 0 && PageAnon(page)) ||
-                            page_referenced(page, 0, sc->mem_cgroup)) {
-                                list_add(&page->lru, &l_active);
-                                continue;
-                        }
+
+                if (unlikely(!page_evictable(page, NULL))) {
+                        putback_lru_page(page);
+                        continue;
                 }
+
+                /* page_referenced clears PageReferenced */
+                if (page_mapping_inuse(page) &&
+                    page_referenced(page, 0, sc->mem_cgroup))
+                        pgmoved++;
+
                 list_add(&page->lru, &l_inactive);
         }
 
+        /*
+         * 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.
+         */
+        zone->recent_rotated[!!file] += pgmoved;
+
+        /*
+         * Move the pages to the [file or anon] inactive list.
+         */
         pagevec_init(&pvec, 1);
+
         pgmoved = 0;
+        lru = LRU_BASE + file * LRU_FILE;
         spin_lock_irq(&zone->lru_lock);
         while (!list_empty(&l_inactive)) {
                 page = lru_to_page(&l_inactive);
@@ -1149,11 +1269,11 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
                 VM_BUG_ON(!PageActive(page));
                 ClearPageActive(page);
 
-                list_move(&page->lru, &zone->inactive_list);
-                mem_cgroup_move_lists(page, false);
+                list_move(&page->lru, &zone->lru[lru].list);
+                mem_cgroup_move_lists(page, lru);
                 pgmoved++;
                 if (!pagevec_add(&pvec, page)) {
-                        __mod_zone_page_state(zone, NR_INACTIVE, pgmoved);
+                        __mod_zone_page_state(zone, NR_LRU_BASE + lru, pgmoved);
                         spin_unlock_irq(&zone->lru_lock);
                         pgdeactivate += pgmoved;
                         pgmoved = 0;
@@ -1163,104 +1283,189 @@ static void shrink_active_list(unsigned long nr_pages, struct zone *zone,
                         spin_lock_irq(&zone->lru_lock);
                 }
         }
-        __mod_zone_page_state(zone, NR_INACTIVE, pgmoved);
+        __mod_zone_page_state(zone, NR_LRU_BASE + lru, pgmoved);
         pgdeactivate += pgmoved;
         if (buffer_heads_over_limit) {
                 spin_unlock_irq(&zone->lru_lock);
                 pagevec_strip(&pvec);
                 spin_lock_irq(&zone->lru_lock);
         }
-
-        pgmoved = 0;
-        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->active_list);
-                mem_cgroup_move_lists(page, true);
-                pgmoved++;
-                if (!pagevec_add(&pvec, page)) {
-                        __mod_zone_page_state(zone, NR_ACTIVE, pgmoved);
-                        pgmoved = 0;
-                        spin_unlock_irq(&zone->lru_lock);
-                        __pagevec_release(&pvec);
-                        spin_lock_irq(&zone->lru_lock);
-                }
-        }
-        __mod_zone_page_state(zone, NR_ACTIVE, pgmoved);
-
         __count_zone_vm_events(PGREFILL, zone, pgscanned);
         __count_vm_events(PGDEACTIVATE, pgdeactivate);
         spin_unlock_irq(&zone->lru_lock);
+        if (vm_swap_full())
+                pagevec_swap_free(&pvec);
 
         pagevec_release(&pvec);
 }
 
+static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
+        struct zone *zone, struct scan_control *sc, int priority)
+{
+        int file = is_file_lru(lru);
+
+        if (lru == LRU_ACTIVE_FILE) {
+                shrink_active_list(nr_to_scan, zone, sc, priority, file);
+                return 0;
+        }
+
+        if (lru == LRU_ACTIVE_ANON &&
+            (!scan_global_lru(sc) || inactive_anon_is_low(zone))) {
+                shrink_active_list(nr_to_scan, zone, sc, priority, file);
+                return 0;
+        }
+        return shrink_inactive_list(nr_to_scan, zone, sc, priority, file);
+}
+
+/*
+ * Determine how aggressively the anon and file LRU lists should be
+ * scanned.  The relative value of each set of LRU lists is determined
+ * by looking at the fraction of the pages scanned we did rotate back
+ * onto the active list instead of evict.
+ *
+ * percent[0] specifies how much pressure to put on ram/swap backed
+ * memory, while percent[1] determines pressure on the file LRUs.
+ */
+static void get_scan_ratio(struct zone *zone, struct scan_control *sc,
+                                        unsigned long *percent)
+{
+        unsigned long anon, file, free;
+        unsigned long anon_prio, file_prio;
+        unsigned long ap, fp;
+
+        anon  = zone_page_state(zone, NR_ACTIVE_ANON) +
+                zone_page_state(zone, NR_INACTIVE_ANON);
+        file  = zone_page_state(zone, NR_ACTIVE_FILE) +
+                zone_page_state(zone, NR_INACTIVE_FILE);
+        free  = zone_page_state(zone, NR_FREE_PAGES);
+
+        /* If we have no swap space, do not bother scanning anon pages. */
+        if (nr_swap_pages <= 0) {
+                percent[0] = 0;
+                percent[1] = 100;
+                return;
+        }
+
+        /* If we have very few page cache pages, force-scan anon pages. */
+        if (unlikely(file + free <= zone->pages_high)) {
+                percent[0] = 100;
+                percent[1] = 0;
+                return;
+        }
+
+        /*
+         * OK, so we have swap space and a fair amount of page cache
+         * pages.  We use the recently rotated / recently scanned
+         * ratios to determine how valuable each cache is.
+         *
+         * Because workloads change over time (and to avoid overflow)
+         * we keep these statistics as a floating average, which ends
+         * up weighing recent references more than old ones.
+         *
+         * anon in [0], file in [1]
+         */
+        if (unlikely(zone->recent_scanned[0] > anon / 4)) {
+                spin_lock_irq(&zone->lru_lock);
+                zone->recent_scanned[0] /= 2;
+                zone->recent_rotated[0] /= 2;
+                spin_unlock_irq(&zone->lru_lock);
+        }
+
+        if (unlikely(zone->recent_scanned[1] > file / 4)) {
+                spin_lock_irq(&zone->lru_lock);
+                zone->recent_scanned[1] /= 2;
+                zone->recent_rotated[1] /= 2;
+                spin_unlock_irq(&zone->lru_lock);
+        }
+
+        /*
+         * With swappiness at 100, anonymous and file have the same priority.
+         * This scanning priority is essentially the inverse of IO cost.
+         */
+        anon_prio = sc->swappiness;
+        file_prio = 200 - sc->swappiness;
+
+        /*
+         *                  anon       recent_rotated[0]
+         * %anon = 100 * ----------- / ----------------- * IO cost
+         *               anon + file      rotate_sum
+         */
+        ap = (anon_prio + 1) * (zone->recent_scanned[0] + 1);
+        ap /= zone->recent_rotated[0] + 1;
+
+        fp = (file_prio + 1) * (zone->recent_scanned[1] + 1);
+        fp /= zone->recent_rotated[1] + 1;
+
+        /* Normalize to percentages */
+        percent[0] = 100 * ap / (ap + fp + 1);
+        percent[1] = 100 - percent[0];
+}
+
+
 /*
  * This is a basic per-zone page freer.  Used by both kswapd and direct reclaim.
  */
 static unsigned long shrink_zone(int priority, struct zone *zone,
                                 struct scan_control *sc)
 {
-        unsigned long nr_active;
-        unsigned long nr_inactive;
+        unsigned long nr[NR_LRU_LISTS];
         unsigned long nr_to_scan;
         unsigned long nr_reclaimed = 0;
+        unsigned long percent[2];       /* anon @ 0; file @ 1 */
+        enum lru_list l;
 
-        if (scan_global_lru(sc)) {
-                /*
-                 * Add one to nr_to_scan just to make sure that the kernel
-                 * will slowly sift through the active list.
-                 */
-                zone->nr_scan_active +=
-                        (zone_page_state(zone, NR_ACTIVE) >> priority) + 1;
-                nr_active = zone->nr_scan_active;
-                zone->nr_scan_inactive +=
-                        (zone_page_state(zone, NR_INACTIVE) >> priority) + 1;
-                nr_inactive = zone->nr_scan_inactive;
-                if (nr_inactive >= sc->swap_cluster_max)
-                        zone->nr_scan_inactive = 0;
-                else
-                        nr_inactive = 0;
-
-                if (nr_active >= sc->swap_cluster_max)
-                        zone->nr_scan_active = 0;
-                else
-                        nr_active = 0;
-        } else {
-                /*
-                 * This reclaim occurs not because zone memory shortage but
-                 * because memory controller hits its limit.
-                 * Then, don't modify zone reclaim related data.
-                 */
-                nr_active = mem_cgroup_calc_reclaim_active(sc->mem_cgroup,
-                                        zone, priority);
-
-                nr_inactive = mem_cgroup_calc_reclaim_inactive(sc->mem_cgroup,
-                                        zone, priority);
-        }
+        get_scan_ratio(zone, sc, percent);
 
+        for_each_evictable_lru(l) {
+                if (scan_global_lru(sc)) {
+                        int file = is_file_lru(l);
+                        int scan;
 
-        while (nr_active || nr_inactive) {
-                if (nr_active) {
-                        nr_to_scan = min(nr_active,
-                                        (unsigned long)sc->swap_cluster_max);
-                        nr_active -= nr_to_scan;
-                        shrink_active_list(nr_to_scan, zone, sc, priority);
+                        scan = zone_page_state(zone, NR_LRU_BASE + l);
+                        if (priority) {
+                                scan >>= priority;
+                                scan = (scan * percent[file]) / 100;
+                        }
+                        zone->lru[l].nr_scan += scan;
+                        nr[l] = zone->lru[l].nr_scan;
+                        if (nr[l] >= sc->swap_cluster_max)
+                                zone->lru[l].nr_scan = 0;
+                        else
+                                nr[l] = 0;
+                } else {
+                        /*
+                         * This reclaim occurs not because zone memory shortage
+                         * but because memory controller hits its limit.
+                         * Don't modify zone reclaim related data.
+                         */
+                        nr[l] = mem_cgroup_calc_reclaim(sc->mem_cgroup, zone,
+                                                                priority, l);
                 }
+        }
 
-                if (nr_inactive) {
-                        nr_to_scan = min(nr_inactive,
+        while (nr[LRU_INACTIVE_ANON] || nr[LRU_ACTIVE_FILE] ||
+                                        nr[LRU_INACTIVE_FILE]) {
+                for_each_evictable_lru(l) {
+                        if (nr[l]) {
+                                nr_to_scan = min(nr[l],
                                         (unsigned long)sc->swap_cluster_max);
-                        nr_inactive -= nr_to_scan;
-                        nr_reclaimed += shrink_inactive_list(nr_to_scan, zone,
-                                                                sc);
+                                nr[l] -= nr_to_scan;
+
+                                nr_reclaimed += shrink_list(l, nr_to_scan,
+                                                        zone, sc, priority);
+                        }
                 }
         }
 
+        /*
+         * Even if we did not try to evict anon pages at all, we want to
+         * rebalance the anon lru active/inactive ratio.
+         */
+        if (!scan_global_lru(sc) || inactive_anon_is_low(zone))
+                shrink_active_list(SWAP_CLUSTER_MAX, zone, sc, priority, 0);
+        else if (!scan_global_lru(sc))
+                shrink_active_list(SWAP_CLUSTER_MAX, zone, sc, priority, 0);
+
         throttle_vm_writeout(sc->gfp_mask);
         return nr_reclaimed;
 }
@@ -1321,7 +1526,7 @@ static unsigned long shrink_zones(int priority, struct zonelist *zonelist,
 
         return nr_reclaimed;
 }
- 
+
 /*
  * This is the main entry point to direct page reclaim.
  *
@@ -1364,8 +1569,7 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
                         if (!cpuset_zone_allowed_hardwall(zone, GFP_KERNEL))
                                 continue;
 
-                        lru_pages += zone_page_state(zone, NR_ACTIVE)
-                                        + zone_page_state(zone, NR_INACTIVE);
+                        lru_pages += zone_lru_pages(zone);
                 }
         }
 
@@ -1555,6 +1759,14 @@ loop_again:
                             priority != DEF_PRIORITY)
                                 continue;
 
+                        /*
+                         * Do some background aging of the anon list, to give
+                         * pages a chance to be referenced before reclaiming.
+                         */
+                        if (inactive_anon_is_low(zone))
+                                shrink_active_list(SWAP_CLUSTER_MAX, zone,
+                                                        &sc, priority, 0);
+
                         if (!zone_watermark_ok(zone, order, zone->pages_high,
                                                0, 0)) {
                                 end_zone = i;
@@ -1567,8 +1779,7 @@ loop_again:
                 for (i = 0; i <= end_zone; i++) {
                         struct zone *zone = pgdat->node_zones + i;
 
-                        lru_pages += zone_page_state(zone, NR_ACTIVE)
-                                        + zone_page_state(zone, NR_INACTIVE);
+                        lru_pages += zone_lru_pages(zone);
                 }
 
                 /*
@@ -1612,8 +1823,7 @@ loop_again:
                         if (zone_is_all_unreclaimable(zone))
                                 continue;
                         if (nr_slab == 0 && zone->pages_scanned >=
-                                (zone_page_state(zone, NR_ACTIVE)
-                                + zone_page_state(zone, NR_INACTIVE)) * 6)
+                                                (zone_lru_pages(zone) * 6))
                                         zone_set_flag(zone,
                                                       ZONE_ALL_UNRECLAIMABLE);
                         /*
@@ -1667,7 +1877,7 @@ out:
 
 /*
  * The background pageout daemon, started as a kernel thread
- * from the init process. 
+ * from the init process.
  *
  * This basically trickles out pages so that we have _some_
  * free memory available even if there is no other activity
@@ -1761,6 +1971,14 @@ void wakeup_kswapd(struct zone *zone, int order)
         wake_up_interruptible(&pgdat->kswapd_wait);
 }
 
+unsigned long global_lru_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);
+}
+
 #ifdef CONFIG_PM
 /*
  * Helper function for shrink_all_memory().  Tries to reclaim 'nr_pages' pages
@@ -1774,6 +1992,7 @@ static unsigned long shrink_all_zones(unsigned long nr_pages, int prio,
 {
         struct zone *zone;
         unsigned long nr_to_scan, ret = 0;
+        enum lru_list l;
 
         for_each_zone(zone) {
 
@@ -1783,38 +2002,31 @@ static unsigned long shrink_all_zones(unsigned long nr_pages, int prio,
                 if (zone_is_all_unreclaimable(zone) && prio != DEF_PRIORITY)
                         continue;
 
-                /* For pass = 0 we don't shrink the active list */
-                if (pass > 0) {
-                        zone->nr_scan_active +=
-                                (zone_page_state(zone, NR_ACTIVE) >> prio) + 1;
-                        if (zone->nr_scan_active >= nr_pages || pass > 3) {
-                                zone->nr_scan_active = 0;
+                for_each_evictable_lru(l) {
+                        /* For pass = 0, we don't shrink the active list */
+                        if (pass == 0 &&
+                                (l == LRU_ACTIVE || l == LRU_ACTIVE_FILE))
+                                continue;
+
+                        zone->lru[l].nr_scan +=
+                                (zone_page_state(zone, NR_LRU_BASE + l)
+                                                                >> prio) + 1;
+                        if (zone->lru[l].nr_scan >= nr_pages || pass > 3) {
+                                zone->lru[l].nr_scan = 0;
                                 nr_to_scan = min(nr_pages,
-                                        zone_page_state(zone, NR_ACTIVE));
-                                shrink_active_list(nr_to_scan, zone, sc, prio);
+                                        zone_page_state(zone,
+                                                        NR_LRU_BASE + l));
+                                ret += shrink_list(l, nr_to_scan, zone,
+                                                                sc, prio);
+                                if (ret >= nr_pages)
+                                        return ret;
                         }
                 }
-
-                zone->nr_scan_inactive +=
-                        (zone_page_state(zone, NR_INACTIVE) >> prio) + 1;
-                if (zone->nr_scan_inactive >= nr_pages || pass > 3) {
-                        zone->nr_scan_inactive = 0;
-                        nr_to_scan = min(nr_pages,
-                                zone_page_state(zone, NR_INACTIVE));
-                        ret += shrink_inactive_list(nr_to_scan, zone, sc);
-                        if (ret >= nr_pages)
-                                return ret;
-                }
         }
 
         return ret;
 }
 
-static unsigned long count_lru_pages(void)
-{
-        return global_page_state(NR_ACTIVE) + global_page_state(NR_INACTIVE);
-}
-
 /*
  * Try to free `nr_pages' of memory, system-wide, and return the number of
  * freed pages.
@@ -1840,7 +2052,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
         current->reclaim_state = &reclaim_state;
 
-        lru_pages = count_lru_pages();
+        lru_pages = global_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) {
@@ -1883,7 +2095,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
 
                         reclaim_state.reclaimed_slab = 0;
                         shrink_slab(sc.nr_scanned, sc.gfp_mask,
-                                        count_lru_pages());
+                                        global_lru_pages());
                         ret += reclaim_state.reclaimed_slab;
                         if (ret >= nr_pages)
                                 goto out;
@@ -1900,7 +2112,7 @@ unsigned long shrink_all_memory(unsigned long nr_pages)
         if (!ret) {
                 do {
                         reclaim_state.reclaimed_slab = 0;
-                        shrink_slab(nr_pages, sc.gfp_mask, count_lru_pages());
+                        shrink_slab(nr_pages, sc.gfp_mask, global_lru_pages());
                         ret += reclaim_state.reclaimed_slab;
                 } while (ret < nr_pages && reclaim_state.reclaimed_slab > 0);
         }
@@ -2128,3 +2340,250 @@ int zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
         return ret;
 }
 #endif
+
+#ifdef CONFIG_UNEVICTABLE_LRU
+/*
+ * page_evictable - test whether a page is evictable
+ * @page: the page to test
+ * @vma: the VMA in which the page is or will be mapped, may be NULL
+ *
+ * Test whether page is evictable--i.e., should be placed on active/inactive
+ * lists vs unevictable list.  The vma argument is !NULL when called from the
+ * fault path to determine how to instantate a new page.
+ *
+ * Reasons page might not be evictable:
+ * (1) page's mapping marked unevictable
+ * (2) page is part of an mlocked VMA
+ *
+ */
+int page_evictable(struct page *page, struct vm_area_struct *vma)
+{
+
+        if (mapping_unevictable(page_mapping(page)))
+                return 0;
+
+        if (PageMlocked(page) || (vma && is_mlocked_vma(vma, page)))
+                return 0;
+
+        return 1;
+}
+
+/**
+ * check_move_unevictable_page - check page for evictability and move to appropriate zone lru list
+ * @page: page to check evictability and move to appropriate lru list
+ * @zone: zone page is in
+ *
+ * Checks a page for evictability and moves the page to the appropriate
+ * zone lru list.
+ *
+ * Restrictions: zone->lru_lock must be held, page must be on LRU and must
+ * have PageUnevictable set.
+ */
+static void check_move_unevictable_page(struct page *page, struct zone *zone)
+{
+        VM_BUG_ON(PageActive(page));
+
+retry:
+        ClearPageUnevictable(page);
+        if (page_evictable(page, NULL)) {
+                enum lru_list l = LRU_INACTIVE_ANON + page_is_file_cache(page);
+
+                __dec_zone_state(zone, NR_UNEVICTABLE);
+                list_move(&page->lru, &zone->lru[l].list);
+                __inc_zone_state(zone, NR_INACTIVE_ANON + l);
+                __count_vm_event(UNEVICTABLE_PGRESCUED);
+        } else {
+                /*
+                 * rotate unevictable list
+                 */
+                SetPageUnevictable(page);
+                list_move(&page->lru, &zone->lru[LRU_UNEVICTABLE].list);
+                if (page_evictable(page, NULL))
+                        goto retry;
+        }
+}
+
+/**
+ * scan_mapping_unevictable_pages - scan an address space for evictable pages
+ * @mapping: struct address_space to scan for evictable pages
+ *
+ * Scan all pages in mapping.  Check unevictable pages for
+ * evictability and move them to the appropriate zone lru list.
+ */
+void scan_mapping_unevictable_pages(struct address_space *mapping)
+{
+        pgoff_t next = 0;
+        pgoff_t end   = (i_size_read(mapping->host) + PAGE_CACHE_SIZE - 1) >>
+                         PAGE_CACHE_SHIFT;
+        struct zone *zone;
+        struct pagevec pvec;
+
+        if (mapping->nrpages == 0)
+                return;
+
+        pagevec_init(&pvec, 0);
+        while (next < end &&
+                pagevec_lookup(&pvec, mapping, next, PAGEVEC_SIZE)) {
+                int i;
+                int pg_scanned = 0;
+
+                zone = NULL;
+
+                for (i = 0; i < pagevec_count(&pvec); i++) {
+                        struct page *page = pvec.pages[i];
+                        pgoff_t page_index = page->index;
+                        struct zone *pagezone = page_zone(page);
+
+                        pg_scanned++;
+                        if (page_index > next)
+                                next = page_index;
+                        next++;
+
+                        if (pagezone != zone) {
+                                if (zone)
+                                        spin_unlock_irq(&zone->lru_lock);
+                                zone = pagezone;
+                                spin_lock_irq(&zone->lru_lock);
+                        }
+
+                        if (PageLRU(page) && PageUnevictable(page))
+                                check_move_unevictable_page(page, zone);
+                }
+                if (zone)
+                        spin_unlock_irq(&zone->lru_lock);
+                pagevec_release(&pvec);
+
+                count_vm_events(UNEVICTABLE_PGSCANNED, pg_scanned);
+        }
+
+}
+
+/**
+ * scan_zone_unevictable_pages - check unevictable list for evictable pages
+ * @zone - zone of which to scan the unevictable list
+ *
+ * Scan @zone's unevictable LRU lists to check for pages that have become
+ * evictable.  Move those that have to @zone's inactive list where they
+ * become candidates for reclaim, unless shrink_inactive_zone() decides
+ * to reactivate them.  Pages that are still unevictable are rotated
+ * back onto @zone's unevictable list.
+ */
+#define SCAN_UNEVICTABLE_BATCH_SIZE 16UL /* arbitrary lock hold batch size */
+void scan_zone_unevictable_pages(struct zone *zone)
+{
+        struct list_head *l_unevictable = &zone->lru[LRU_UNEVICTABLE].list;
+        unsigned long scan;
+        unsigned long nr_to_scan = zone_page_state(zone, NR_UNEVICTABLE);
+
+        while (nr_to_scan > 0) {
+                unsigned long batch_size = min(nr_to_scan,
+                                                SCAN_UNEVICTABLE_BATCH_SIZE);
+
+                spin_lock_irq(&zone->lru_lock);
+                for (scan = 0;  scan < batch_size; scan++) {
+                        struct page *page = lru_to_page(l_unevictable);
+
+                        if (!trylock_page(page))
+                                continue;
+
+                        prefetchw_prev_lru_page(page, l_unevictable, flags);
+
+                        if (likely(PageLRU(page) && PageUnevictable(page)))
+                                check_move_unevictable_page(page, zone);
+
+                        unlock_page(page);
+                }
+                spin_unlock_irq(&zone->lru_lock);
+
+                nr_to_scan -= batch_size;
+        }
+}
+
+
+/**
+ * scan_all_zones_unevictable_pages - scan all unevictable lists for evictable pages
+ *
+ * A really big hammer:  scan all zones' unevictable LRU lists to check for
+ * pages that have become evictable.  Move those back to the zones'
+ * inactive list where they become candidates for reclaim.
+ * This occurs when, e.g., we have unswappable pages on the unevictable lists,
+ * and we add swap to the system.  As such, it runs in the context of a task
+ * that has possibly/probably made some previously unevictable pages
+ * evictable.
+ */
+void scan_all_zones_unevictable_pages(void)
+{
+        struct zone *zone;
+
+        for_each_zone(zone) {
+                scan_zone_unevictable_pages(zone);
+        }
+}
+
+/*
+ * scan_unevictable_pages [vm] sysctl handler.  On demand re-scan of
+ * all nodes' unevictable lists for evictable pages
+ */
+unsigned long scan_unevictable_pages;
+
+int scan_unevictable_handler(struct ctl_table *table, int write,
+                           struct file *file, void __user *buffer,
+                           size_t *length, loff_t *ppos)
+{
+        proc_doulongvec_minmax(table, write, file, buffer, length, ppos);
+
+        if (write && *(unsigned long *)table->data)
+                scan_all_zones_unevictable_pages();
+
+        scan_unevictable_pages = 0;
+        return 0;
+}
+
+/*
+ * per node 'scan_unevictable_pages' attribute.  On demand re-scan of
+ * a specified node's per zone unevictable lists for evictable pages.
+ */
+
+static ssize_t read_scan_unevictable_node(struct sys_device *dev,
+                                          struct sysdev_attribute *attr,
+                                          char *buf)
+{
+        return sprintf(buf, "0\n");     /* always zero; should fit... */
+}
+
+static ssize_t write_scan_unevictable_node(struct sys_device *dev,
+                                           struct sysdev_attribute *attr,
+                                        const char *buf, size_t count)
+{
+        struct zone *node_zones = NODE_DATA(dev->id)->node_zones;
+        struct zone *zone;
+        unsigned long res;
+        unsigned long req = strict_strtoul(buf, 10, &res);
+
+        if (!req)
+                return 1;       /* zero is no-op */
+
+        for (zone = node_zones; zone - node_zones < MAX_NR_ZONES; ++zone) {
+                if (!populated_zone(zone))
+                        continue;
+                scan_zone_unevictable_pages(zone);
+        }
+        return 1;
+}
+
+
+static SYSDEV_ATTR(scan_unevictable_pages, S_IRUGO | S_IWUSR,
+                        read_scan_unevictable_node,
+                        write_scan_unevictable_node);
+
+int scan_unevictable_register_node(struct node *node)
+{
+        return sysdev_create_file(&node->sysdev, &attr_scan_unevictable_pages);
+}
+
+void scan_unevictable_unregister_node(struct node *node)
+{
+        sysdev_remove_file(&node->sysdev, &attr_scan_unevictable_pages);
+}
+
+#endif