mm: use VM_BUG_ON_MM where possible

[pandora-kernel.git] / mm / huge_memory.c

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index d9a21d0..74c78aa 100644 (file)
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -1096,7 +1096,7 @@ int do_huge_pmd_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
        unsigned long mmun_end;         /* For mmu_notifiers */
 
        ptl = pmd_lockptr(mm, pmd);
-       VM_BUG_ON(!vma->anon_vma);
+       VM_BUG_ON_VMA(!vma->anon_vma, vma);
        haddr = address & HPAGE_PMD_MASK;
        if (is_huge_zero_pmd(orig_pmd))
                goto alloc;
@@ -1795,14 +1795,17 @@ static int __split_huge_page_map(struct page *page,
                for (i = 0; i < HPAGE_PMD_NR; i++, haddr += PAGE_SIZE) {
                        pte_t *pte, entry;
                        BUG_ON(PageCompound(page+i));
+                       /*
+                        * Note that pmd_numa is not transferred deliberately
+                        * to avoid any possibility that pte_numa leaks to
+                        * a PROT_NONE VMA by accident.
+                        */
                        entry = mk_pte(page + i, vma->vm_page_prot);
                        entry = maybe_mkwrite(pte_mkdirty(entry), vma);
                        if (!pmd_write(*pmd))
                                entry = pte_wrprotect(entry);
                        if (!pmd_young(*pmd))
                                entry = pte_mkold(entry);
-                       if (pmd_numa(*pmd))
-                               entry = pte_mknuma(entry);
                        pte = pte_offset_map(&_pmd, haddr);
                        BUG_ON(!pte_none(*pte));
                        set_pte_at(mm, haddr, pte, entry);
@@ -2045,7 +2048,7 @@ int __khugepaged_enter(struct mm_struct *mm)
                return -ENOMEM;
 
        /* __khugepaged_exit() must not run from under us */
-       VM_BUG_ON(khugepaged_test_exit(mm));
+       VM_BUG_ON_MM(khugepaged_test_exit(mm), mm);
        if (unlikely(test_and_set_bit(MMF_VM_HUGEPAGE, &mm->flags))) {
                free_mm_slot(mm_slot);
                return 0;
@@ -2080,7 +2083,7 @@ int khugepaged_enter_vma_merge(struct vm_area_struct *vma)
        if (vma->vm_ops)
                /* khugepaged not yet working on file or special mappings */
                return 0;
-       VM_BUG_ON(vma->vm_flags & VM_NO_THP);
+       VM_BUG_ON_VMA(vma->vm_flags & VM_NO_THP, vma);
        hstart = (vma->vm_start + ~HPAGE_PMD_MASK) & HPAGE_PMD_MASK;
        hend = vma->vm_end & HPAGE_PMD_MASK;
        if (hstart < hend)
@@ -2319,23 +2322,17 @@ static struct page
                       int node)
 {
        VM_BUG_ON_PAGE(*hpage, *hpage);
+
        /*
-        * Allocate the page while the vma is still valid and under
-        * the mmap_sem read mode so there is no memory allocation
-        * later when we take the mmap_sem in write mode. This is more
-        * friendly behavior (OTOH it may actually hide bugs) to
-        * filesystems in userland with daemons allocating memory in
-        * the userland I/O paths.  Allocating memory with the
-        * mmap_sem in read mode is good idea also to allow greater
-        * scalability.
+        * Before allocating the hugepage, release the mmap_sem read lock.
+        * The allocation can take potentially a long time if it involves
+        * sync compaction, and we do not need to hold the mmap_sem during
+        * that. We will recheck the vma after taking it again in write mode.
         */
+       up_read(&mm->mmap_sem);
+
        *hpage = alloc_pages_exact_node(node, alloc_hugepage_gfpmask(
                khugepaged_defrag(), __GFP_OTHER_NODE), HPAGE_PMD_ORDER);
-       /*
-        * After allocating the hugepage, release the mmap_sem read lock in
-        * preparation for taking it in write mode.
-        */
-       up_read(&mm->mmap_sem);
        if (unlikely(!*hpage)) {
                count_vm_event(THP_COLLAPSE_ALLOC_FAILED);
                *hpage = ERR_PTR(-ENOMEM);
@@ -2409,7 +2406,7 @@ static bool hugepage_vma_check(struct vm_area_struct *vma)
                return false;
        if (is_vma_temporary_stack(vma))
                return false;
-       VM_BUG_ON(vma->vm_flags & VM_NO_THP);
+       VM_BUG_ON_VMA(vma->vm_flags & VM_NO_THP, vma);
        return true;
 }