3 files changed, 79 insertions, 45 deletions

diff --git a/mm/gup.c b/mm/gup.c
index b2b4d4263768..dfcde13f289a 100644
--- a/mm/gup.c
+++ b/mm/gup.c
@@ -1643,6 +1643,47 @@ static int gup_p4d_range(pgd_t pgd, unsigned long addr, unsigned long end,
         return 1;
 }
 
+static void gup_pgd_range(unsigned long addr, unsigned long end,
+                int write, struct page **pages, int *nr)
+{
+        unsigned long next;
+        pgd_t *pgdp;
+
+        pgdp = pgd_offset(current->mm, addr);
+        do {
+                pgd_t pgd = READ_ONCE(*pgdp);
+
+                next = pgd_addr_end(addr, end);
+                if (pgd_none(pgd))
+                        return;
+                if (unlikely(pgd_huge(pgd))) {
+                        if (!gup_huge_pgd(pgd, pgdp, addr, next, write,
+                                          pages, nr))
+                                return;
+                } else if (unlikely(is_hugepd(__hugepd(pgd_val(pgd))))) {
+                        if (!gup_huge_pd(__hugepd(pgd_val(pgd)), addr,
+                                         PGDIR_SHIFT, next, write, pages, nr))
+                                return;
+                } else if (!gup_p4d_range(pgd, addr, next, write, pages, nr))
+                        return;
+        } while (pgdp++, addr = next, addr != end);
+}
+
+#ifndef gup_fast_permitted
+/*
+ * Check if it's allowed to use __get_user_pages_fast() for the range, or
+ * we need to fall back to the slow version:
+ */
+bool gup_fast_permitted(unsigned long start, int nr_pages, int write)
+{
+        unsigned long len, end;
+
+        len = (unsigned long) nr_pages << PAGE_SHIFT;
+        end = start + len;
+        return end >= start;
+}
+#endif
+
 /*
  * Like get_user_pages_fast() except it's IRQ-safe in that it won't fall back to
  * the regular GUP. It will only return non-negative values.
@@ -1650,10 +1691,8 @@ static int gup_p4d_range(pgd_t pgd, unsigned long addr, unsigned long end,
 int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
                           struct page **pages)
 {
-        struct mm_struct *mm = current->mm;
         unsigned long addr, len, end;
-        unsigned long next, flags;
-        pgd_t *pgdp;
+        unsigned long flags;
         int nr = 0;
 
         start &= PAGE_MASK;
@@ -1677,45 +1716,15 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write,
          * block IPIs that come from THPs splitting.
          */
 
-        local_irq_save(flags);
-        pgdp = pgd_offset(mm, addr);
-        do {
-                pgd_t pgd = READ_ONCE(*pgdp);
-
-                next = pgd_addr_end(addr, end);
-                if (pgd_none(pgd))
-                        break;
-                if (unlikely(pgd_huge(pgd))) {
-                        if (!gup_huge_pgd(pgd, pgdp, addr, next, write,
-                                          pages, &nr))
-                                break;
-                } else if (unlikely(is_hugepd(__hugepd(pgd_val(pgd))))) {
-                        if (!gup_huge_pd(__hugepd(pgd_val(pgd)), addr,
-                                         PGDIR_SHIFT, next, write, pages, &nr))
-                                break;
-                } else if (!gup_p4d_range(pgd, addr, next, write, pages, &nr))
-                        break;
-        } while (pgdp++, addr = next, addr != end);
-        local_irq_restore(flags);
+        if (gup_fast_permitted(start, nr_pages, write)) {
+                local_irq_save(flags);
+                gup_pgd_range(addr, end, write, pages, &nr);
+                local_irq_restore(flags);
+        }
 
         return nr;
 }
 
