Merge branch 'for-tip' of git://git.kernel.org/pub/scm/linux/kernel/git/tj/percpu into x86/urgent

2 files changed, 38 insertions, 34 deletions

diff --git a/mm/memory.c b/mm/memory.c
index d5d1653d60a6..98bcb90d5957 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -1310,8 +1310,9 @@ int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
                         cond_resched();
                         while (!(page = follow_page(vma, start, foll_flags))) {
                                 int ret;
-                                ret = handle_mm_fault(mm, vma, start,
-                                                foll_flags & FOLL_WRITE);
+
+                                /* FOLL_WRITE matches FAULT_FLAG_WRITE! */
+                                ret = handle_mm_fault(mm, vma, start, foll_flags & FOLL_WRITE);
                                 if (ret & VM_FAULT_ERROR) {
                                         if (ret & VM_FAULT_OOM)
                                                 return i ? i : -ENOMEM;
@@ -2496,7 +2497,7 @@ int vmtruncate_range(struct inode *inode, loff_t offset, loff_t end)
  */
 static int do_swap_page(struct mm_struct *mm, struct vm_area_struct *vma,
                 unsigned long address, pte_t *page_table, pmd_t *pmd,
-                int write_access, pte_t orig_pte)
+                unsigned int flags, pte_t orig_pte)
 {
         spinlock_t *ptl;
         struct page *page;
@@ -2572,9 +2573,9 @@ static int do_swap_page(struct mm_struct *mm, struct vm_area_struct *vma,
 
         inc_mm_counter(mm, anon_rss);
         pte = mk_pte(page, vma->vm_page_prot);
-        if (write_access && reuse_swap_page(page)) {
+        if ((flags & FAULT_FLAG_WRITE) && reuse_swap_page(page)) {
                 pte = maybe_mkwrite(pte_mkdirty(pte), vma);
-                write_access = 0;
+                flags &= ~FAULT_FLAG_WRITE;
         }
         flush_icache_page(vma, page);
         set_pte_at(mm, address, page_table, pte);
@@ -2587,7 +2588,7 @@ static int do_swap_page(struct mm_struct *mm, struct vm_area_struct *vma,
                 try_to_free_swap(page);
         unlock_page(page);
 
-        if (write_access) {
+        if (flags & FAULT_FLAG_WRITE) {
                 ret |= do_wp_page(mm, vma, address, page_table, pmd, ptl, pte);
                 if (ret & VM_FAULT_ERROR)
                         ret &= VM_FAULT_ERROR;
@@ -2616,7 +2617,7 @@ out_page:
  */
 static int do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma,
                 unsigned long address, pte_t *page_table, pmd_t *pmd,
-                int write_access)
+                unsigned int flags)
 {
         struct page *page;
         spinlock_t *ptl;
@@ -2776,7 +2777,7 @@ static int __do_fault(struct mm_struct *mm, struct vm_area_struct *vma,
          * due to the bad i386 page protection. But it's valid
          * for other architectures too.
          *
-         * Note that if write_access is true, we either now have
+         * Note that if FAULT_FLAG_WRITE is set, we either now have
          * an exclusive copy of the page, or this is a shared mapping,
          * so we can make it writable and dirty to avoid having to
          * handle that later.
@@ -2847,11 +2848,10 @@ unwritable_page:
 
 static int do_linear_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                 unsigned long address, pte_t *page_table, pmd_t *pmd,
-                int write_access, pte_t orig_pte)
+                unsigned int flags, pte_t orig_pte)
 {
         pgoff_t pgoff = (((address & PAGE_MASK)
                         - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
-        unsigned int flags = (write_access ? FAULT_FLAG_WRITE : 0);
 
         pte_unmap(page_table);
         return __do_fault(mm, vma, address, pmd, pgoff, flags, orig_pte);
@@ -2868,12 +2868,12 @@ static int do_linear_fault(struct mm_struct *mm, struct vm_area_struct *vma,
  */
 static int do_nonlinear_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                 unsigned long address, pte_t *page_table, pmd_t *pmd,
-                int write_access, pte_t orig_pte)
+                unsigned int flags, pte_t orig_pte)
 {
-        unsigned int flags = FAULT_FLAG_NONLINEAR |
-                                (write_access ? FAULT_FLAG_WRITE : 0);
         pgoff_t pgoff;
 
+        flags |= FAULT_FLAG_NONLINEAR;
+
         if (!pte_unmap_same(mm, pmd, page_table, orig_pte))
                 return 0;
 
@@ -2904,7 +2904,7 @@ static int do_nonlinear_fault(struct mm_struct *mm, struct vm_area_struct *vma,
  */
 static inline int handle_pte_fault(struct mm_struct *mm,
                 struct vm_area_struct *vma, unsigned long address,
-                pte_t *pte, pmd_t *pmd, int write_access)
+                pte_t *pte, pmd_t *pmd, unsigned int flags)
 {
         pte_t entry;
         spinlock_t *ptl;
@@ -2915,30 +2915,30 @@ static inline int handle_pte_fault(struct mm_struct *mm,
                         if (vma->vm_ops) {
                                 if (likely(vma->vm_ops->fault))
                                         return do_linear_fault(mm, vma, address,
-                                                pte, pmd, write_access, entry);
+                                                pte, pmd, flags, entry);
                         }
                         return do_anonymous_page(mm, vma, address,
-                                                 pte, pmd, write_access);
+                                                 pte, pmd, flags);
                 }
                 if (pte_file(entry))
                         return do_nonlinear_fault(mm, vma, address,
-                                        pte, pmd, write_access, entry);
+                                        pte, pmd, flags, entry);
                 return do_swap_page(mm, vma, address,
-                                        pte, pmd, write_access, entry);
+                                        pte, pmd, flags, entry);
         }
 
         ptl = pte_lockptr(mm, pmd);
         spin_lock(ptl);
         if (unlikely(!pte_same(*pte, entry)))
                 goto unlock;
-        if (write_access) {
+        if (flags & FAULT_FLAG_WRITE) {
                 if (!pte_write(entry))
                         return do_wp_page(mm, vma, address,
                                         pte, pmd, ptl, entry);
                 entry = pte_mkdirty(entry);
         }
         entry = pte_mkyoung(entry);
-        if (ptep_set_access_flags(vma, address, pte, entry, write_access)) {
+        if (ptep_set_access_flags(vma, address, pte, entry, flags & FAULT_FLAG_WRITE)) {
                 update_mmu_cache(vma, address, entry);
         } else {
                 /*
@@ -2947,7 +2947,7 @@ static inline int handle_pte_fault(struct mm_struct *mm,
                  * This still avoids useless tlb flushes for .text page faults
                  * with threads.
                  */
-                if (write_access)
+                if (flags & FAULT_FLAG_WRITE)
                         flush_tlb_page(vma, address);
         }
 unlock:
@@ -2959,7 +2959,7 @@ unlock:
  * By the time we get here, we already hold the mm semaphore
  */
 int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
-                unsigned long address, int write_access)
+                unsigned long address, unsigned int flags)
 {
         pgd_t *pgd;
         pud_t *pud;
@@ -2971,7 +2971,7 @@ int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
         count_vm_event(PGFAULT);
 
         if (unlikely(is_vm_hugetlb_page(vma)))
-                return hugetlb_fault(mm, vma, address, write_access);
+                return hugetlb_fault(mm, vma, address, flags);
 
         pgd = pgd_offset(mm, address);
         pud = pud_alloc(mm, pgd, address);
@@ -2984,7 +2984,7 @@ int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
         if (!pte)
                 return VM_FAULT_OOM;
 
-        return handle_pte_fault(mm, vma, address, pte, pmd, write_access);
+        return handle_pte_fault(mm, vma, address, pte, pmd, flags);
 }
 
 #ifndef __PAGETABLE_PUD_FOLDED
diff --git a/mm/percpu.c b/mm/percpu.c
index c0b2c1a76e81..b70f2acd8853 100644
--- a/mm/percpu.c
+++ b/mm/percpu.c
@@ -549,14 +549,14 @@ static void pcpu_free_area(struct pcpu_chunk *chunk, int freeme)
  * @chunk: chunk of interest
  * @page_start: page index of the first page to unmap
  * @page_end: page index of the last page to unmap + 1
- * @flush: whether to flush cache and tlb or not
+ * @flush_tlb: whether to flush tlb or not
  *
  * For each cpu, unmap pages [@page_start,@page_end) out of @chunk.
  * If @flush is true, vcache is flushed before unmapping and tlb
  * after.
  */
 static void pcpu_unmap(struct pcpu_chunk *chunk, int page_start, int page_end,
-                       bool flush)
+                       bool flush_tlb)
 {
         unsigned int last = num_possible_cpus() - 1;
         unsigned int cpu;
@@ -569,9 +569,8 @@ static void pcpu_unmap(struct pcpu_chunk *chunk, int page_start, int page_end,
          * the whole region at once rather than doing it for each cpu.
          * This could be an overkill but is more scalable.
          */
-        if (flush)
-                flush_cache_vunmap(pcpu_chunk_addr(chunk, 0, page_start),
-                                   pcpu_chunk_addr(chunk, last, page_end));
+        flush_cache_vunmap(pcpu_chunk_addr(chunk, 0, page_start),
+                           pcpu_chunk_addr(chunk, last, page_end));
 
         for_each_possible_cpu(cpu)
                 unmap_kernel_range_noflush(
@@ -579,7 +578,7 @@ static void pcpu_unmap(struct pcpu_chunk *chunk, int page_start, int page_end,
                                 (page_end - page_start) << PAGE_SHIFT);
 
         /* ditto as flush_cache_vunmap() */
-        if (flush)
+        if (flush_tlb)
                 flush_tlb_kernel_range(pcpu_chunk_addr(chunk, 0, page_start),
                                        pcpu_chunk_addr(chunk, last, page_end));
 }
@@ -1234,6 +1233,7 @@ static struct page * __init pcpue_get_page(unsigned int cpu, int pageno)
 ssize_t __init pcpu_embed_first_chunk(size_t static_size, size_t reserved_size,
                                       ssize_t dyn_size, ssize_t unit_size)
 {
+        size_t chunk_size;
         unsigned int cpu;
 
         /* determine parameters and allocate */
@@ -1248,11 +1248,15 @@ ssize_t __init pcpu_embed_first_chunk(size_t static_size, size_t reserved_size,
         } else
                 pcpue_unit_size = max_t(size_t, pcpue_size, PCPU_MIN_UNIT_SIZE);
 
-        pcpue_ptr = __alloc_bootmem_nopanic(
-                                        num_possible_cpus() * pcpue_unit_size,
-                                        PAGE_SIZE, __pa(MAX_DMA_ADDRESS));
-        if (!pcpue_ptr)
+        chunk_size = pcpue_unit_size * num_possible_cpus();
+
+        pcpue_ptr = __alloc_bootmem_nopanic(chunk_size, PAGE_SIZE,
+                                            __pa(MAX_DMA_ADDRESS));
+        if (!pcpue_ptr) {
+                pr_warning("PERCPU: failed to allocate %zu bytes for "
+                           "embedding\n", chunk_size);
                 return -ENOMEM;
+        }
 
         /* return the leftover and copy */
         for_each_possible_cpu(cpu) {