Merge branch 'linus' into core/locking

13 files changed, 137 insertions, 267 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index ab8553658af3..f3e5f8944d17 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -2029,48 +2029,8 @@ int pagecache_write_begin(struct file *file, struct address_space *mapping,
 {
         const struct address_space_operations *aops = mapping->a_ops;
 
-        if (aops->write_begin) {
-                return aops->write_begin(file, mapping, pos, len, flags,
+        return aops->write_begin(file, mapping, pos, len, flags,
                                                         pagep, fsdata);
-        } else {
-                int ret;
-                pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-                unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
-                struct inode *inode = mapping->host;
-                struct page *page;
-again:
-                page = __grab_cache_page(mapping, index);
-                *pagep = page;
-                if (!page)
-                        return -ENOMEM;
-
-                if (flags & AOP_FLAG_UNINTERRUPTIBLE && !PageUptodate(page)) {
-                        /*
-                         * There is no way to resolve a short write situation
-                         * for a !Uptodate page (except by double copying in
-                         * the caller done by generic_perform_write_2copy).
-                         *
-                         * Instead, we have to bring it uptodate here.
-                         */
-                        ret = aops->readpage(file, page);
-                        page_cache_release(page);
-                        if (ret) {
-                                if (ret == AOP_TRUNCATED_PAGE)
-                                        goto again;
-                                return ret;
-                        }
-                        goto again;
-                }
-
-                ret = aops->prepare_write(file, page, offset, offset+len);
-                if (ret) {
-                        unlock_page(page);
-                        page_cache_release(page);
-                        if (pos + len > inode->i_size)
-                                vmtruncate(inode, inode->i_size);
-                }
-                return ret;
-        }
 }
 EXPORT_SYMBOL(pagecache_write_begin);
 
@@ -2079,32 +2039,9 @@ int pagecache_write_end(struct file *file, struct address_space *mapping,
                                 struct page *page, void *fsdata)
 {
         const struct address_space_operations *aops = mapping->a_ops;
-        int ret;
-
-        if (aops->write_end) {
-                mark_page_accessed(page);
-                ret = aops->write_end(file, mapping, pos, len, copied,
-                                                        page, fsdata);
-        } else {
-                unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
-                struct inode *inode = mapping->host;
-
-                flush_dcache_page(page);
-                ret = aops->commit_write(file, page, offset, offset+len);
-                unlock_page(page);
-                mark_page_accessed(page);
-                page_cache_release(page);
-
-                if (ret < 0) {
-                        if (pos + len > inode->i_size)
-                                vmtruncate(inode, inode->i_size);
-                } else if (ret > 0)
-                        ret = min_t(size_t, copied, ret);
-                else
-                        ret = copied;
-        }
 
-        return ret;
+        mark_page_accessed(page);
+        return aops->write_end(file, mapping, pos, len, copied, page, fsdata);
 }
 EXPORT_SYMBOL(pagecache_write_end);
 
@@ -2226,174 +2163,6 @@ repeat:
 }
 EXPORT_SYMBOL(__grab_cache_page);
 
-static ssize_t generic_perform_write_2copy(struct file *file,
-                                struct iov_iter *i, loff_t pos)
-{
-        struct address_space *mapping = file->f_mapping;
-        const struct address_space_operations *a_ops = mapping->a_ops;
-        struct inode *inode = mapping->host;
-        long status = 0;
-        ssize_t written = 0;
-
-        do {
-                struct page *src_page;
-                struct page *page;
-                pgoff_t index;          /* Pagecache index for current page */
-                unsigned long offset;   /* Offset into pagecache page */
-                unsigned long bytes;    /* Bytes to write to page */
-                size_t copied;          /* Bytes copied from user */
-
-                offset = (pos & (PAGE_CACHE_SIZE - 1));
-                index = pos >> PAGE_CACHE_SHIFT;
-                bytes = min_t(unsigned long, PAGE_CACHE_SIZE - offset,
-                                                iov_iter_count(i));
-
-                /*
-                 * a non-NULL src_page indicates that we're doing the
-                 * copy via get_user_pages and kmap.
-                 */
-                src_page = NULL;
-
-                /*
-                 * Bring in the user page that we will copy from _first_.
-                 * Otherwise there's a nasty deadlock on copying from the
-                 * same page as we're writing to, without it being marked
-                 * up-to-date.
-                 *
-                 * Not only is this an optimisation, but it is also required
-                 * to check that the address is actually valid, when atomic
-                 * usercopies are used, below.
-                 */
-                if (unlikely(iov_iter_fault_in_readable(i, bytes))) {
-                        status = -EFAULT;
-                        break;
-                }
-
-                page = __grab_cache_page(mapping, index);
-                if (!page) {
-                        status = -ENOMEM;
-                        break;
-                }
-
-                /*
-                 * non-uptodate pages cannot cope with short copies, and we
-                 * cannot take a pagefault with the destination page locked.
-                 * So pin the source page to copy it.
-                 */
-                if (!PageUptodate(page) && !segment_eq(get_fs(), KERNEL_DS)) {
-                        unlock_page(page);
-
-                        src_page = alloc_page(GFP_KERNEL);
-                        if (!src_page) {
-                                page_cache_release(page);
-                                status = -ENOMEM;
-                                break;
-                        }
-
-                        /*
-                         * Cannot get_user_pages with a page locked for the
-                         * same reason as we can't take a page fault with a
-                         * page locked (as explained below).
-                         */
-                        copied = iov_iter_copy_from_user(src_page, i,
-                                                                offset, bytes);
-                        if (unlikely(copied == 0)) {
-                                status = -EFAULT;
-                                page_cache_release(page);
-                                page_cache_release(src_page);
-                                break;
-                        }
-                        bytes = copied;
-
-                        lock_page(page);
-                        /*
-                         * Can't handle the page going uptodate here, because
-                         * that means we would use non-atomic usercopies, which
-                         * zero out the tail of the page, which can cause
-                         * zeroes to become transiently visible. We could just
-                         * use a non-zeroing copy, but the APIs aren't too
-                         * consistent.
-                         */
-                        if (unlikely(!page->mapping || PageUptodate(page))) {
-                                unlock_page(page);
-                                page_cache_release(page);
-                                page_cache_release(src_page);
-                                continue;
-                        }
-                }
-
-                status = a_ops->prepare_write(file, page, offset, offset+bytes);
-                if (unlikely(status))
-                        goto fs_write_aop_error;
-
-                if (!src_page) {
-                        /*
-                         * Must not enter the pagefault handler here, because
-                         * we hold the page lock, so we might recursively
-                         * deadlock on the same lock, or get an ABBA deadlock
-                         * against a different lock, or against the mmap_sem
-                         * (which nests outside the page lock).  So increment
-                         * preempt count, and use _atomic usercopies.
-                         *
-                         * The page is uptodate so we are OK to encounter a
-                         * short copy: if unmodified parts of the page are
-                         * marked dirty and written out to disk, it doesn't
-                         * really matter.
-                         */
-                        pagefault_disable();
-                        copied = iov_iter_copy_from_user_atomic(page, i,
-                                                                offset, bytes);
-                        pagefault_enable();
-                } else {
-                        void *src, *dst;
-                        src = kmap_atomic(src_page, KM_USER0);
-                        dst = kmap_atomic(page, KM_USER1);
-                        memcpy(dst + offset, src + offset, bytes);
-                        kunmap_atomic(dst, KM_USER1);
-                        kunmap_atomic(src, KM_USER0);
-                        copied = bytes;
-                }
-                flush_dcache_page(page);
-
-                status = a_ops->commit_write(file, page, offset, offset+bytes);
-                if (unlikely(status < 0))
-                        goto fs_write_aop_error;
-                if (unlikely(status > 0)) /* filesystem did partial write */
-                        copied = min_t(size_t, copied, status);
-
-                unlock_page(page);
-                mark_page_accessed(page);
-                page_cache_release(page);
-                if (src_page)
-                        page_cache_release(src_page);
-
-                iov_iter_advance(i, copied);
-                pos += copied;
-                written += copied;
-
-                balance_dirty_pages_ratelimited(mapping);
-                cond_resched();
-                continue;
-
-fs_write_aop_error:
-                unlock_page(page);
-                page_cache_release(page);
-                if (src_page)
-                        page_cache_release(src_page);
-
-                /*
-                 * prepare_write() may have instantiated a few blocks
-                 * outside i_size.  Trim these off again. Don't need
-                 * i_size_read because we hold i_mutex.
-                 */
-                if (pos + bytes > inode->i_size)
-                        vmtruncate(inode, inode->i_size);
-                break;
-        } while (iov_iter_count(i));
-
-        return written ? written : status;
-}
-
 static ssize_t generic_perform_write(struct file *file,
                                 struct iov_iter *i, loff_t pos)
 {
@@ -2494,10 +2263,7 @@ generic_file_buffered_write(struct kiocb *iocb, const struct iovec *iov,
         struct iov_iter i;
 
         iov_iter_init(&i, iov, nr_segs, count, written);
-        if (a_ops->write_begin)
-                status = generic_perform_write(file, &i, pos);
-        else
-                status = generic_perform_write_2copy(file, &i, pos);
+        status = generic_perform_write(file, &i, pos);
 
         if (likely(status >= 0)) {
                 written += status;
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 421aee99b84a..d143ab67be44 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -354,11 +354,26 @@ static int vma_has_reserves(struct vm_area_struct *vma)
         return 0;
 }
 
+static void clear_gigantic_page(struct page *page,
+                        unsigned long addr, unsigned long sz)
+{
+        int i;
+        struct page *p = page;
+
+        might_sleep();
+        for (i = 0; i < sz/PAGE_SIZE; i++, p = mem_map_next(p, page, i)) {
+                cond_resched();
+                clear_user_highpage(p, addr + i * PAGE_SIZE);
+        }
+}
 static void clear_huge_page(struct page *page,
                         unsigned long addr, unsigned long sz)
 {
         int i;
 
+        if (unlikely(sz > MAX_ORDER_NR_PAGES))
+                return clear_gigantic_page(page, addr, sz);
+
         might_sleep();
         for (i = 0; i < sz/PAGE_SIZE; i++) {
                 cond_resched();
@@ -366,12 +381,32 @@ static void clear_huge_page(struct page *page,
         }
 }
 
+static void copy_gigantic_page(struct page *dst, struct page *src,
+                           unsigned long addr, struct vm_area_struct *vma)
+{
+        int i;
+        struct hstate *h = hstate_vma(vma);
+        struct page *dst_base = dst;
+        struct page *src_base = src;
+        might_sleep();
+        for (i = 0; i < pages_per_huge_page(h); ) {
+                cond_resched();
+                copy_user_highpage(dst, src, addr + i*PAGE_SIZE, vma);
+
+                i++;
+                dst = mem_map_next(dst, dst_base, i);
+                src = mem_map_next(src, src_base, i);
+        }
+}
 static void copy_huge_page(struct page *dst, struct page *src,
                            unsigned long addr, struct vm_area_struct *vma)
 {
         int i;
         struct hstate *h = hstate_vma(vma);
 
+        if (unlikely(pages_per_huge_page(h) > MAX_ORDER_NR_PAGES))
+                return copy_gigantic_page(dst, src, addr, vma);
+
         might_sleep();
         for (i = 0; i < pages_per_huge_page(h); i++) {
                 cond_resched();
@@ -456,6 +491,8 @@ static void update_and_free_page(struct hstate *h, struct page *page)
 {
         int i;
 
+        VM_BUG_ON(h->order >= MAX_ORDER);
+
         h->nr_huge_pages--;
         h->nr_huge_pages_node[page_to_nid(page)]--;
         for (i = 0; i < pages_per_huge_page(h); i++) {
@@ -970,6 +1007,14 @@ found:
         return 1;
 }
 
+static void prep_compound_huge_page(struct page *page, int order)
+{
+        if (unlikely(order > (MAX_ORDER - 1)))
+                prep_compound_gigantic_page(page, order);
+        else
+                prep_compound_page(page, order);
+}
+
 /* Put bootmem huge pages into the standard lists after mem_map is up */
 static void __init gather_bootmem_prealloc(void)
 {
@@ -980,7 +1025,7 @@ static void __init gather_bootmem_prealloc(void)
                 struct hstate *h = m->hstate;
                 __ClearPageReserved(page);
                 WARN_ON(page_count(page) != 1);
-                prep_compound_page(page, h->order);
+                prep_compound_huge_page(page, h->order);
                 prep_new_huge_page(h, page, page_to_nid(page));
         }
 }
@@ -2130,7 +2175,7 @@ same_page:
                         if (zeropage_ok)
                                 pages[i] = ZERO_PAGE(0);
                         else
-                                pages[i] = page + pfn_offset;
+                                pages[i] = mem_map_offset(page, pfn_offset);
                         get_page(pages[i]);
                 }
 
diff --git a/mm/internal.h b/mm/internal.h
index e4e728bdf324..13333bc2eb68 100644
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -17,6 +17,7 @@ void free_pgtables(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
                 unsigned long floor, unsigned long ceiling);
 
 extern void prep_compound_page(struct page *page, unsigned long order);
+extern void prep_compound_gigantic_page(struct page *page, unsigned long order);
 
 static inline void set_page_count(struct page *page, int v)
 {
@@ -176,6 +177,34 @@ static inline void free_page_mlock(struct page *page) { }
 #endif /* CONFIG_UNEVICTABLE_LRU */
 
 /*
+ * Return the mem_map entry representing the 'offset' subpage within
+ * the maximally aligned gigantic page 'base'.  Handle any discontiguity
+ * in the mem_map at MAX_ORDER_NR_PAGES boundaries.
+ */
+static inline struct page *mem_map_offset(struct page *base, int offset)
+{
+        if (unlikely(offset >= MAX_ORDER_NR_PAGES))
+                return pfn_to_page(page_to_pfn(base) + offset);
+        return base + offset;
+}
+
+/*
+ * Iterator over all subpages withing the maximally aligned gigantic
+ * page 'base'.  Handle any discontiguity in the mem_map.
+ */
+static inline struct page *mem_map_next(struct page *iter,
+                                                struct page *base, int offset)
+{
+        if (unlikely((offset & (MAX_ORDER_NR_PAGES - 1)) == 0)) {
+                unsigned long pfn = page_to_pfn(base) + offset;
+                if (!pfn_valid(pfn))
+                        return NULL;
+                return pfn_to_page(pfn);
+        }
+        return iter + 1;
+}
+
+/*
  * FLATMEM and DISCONTIGMEM configurations use alloc_bootmem_node,
  * so all functions starting at paging_init should be marked __init
  * in those cases. SPARSEMEM, however, allows for memory hotplug,
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 36f42573a335..e9493b1c1117 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -489,12 +489,6 @@ check_range(struct mm_struct *mm, unsigned long start, unsigned long end,
         int err;
         struct vm_area_struct *first, *vma, *prev;
 
-        if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
-
-                err = migrate_prep();
-                if (err)
-                        return ERR_PTR(err);
-        }
 
         first = find_vma(mm, start);
         if (!first)
@@ -809,9 +803,13 @@ int do_migrate_pages(struct mm_struct *mm,
         const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags)
 {
         int busy = 0;
-        int err = 0;
+        int err;
         nodemask_t tmp;
 
+        err = migrate_prep();
+        if (err)
+                return err;
+
         down_read(&mm->mmap_sem);
 
         err = migrate_vmas(mm, from_nodes, to_nodes, flags);
@@ -974,6 +972,12 @@ static long do_mbind(unsigned long start, unsigned long len,
                  start, start + len, mode, mode_flags,
                  nmask ? nodes_addr(*nmask)[0] : -1);
 
+        if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
+
+                err = migrate_prep();
+                if (err)
+                        return err;
+        }
         down_write(&mm->mmap_sem);
         vma = check_range(mm, start, end, nmask,
                           flags | MPOL_MF_INVERT, &pagelist);
diff --git a/mm/migrate.c b/mm/migrate.c
index 6602941bfab0..385db89f0c33 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -841,12 +841,12 @@ static int do_move_page_to_node_array(struct mm_struct *mm,
         struct page_to_node *pp;
         LIST_HEAD(pagelist);
 
+        migrate_prep();
         down_read(&mm->mmap_sem);
 
         /*
          * Build a list of pages to migrate
          */
-        migrate_prep();
         for (pp = pm; pp->node != MAX_NUMNODES; pp++) {
                 struct vm_area_struct *vma;
                 struct page *page;
diff --git a/mm/mmap.c b/mm/mmap.c
index 74f4d158022e..de14ac21e5b5 100644
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -175,7 +175,8 @@ int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin)
 
         /* Don't let a single process grow too big:
            leave 3% of the size of this process for other processes */
-        allowed -= mm->total_vm / 32;
+        if (mm)
+                allowed -= mm->total_vm / 32;
 
         /*
          * cast `allowed' as a signed long because vm_committed_space
diff --git a/mm/nommu.c b/mm/nommu.c
index 2696b24f2bb3..7695dc850785 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -1454,7 +1454,8 @@ int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin)
 
         /* Don't let a single process grow too big:
            leave 3% of the size of this process for other processes */
-        allowed -= current->mm->total_vm / 32;
+        if (mm)
+                allowed -= mm->total_vm / 32;
 
         /*
          * cast `allowed' as a signed long because vm_committed_space
diff --git a/mm/oom_kill.c b/mm/oom_kill.c
index 64e5b4bcd964..a0a01902f551 100644
--- a/mm/oom_kill.c
+++ b/mm/oom_kill.c
@@ -38,7 +38,6 @@ static DEFINE_SPINLOCK(zone_scan_mutex);
  * badness - calculate a numeric value for how bad this task has been
  * @p: task struct of which task we should calculate
  * @uptime: current uptime in seconds
- * @mem: target memory controller
  *
  * The formula used is relatively simple and documented inline in the
  * function. The main rationale is that we want to select a good task
@@ -295,6 +294,8 @@ static void dump_tasks(const struct mem_cgroup *mem)
                         continue;
                 if (mem && !task_in_mem_cgroup(p, mem))
                         continue;
+                if (!thread_group_leader(p))
+                        continue;
 
                 task_lock(p);
                 printk(KERN_INFO "[%5d] %5d %5d %8lu %8lu %3d     %3d %s\n",
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index d0a240fbb8bf..54069e64e3a8 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -263,24 +263,39 @@ void prep_compound_page(struct page *page, unsigned long order)
 {
         int i;
         int nr_pages = 1 << order;
+
+        set_compound_page_dtor(page, free_compound_page);
+        set_compound_order(page, order);
+        __SetPageHead(page);
+        for (i = 1; i < nr_pages; i++) {
+                struct page *p = page + i;
+
+                __SetPageTail(p);
+                p->first_page = page;
+        }
+}
+
+#ifdef CONFIG_HUGETLBFS
+void prep_compound_gigantic_page(struct page *page, unsigned long order)
+{
+        int i;
+        int nr_pages = 1 << order;
         struct page *p = page + 1;
 
         set_compound_page_dtor(page, free_compound_page);
         set_compound_order(page, order);
         __SetPageHead(page);
-        for (i = 1; i < nr_pages; i++, p++) {
-                if (unlikely((i & (MAX_ORDER_NR_PAGES - 1)) == 0))
-                        p = pfn_to_page(page_to_pfn(page) + i);
+        for (i = 1; i < nr_pages; i++, p = mem_map_next(p, page, i)) {
                 __SetPageTail(p);
                 p->first_page = page;
         }
 }
+#endif
 
 static void destroy_compound_page(struct page *page, unsigned long order)
 {
         int i;
         int nr_pages = 1 << order;
-        struct page *p = page + 1;
 
         if (unlikely(compound_order(page) != order))
                 bad_page(page);
@@ -288,9 +303,8 @@ static void destroy_compound_page(struct page *page, unsigned long order)
         if (unlikely(!PageHead(page)))
                         bad_page(page);
         __ClearPageHead(page);
-        for (i = 1; i < nr_pages; i++, p++) {
-                if (unlikely((i & (MAX_ORDER_NR_PAGES - 1)) == 0))
-                        p = pfn_to_page(page_to_pfn(page) + i);
+        for (i = 1; i < nr_pages; i++) {
+                struct page *p = page + i;
 
                 if (unlikely(!PageTail(p) |
                                 (p->first_page != page)))
diff --git a/mm/page_isolation.c b/mm/page_isolation.c
index b70a7fec1ff6..5e0ffd967452 100644
--- a/mm/page_isolation.c
+++ b/mm/page_isolation.c
@@ -130,10 +130,11 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn)
                 if (page && get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
                         break;
         }
-        if (pfn < end_pfn)
+        page = __first_valid_page(start_pfn, end_pfn - start_pfn);
+        if ((pfn < end_pfn) || !page)
                 return -EBUSY;
         /* Check all pages are free or Marked as ISOLATED */
-        zone = page_zone(pfn_to_page(pfn));
+        zone = page_zone(page);
         spin_lock_irqsave(&zone->lock, flags);
         ret = __test_page_isolated_in_pageblock(start_pfn, end_pfn);
         spin_unlock_irqrestore(&zone->lock, flags);
diff --git a/mm/shmem.c b/mm/shmem.c
index d38d7e61fcd0..0ed075215e5f 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -161,8 +161,8 @@ static inline struct shmem_sb_info *SHMEM_SB(struct super_block *sb)
  */
 static inline int shmem_acct_size(unsigned long flags, loff_t size)
 {
-        return (flags & VM_ACCOUNT)?
-                security_vm_enough_memory(VM_ACCT(size)): 0;
+        return (flags & VM_ACCOUNT) ?
+                security_vm_enough_memory_kern(VM_ACCT(size)) : 0;
 }
 
 static inline void shmem_unacct_size(unsigned long flags, loff_t size)
@@ -179,8 +179,8 @@ static inline void shmem_unacct_size(unsigned long flags, loff_t size)
  */
 static inline int shmem_acct_block(unsigned long flags)
 {
-        return (flags & VM_ACCOUNT)?
-                0: security_vm_enough_memory(VM_ACCT(PAGE_CACHE_SIZE));
+        return (flags & VM_ACCOUNT) ?
+                0 : security_vm_enough_memory_kern(VM_ACCT(PAGE_CACHE_SIZE));
 }
 
 static inline void shmem_unacct_blocks(unsigned long flags, long pages)
diff --git a/mm/sparse-vmemmap.c b/mm/sparse-vmemmap.c
index a91b5f8fcaf6..a13ea6401ae7 100644
--- a/mm/sparse-vmemmap.c
+++ b/mm/sparse-vmemmap.c
@@ -64,7 +64,7 @@ void __meminit vmemmap_verify(pte_t *pte, int node,
         unsigned long pfn = pte_pfn(*pte);
         int actual_node = early_pfn_to_nid(pfn);
 
-        if (actual_node != node)
+        if (node_distance(actual_node, node) > LOCAL_DISTANCE)
                 printk(KERN_WARNING "[%lx-%lx] potential offnode "
                         "page_structs\n", start, end - 1);
 }
diff --git a/mm/vmalloc.c b/mm/vmalloc.c
index 036536945dd9..ba6b0f5f7fac 100644
--- a/mm/vmalloc.c
+++ b/mm/vmalloc.c
@@ -178,7 +178,7 @@ static int vmap_page_range(unsigned long addr, unsigned long end,
 static inline int is_vmalloc_or_module_addr(const void *x)
 {
         /*
-         * x86-64 and sparc64 put modules in a special place,
+         * ARM, x86-64 and sparc64 put modules in a special place,
          * and fall back on vmalloc() if that fails. Others
          * just put it in the vmalloc space.
          */
@@ -592,6 +592,8 @@ static void free_unmap_vmap_area_addr(unsigned long addr)
 
 #define VMAP_BLOCK_SIZE         (VMAP_BBMAP_BITS * PAGE_SIZE)
 
+static bool vmap_initialized __read_mostly = false;
+
 struct vmap_block_queue {
         spinlock_t lock;
         struct list_head free;
@@ -828,6 +830,9 @@ void vm_unmap_aliases(void)
         int cpu;
         int flush = 0;
 
+        if (unlikely(!vmap_initialized))
+                return;
+
         for_each_possible_cpu(cpu) {
                 struct vmap_block_queue *vbq = &per_cpu(vmap_block_queue, cpu);
                 struct vmap_block *vb;
@@ -897,7 +902,8 @@ EXPORT_SYMBOL(vm_unmap_ram);
  * @count: number of pages
  * @node: prefer to allocate data structures on this node
  * @prot: memory protection to use. PAGE_KERNEL for regular RAM
- * @returns: a pointer to the address that has been mapped, or NULL on failure
+ *
+ * Returns: a pointer to the address that has been mapped, or %NULL on failure
  */
 void *vm_map_ram(struct page **pages, unsigned int count, int node, pgprot_t prot)
 {
@@ -941,6 +947,8 @@ void __init vmalloc_init(void)
                 INIT_LIST_HEAD(&vbq->dirty);
                 vbq->nr_dirty = 0;
         }
+
+        vmap_initialized = true;
 }
 
 void unmap_kernel_range(unsigned long addr, unsigned long size)