-#ifndef gup_fast_permitted
-/*
- * Check if it's allowed to use __get_user_pages_fast() for the range, or
- * we need to fall back to the slow version:
- */
-bool gup_fast_permitted(unsigned long start, int nr_pages, int write)
-{
-        unsigned long len, end;
-
-        len = (unsigned long) nr_pages << PAGE_SHIFT;
-        end = start + len;
-        return end >= start;
-}
-#endif
-
 /**
  * get_user_pages_fast() - pin user pages in memory
  * @start:      starting user address
@@ -1735,12 +1744,22 @@ bool gup_fast_permitted(unsigned long start, int nr_pages, int write)
 int get_user_pages_fast(unsigned long start, int nr_pages, int write,
                         struct page **pages)
 {
+        unsigned long addr, len, end;
         int nr = 0, ret = 0;
 
         start &= PAGE_MASK;
+        addr = start;
+        len = (unsigned long) nr_pages << PAGE_SHIFT;
+        end = start + len;
+
+        if (unlikely(!access_ok(write ? VERIFY_WRITE : VERIFY_READ,
+                                        (void __user *)start, len)))
+                return 0;
 
         if (gup_fast_permitted(start, nr_pages, write)) {
-                nr = __get_user_pages_fast(start, nr_pages, write, pages);
+                local_irq_disable();
+                gup_pgd_range(addr, end, write, pages, &nr);
+                local_irq_enable();
                 ret = nr;
         }
 
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 77e4d3c5c57b..8dfd13f724d9 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -5646,6 +5646,16 @@ void __init sparse_memory_present_with_active_regions(int nid)
         unsigned long start_pfn, end_pfn;
         int i, this_nid;
 
+#ifdef CONFIG_SPARSEMEM_EXTREME
+        if (!mem_section) {
+                unsigned long size, align;
+
+                size = sizeof(struct mem_section) * NR_SECTION_ROOTS;
+                align = 1 << (INTERNODE_CACHE_SHIFT);
+                mem_section = memblock_virt_alloc(size, align);
+        }
+#endif
+
         for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, &this_nid)
                 memory_present(this_nid, start_pfn, end_pfn);
 }
diff --git a/mm/sparse.c b/mm/sparse.c
index 83b3bf6461af..b00a97398795 100644
--- a/mm/sparse.c
+++ b/mm/sparse.c
@@ -22,8 +22,7 @@
  * 1) mem_section       - memory sections, mem_map's for valid memory
  */
 #ifdef CONFIG_SPARSEMEM_EXTREME
-struct mem_section *mem_section[NR_SECTION_ROOTS]
-        ____cacheline_internodealigned_in_smp;
+struct mem_section **mem_section;
 #else
 struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT]
         ____cacheline_internodealigned_in_smp;
@@ -100,7 +99,7 @@ static inline int sparse_index_init(unsigned long section_nr, int nid)
 int __section_nr(struct mem_section* ms)
 {
         unsigned long root_nr;
-        struct mem_section* root;
+        struct mem_section *root = NULL;
 
         for (root_nr = 0; root_nr < NR_SECTION_ROOTS; root_nr++) {
                 root = __nr_to_section(root_nr * SECTIONS_PER_ROOT);
@@ -111,7 +110,7 @@ int __section_nr(struct mem_section* ms)
                      break;
         }
 
-        VM_BUG_ON(root_nr == NR_SECTION_ROOTS);
+        VM_BUG_ON(!root);
 
         return (root_nr * SECTIONS_PER_ROOT) + (ms - root);
 }
@@ -329,11 +328,17 @@ again:
 static void __init check_usemap_section_nr(int nid, unsigned long *usemap)
 {
         unsigned long usemap_snr, pgdat_snr;
-        static unsigned long old_usemap_snr = NR_MEM_SECTIONS;
-        static unsigned long old_pgdat_snr = NR_MEM_SECTIONS;
+        static unsigned long old_usemap_snr;
+        static unsigned long old_pgdat_snr;
         struct pglist_data *pgdat = NODE_DATA(nid);
         int usemap_nid;
 
+        /* First call */
+        if (!old_usemap_snr) {
+                old_usemap_snr = NR_MEM_SECTIONS;
+                old_pgdat_snr = NR_MEM_SECTIONS;
+        }
+
         usemap_snr = pfn_to_section_nr(__pa(usemap) >> PAGE_SHIFT);
         pgdat_snr = pfn_to_section_nr(__pa(pgdat) >> PAGE_SHIFT);
         if (usemap_snr == pgdat_snr)