Merge git://git.kernel.org/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog

[net-next-2.6.git] / mm / memory-failure.c

diff --git a/mm/memory-failure.c b/mm/memory-failure.c
index 473f15a3356df7093a086bcab0292da1cdffa3b4..9c26eeca13425886690cddaf6dd45954fd3f0097 100644 (file)
--- a/mm/memory-failure.c
+++ b/mm/memory-failure.c
@@ -45,6 +45,7 @@
 #include <linux/page-isolation.h>
 #include <linux/suspend.h>
 #include <linux/slab.h>
+#include <linux/swapops.h>
 #include <linux/hugetlb.h>
 #include "internal.h"
 
@@ -690,17 +691,29 @@ static int me_swapcache_clean(struct page *p, unsigned long pfn)
 /*
  * Huge pages. Needs work.
  * Issues:
- * No rmap support so we cannot find the original mapper. In theory could walk
- * all MMs and look for the mappings, but that would be non atomic and racy.
- * Need rmap for hugepages for this. Alternatively we could employ a heuristic,
- * like just walking the current process and hoping it has it mapped (that
- * should be usually true for the common "shared database cache" case)
- * Should handle free huge pages and dequeue them too, but this needs to
- * handle huge page accounting correctly.
+ * - Error on hugepage is contained in hugepage unit (not in raw page unit.)
+ *   To narrow down kill region to one page, we need to break up pmd.
+ * - To support soft-offlining for hugepage, we need to support hugepage
+ *   migration.
  */
 static int me_huge_page(struct page *p, unsigned long pfn)
 {
-       return FAILED;
+       struct page *hpage = compound_head(p);
+       /*
+        * We can safely recover from error on free or reserved (i.e.
+        * not in-use) hugepage by dequeuing it from freelist.
+        * To check whether a hugepage is in-use or not, we can't use
+        * page->lru because it can be used in other hugepage operations,
+        * such as __unmap_hugepage_range() and gather_surplus_pages().
+        * So instead we use page_mapping() and PageAnon().
+        * We assume that this function is called with page lock held,
+        * so there is no race between isolation and mapping/unmapping.
+        */
+       if (!(page_mapping(hpage) || PageAnon(hpage))) {
+               __isolate_hwpoisoned_huge_page(hpage);
+               return RECOVERED;
+       }
+       return DELAYED;
 }
 
 /*
@@ -1344,3 +1357,35 @@ done:
        /* keep elevated page count for bad page */
        return ret;
 }
+
+/*
+ * The caller must hold current->mm->mmap_sem in read mode.
+ */
+int is_hwpoison_address(unsigned long addr)
+{
+       pgd_t *pgdp;
+       pud_t pud, *pudp;
+       pmd_t pmd, *pmdp;
+       pte_t pte, *ptep;
+       swp_entry_t entry;
+
+       pgdp = pgd_offset(current->mm, addr);
+       if (!pgd_present(*pgdp))
+               return 0;
+       pudp = pud_offset(pgdp, addr);
+       pud = *pudp;
+       if (!pud_present(pud) || pud_large(pud))
+               return 0;
+       pmdp = pmd_offset(pudp, addr);
+       pmd = *pmdp;
+       if (!pmd_present(pmd) || pmd_large(pmd))
+               return 0;
+       ptep = pte_offset_map(pmdp, addr);
+       pte = *ptep;
+       pte_unmap(ptep);
+       if (!is_swap_pte(pte))
+               return 0;
+       entry = pte_to_swp_entry(pte);
+       return is_hwpoison_entry(entry);
+}
+EXPORT_SYMBOL_GPL(is_hwpoison_address);