workqueue: use new hashtable implementation

[platform/adaptation/renesas_rcar/renesas_kernel.git] / mm / memory-failure.c

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 8b20278..c6e4dd3 100644 (file)
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -402,7 +402,7 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
        struct anon_vma *av;
        pgoff_t pgoff;
 
-       av = page_lock_anon_vma(page);
+       av = page_lock_anon_vma_read(page);
        if (av == NULL) /* Not actually mapped anymore */
                return;
 
@@ -423,7 +423,7 @@ static void collect_procs_anon(struct page *page, struct list_head *to_kill,
                }
        }
        read_unlock(&tasklist_lock);
-       page_unlock_anon_vma(av);
+       page_unlock_anon_vma_read(av);
 }
 
 /*
@@ -781,16 +781,16 @@ static struct page_state {
        { compound,     compound,       "huge",         me_huge_page },
 #endif
 
-       { sc|dirty,     sc|dirty,       "swapcache",    me_swapcache_dirty },
-       { sc|dirty,     sc,             "swapcache",    me_swapcache_clean },
+       { sc|dirty,     sc|dirty,       "dirty swapcache",      me_swapcache_dirty },
+       { sc|dirty,     sc,             "clean swapcache",      me_swapcache_clean },
 
-       { unevict|dirty, unevict|dirty, "unevictable LRU", me_pagecache_dirty},
-       { unevict,      unevict,        "unevictable LRU", me_pagecache_clean},
+       { unevict|dirty, unevict|dirty, "dirty unevictable LRU", me_pagecache_dirty },
+       { unevict,      unevict,        "clean unevictable LRU", me_pagecache_clean },
 
-       { mlock|dirty,  mlock|dirty,    "mlocked LRU",  me_pagecache_dirty },
-       { mlock,        mlock,          "mlocked LRU",  me_pagecache_clean },
+       { mlock|dirty,  mlock|dirty,    "dirty mlocked LRU",    me_pagecache_dirty },
+       { mlock,        mlock,          "clean mlocked LRU",    me_pagecache_clean },
 
-       { lru|dirty,    lru|dirty,      "LRU",          me_pagecache_dirty },
+       { lru|dirty,    lru|dirty,      "dirty LRU",    me_pagecache_dirty },
        { lru|dirty,    lru,            "clean LRU",    me_pagecache_clean },
 
        /*
@@ -812,14 +812,14 @@ static struct page_state {
 #undef slab
 #undef reserved
 
+/*
+ * "Dirty/Clean" indication is not 100% accurate due to the possibility of
+ * setting PG_dirty outside page lock. See also comment above set_page_dirty().
+ */
 static void action_result(unsigned long pfn, char *msg, int result)
 {
-       struct page *page = pfn_to_page(pfn);
-
-       printk(KERN_ERR "MCE %#lx: %s%s page recovery: %s\n",
-               pfn,
-               PageDirty(page) ? "dirty " : "",
-               msg, action_name[result]);
+       pr_err("MCE %#lx: %s page recovery: %s\n",
+               pfn, msg, action_name[result]);
 }
 
 static int page_action(struct page_state *ps, struct page *p,
@@ -1385,7 +1385,7 @@ static int get_any_page(struct page *p, unsigned long pfn, int flags)
         * Isolate the page, so that it doesn't get reallocated if it
         * was free.
         */
-       set_migratetype_isolate(p);
+       set_migratetype_isolate(p, true);
        /*
         * When the target page is a free hugepage, just remove it
         * from free hugepage list.
@@ -1566,7 +1566,8 @@ int soft_offline_page(struct page *page, int flags)
                                            page_is_file_cache(page));
                list_add(&page->lru, &pagelist);
                ret = migrate_pages(&pagelist, new_page, MPOL_MF_MOVE_ALL,
-                                                       false, MIGRATE_SYNC);
+                                                       false, MIGRATE_SYNC,
+                                                       MR_MEMORY_FAILURE);
                if (ret) {
                        putback_lru_pages(&pagelist);
                        pr_info("soft offline: %#lx: migration failed %d, type %lx\n",