Unevictable LRU Infrastructure

When the system contains lots of mlocked or otherwise unevictable pages,
the pageout code (kswapd) can spend lots of time scanning over these
pages.  Worse still, the presence of lots of unevictable pages can confuse
kswapd into thinking that more aggressive pageout modes are required,
resulting in all kinds of bad behaviour.

Infrastructure to manage pages excluded from reclaim--i.e., hidden from
vmscan.  Based on a patch by Larry Woodman of Red Hat.  Reworked to
maintain "unevictable" pages on a separate per-zone LRU list, to "hide"
them from vmscan.

Kosaki Motohiro added the support for the memory controller unevictable
lru list.

Pages on the unevictable list have both PG_unevictable and PG_lru set.
Thus, PG_unevictable is analogous to and mutually exclusive with
PG_active--it specifies which LRU list the page is on.

The unevictable infrastructure is enabled by a new mm Kconfig option
[CONFIG_]UNEVICTABLE_LRU.

A new function 'page_evictable(page, vma)' in vmscan.c tests whether or
not a page may be evictable.  Subsequent patches will add the various
!evictable tests.  We'll want to keep these tests light-weight for use in
shrink_active_list() and, possibly, the fault path.

To avoid races between tasks putting pages [back] onto an LRU list and
tasks that might be moving the page from non-evictable to evictable state,
the new function 'putback_lru_page()' -- inverse to 'isolate_lru_page()'
-- tests the "evictability" of a page after placing it on the LRU, before
dropping the reference.  If the page has become unevictable,
putback_lru_page() will redo the 'putback', thus moving the page to the
unevictable list.  This way, we avoid "stranding" evictable pages on the
unevictable list.

[akpm@linux-foundation.org: fix fallout from out-of-order merge]
[riel@redhat.com: fix UNEVICTABLE_LRU and !PROC_PAGE_MONITOR build]
[nishimura@mxp.nes.nec.co.jp: remove redundant mapping check]
[kosaki.motohiro@jp.fujitsu.com: unevictable-lru-infrastructure: putback_lru_page()/unevictable page handling rework]
[kosaki.motohiro@jp.fujitsu.com: kill unnecessary lock_page() in vmscan.c]
[kosaki.motohiro@jp.fujitsu.com: revert migration change of unevictable lru infrastructure]
[kosaki.motohiro@jp.fujitsu.com: revert to unevictable-lru-infrastructure-kconfig-fix.patch]
[kosaki.motohiro@jp.fujitsu.com: restore patch failure of vmstat-unevictable-and-mlocked-pages-vm-events.patch]
Signed-off-by: Lee Schermerhorn <lee.schermerhorn@hp.com>
Signed-off-by: Rik van Riel <riel@redhat.com>
Signed-off-by: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Debugged-by: Benjamin Kidwell <benjkidwell@yahoo.com>
Signed-off-by: Daisuke Nishimura <nishimura@mxp.nes.nec.co.jp>
Signed-off-by: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 45 insertions, 28 deletions

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 27e9e75f4eab..82c065e7551e 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -160,9 +160,10 @@ struct page_cgroup {
         struct mem_cgroup *mem_cgroup;
         int flags;
 };
-#define PAGE_CGROUP_FLAG_CACHE  (0x1)   /* charged as cache */
-#define PAGE_CGROUP_FLAG_ACTIVE (0x2)   /* page is active in this cgroup */
-#define PAGE_CGROUP_FLAG_FILE   (0x4)   /* page is file system backed */
+#define PAGE_CGROUP_FLAG_CACHE     (0x1)        /* charged as cache */
+#define PAGE_CGROUP_FLAG_ACTIVE    (0x2)        /* page is active in this cgroup */
+#define PAGE_CGROUP_FLAG_FILE      (0x4)        /* page is file system backed */
+#define PAGE_CGROUP_FLAG_UNEVICTABLE (0x8)      /* page is unevictableable */
 
 static int page_cgroup_nid(struct page_cgroup *pc)
 {
@@ -292,10 +293,14 @@ static void __mem_cgroup_remove_list(struct mem_cgroup_per_zone *mz,
 {
         int lru = LRU_BASE;
 
-        if (pc->flags & PAGE_CGROUP_FLAG_ACTIVE)
-                lru += LRU_ACTIVE;
-        if (pc->flags & PAGE_CGROUP_FLAG_FILE)
-                lru += LRU_FILE;
+        if (pc->flags & PAGE_CGROUP_FLAG_UNEVICTABLE)
+                lru = LRU_UNEVICTABLE;
+        else {
+                if (pc->flags & PAGE_CGROUP_FLAG_ACTIVE)
+                        lru += LRU_ACTIVE;
+                if (pc->flags & PAGE_CGROUP_FLAG_FILE)
+                        lru += LRU_FILE;
+        }
 
         MEM_CGROUP_ZSTAT(mz, lru) -= 1;
 
@@ -308,10 +313,14 @@ static void __mem_cgroup_add_list(struct mem_cgroup_per_zone *mz,
 {
         int lru = LRU_BASE;
 
-        if (pc->flags & PAGE_CGROUP_FLAG_ACTIVE)
-                lru += LRU_ACTIVE;
-        if (pc->flags & PAGE_CGROUP_FLAG_FILE)
-                lru += LRU_FILE;
+        if (pc->flags & PAGE_CGROUP_FLAG_UNEVICTABLE)
+                lru = LRU_UNEVICTABLE;
+        else {
+                if (pc->flags & PAGE_CGROUP_FLAG_ACTIVE)
+                        lru += LRU_ACTIVE;
+                if (pc->flags & PAGE_CGROUP_FLAG_FILE)
+                        lru += LRU_FILE;
+        }
 
         MEM_CGROUP_ZSTAT(mz, lru) += 1;
         list_add(&pc->lru, &mz->lists[lru]);
@@ -319,21 +328,31 @@ static void __mem_cgroup_add_list(struct mem_cgroup_per_zone *mz,
         mem_cgroup_charge_statistics(pc->mem_cgroup, pc->flags, true);
 }
 
-static void __mem_cgroup_move_lists(struct page_cgroup *pc, bool active)
+static void __mem_cgroup_move_lists(struct page_cgroup *pc, enum lru_list lru)
 {
         struct mem_cgroup_per_zone *mz = page_cgroup_zoneinfo(pc);
-        int from = pc->flags & PAGE_CGROUP_FLAG_ACTIVE;
-        int file = pc->flags & PAGE_CGROUP_FLAG_FILE;
-        int lru = LRU_FILE * !!file + !!from;
+        int active    = pc->flags & PAGE_CGROUP_FLAG_ACTIVE;
+        int file      = pc->flags & PAGE_CGROUP_FLAG_FILE;
+        int unevictable = pc->flags & PAGE_CGROUP_FLAG_UNEVICTABLE;
+        enum lru_list from = unevictable ? LRU_UNEVICTABLE :
+                                (LRU_FILE * !!file + !!active);
 
-        MEM_CGROUP_ZSTAT(mz, lru) -= 1;
+        if (lru == from)
+                return;
 
-        if (active)
-                pc->flags |= PAGE_CGROUP_FLAG_ACTIVE;
-        else
+        MEM_CGROUP_ZSTAT(mz, from) -= 1;
+
+        if (is_unevictable_lru(lru)) {
                 pc->flags &= ~PAGE_CGROUP_FLAG_ACTIVE;
+                pc->flags |= PAGE_CGROUP_FLAG_UNEVICTABLE;
+        } else {
+                if (is_active_lru(lru))
+                        pc->flags |= PAGE_CGROUP_FLAG_ACTIVE;
+                else
+                        pc->flags &= ~PAGE_CGROUP_FLAG_ACTIVE;
+                pc->flags &= ~PAGE_CGROUP_FLAG_UNEVICTABLE;
+        }
 
-        lru = LRU_FILE * !!file + !!active;
         MEM_CGROUP_ZSTAT(mz, lru) += 1;
         list_move(&pc->lru, &mz->lists[lru]);
 }
@@ -351,7 +370,7 @@ int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem)
 /*
  * This routine assumes that the appropriate zone's lru lock is already held
  */
-void mem_cgroup_move_lists(struct page *page, bool active)
+void mem_cgroup_move_lists(struct page *page, enum lru_list lru)
 {
         struct page_cgroup *pc;
         struct mem_cgroup_per_zone *mz;
@@ -374,7 +393,7 @@ void mem_cgroup_move_lists(struct page *page, bool active)
         if (pc) {
                 mz = page_cgroup_zoneinfo(pc);
                 spin_lock_irqsave(&mz->lru_lock, flags);
-                __mem_cgroup_move_lists(pc, active);
+                __mem_cgroup_move_lists(pc, lru);
                 spin_unlock_irqrestore(&mz->lru_lock, flags);
         }
         unlock_page_cgroup(page);
@@ -472,12 +491,10 @@ unsigned long mem_cgroup_isolate_pages(unsigned long nr_to_scan,
                 /*
                  * TODO: play better with lumpy reclaim, grabbing anything.
                  */
-                if (PageActive(page) && !active) {
-                        __mem_cgroup_move_lists(pc, true);
-                        continue;
-                }
-                if (!PageActive(page) && active) {
-                        __mem_cgroup_move_lists(pc, false);
+                if (PageUnevictable(page) ||
+                    (PageActive(page) && !active) ||
+                    (!PageActive(page) && active)) {
+                        __mem_cgroup_move_lists(pc, page_lru(page));
                         continue;
                 }