5 files changed, 93 insertions, 59 deletions

diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c
index 69bb818fdd79..4ced3fc66130 100644
--- a/arch/sparc/mm/fault_64.c
+++ b/arch/sparc/mm/fault_64.c
@@ -96,38 +96,51 @@ static unsigned int get_user_insn(unsigned long tpc)
         pte_t *ptep, pte;
         unsigned long pa;
         u32 insn = 0;
-        unsigned long pstate;
 
-        if (pgd_none(*pgdp))
-                goto outret;
+        if (pgd_none(*pgdp) || unlikely(pgd_bad(*pgdp)))
+                goto out;
         pudp = pud_offset(pgdp, tpc);
-        if (pud_none(*pudp))
-                goto outret;
-        pmdp = pmd_offset(pudp, tpc);
-        if (pmd_none(*pmdp))
-                goto outret;
+        if (pud_none(*pudp) || unlikely(pud_bad(*pudp)))
+                goto out;
 
         /* This disables preemption for us as well. */
-        __asm__ __volatile__("rdpr %%pstate, %0" : "=r" (pstate));
-        __asm__ __volatile__("wrpr %0, %1, %%pstate"
-                                : : "r" (pstate), "i" (PSTATE_IE));
-        ptep = pte_offset_map(pmdp, tpc);
-        pte = *ptep;
-        if (!pte_present(pte))
-                goto out;
+        local_irq_disable();
+
+        pmdp = pmd_offset(pudp, tpc);
+        if (pmd_none(*pmdp) || unlikely(pmd_bad(*pmdp)))
+                goto out_irq_enable;
 
-        pa  = (pte_pfn(pte) << PAGE_SHIFT);
-        pa += (tpc & ~PAGE_MASK);
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+        if (pmd_trans_huge(*pmdp)) {
+                if (pmd_trans_splitting(*pmdp))
+                        goto out_irq_enable;
 
-        /* Use phys bypass so we don't pollute dtlb/dcache. */
-        __asm__ __volatile__("lduwa [%1] %2, %0"
-                             : "=r" (insn)
-                             : "r" (pa), "i" (ASI_PHYS_USE_EC));
+                pa  = pmd_pfn(*pmdp) << PAGE_SHIFT;
+                pa += tpc & ~HPAGE_MASK;
 
+                /* Use phys bypass so we don't pollute dtlb/dcache. */
+                __asm__ __volatile__("lduwa [%1] %2, %0"
+                                     : "=r" (insn)
+                                     : "r" (pa), "i" (ASI_PHYS_USE_EC));
+        } else
+#endif
+        {
+                ptep = pte_offset_map(pmdp, tpc);
+                pte = *ptep;
+                if (pte_present(pte)) {
+                        pa  = (pte_pfn(pte) << PAGE_SHIFT);
+                        pa += (tpc & ~PAGE_MASK);
+
+                        /* Use phys bypass so we don't pollute dtlb/dcache. */
+                        __asm__ __volatile__("lduwa [%1] %2, %0"
+                                             : "=r" (insn)
+                                             : "r" (pa), "i" (ASI_PHYS_USE_EC));
+                }
+                pte_unmap(ptep);
+        }
+out_irq_enable:
+        local_irq_enable();
 out:
-        pte_unmap(ptep);
-        __asm__ __volatile__("wrpr %0, 0x0, %%pstate" : : "r" (pstate));
-outret:
         return insn;
 }
 
@@ -153,7 +166,8 @@ show_signal_msg(struct pt_regs *regs, int sig, int code,
 }
 
 static void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
-                             unsigned int insn, int fault_code)
+                             unsigned long fault_addr, unsigned int insn,
+                             int fault_code)
 {
         unsigned long addr;
         siginfo_t info;
@@ -161,10 +175,18 @@ static void do_fault_siginfo(int code, int sig, struct pt_regs *regs,
         info.si_code = code;
         info.si_signo = sig;
         info.si_errno = 0;
-        if (fault_code & FAULT_CODE_ITLB)
+        if (fault_code & FAULT_CODE_ITLB) {
                 addr = regs->tpc;
-        else
-                addr = compute_effective_address(regs, insn, 0);
+        } else {
+                /* If we were able to probe the faulting instruction, use it
+                 * to compute a precise fault address.  Otherwise use the fault
+                 * time provided address which may only have page granularity.
+                 */
+                if (insn)
+                        addr = compute_effective_address(regs, insn, 0);
+                else
+                        addr = fault_addr;
+        }
         info.si_addr = (void __user *) addr;
         info.si_trapno = 0;
 
@@ -239,7 +261,7 @@ static void __kprobes do_kernel_fault(struct pt_regs *regs, int si_code,
                 /* The si_code was set to make clear whether
                  * this was a SEGV_MAPERR or SEGV_ACCERR fault.
                  */
-                do_fault_siginfo(si_code, SIGSEGV, regs, insn, fault_code);
+                do_fault_siginfo(si_code, SIGSEGV, regs, address, insn, fault_code);
                 return;
         }
 
@@ -259,18 +281,6 @@ static void noinline __kprobes bogus_32bit_fault_tpc(struct pt_regs *regs)
         show_regs(regs);
 }
 
-static void noinline __kprobes bogus_32bit_fault_address(struct pt_regs *regs,
-                                                         unsigned long addr)
-{
-        static int times;
-
-        if (times++ < 10)
-                printk(KERN_ERR "FAULT[%s:%d]: 32-bit process "
-                       "reports 64-bit fault address [%lx]\n",
-                       current->comm, current->pid, addr);
-        show_regs(regs);
-}
-
 asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs)
 {
         enum ctx_state prev_state = exception_enter();
@@ -300,10 +310,8 @@ asmlinkage void __kprobes do_sparc64_fault(struct pt_regs *regs)
                                 goto intr_or_no_mm;
                         }
                 }
-                if (unlikely((address >> 32) != 0)) {
-                        bogus_32bit_fault_address(regs, address);
+                if (unlikely((address >> 32) != 0))
                         goto intr_or_no_mm;
-                }
         }
 
         if (regs->tstate & TSTATE_PRIV) {
@@ -525,7 +533,7 @@ do_sigbus:
          * Send a sigbus, regardless of whether we were in kernel
          * or user mode.
          */
-        do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, insn, fault_code);
+        do_fault_siginfo(BUS_ADRERR, SIGBUS, regs, address, insn, fault_code);
 
         /* Kernel mode? Handle exceptions or die */
         if (regs->tstate & TSTATE_PRIV)
diff --git a/arch/sparc/mm/gup.c b/arch/sparc/mm/gup.c
index c4d3da68b800..1aed0432c64b 100644
--- a/arch/sparc/mm/gup.c
+++ b/arch/sparc/mm/gup.c
@@ -73,7 +73,7 @@ static int gup_huge_pmd(pmd_t *pmdp, pmd_t pmd, unsigned long addr,
         struct page *head, *page, *tail;
         int refs;
 
-        if (!pmd_large(pmd))
+        if (!(pmd_val(pmd) & _PAGE_VALID))
                 return 0;
 
         if (write && !pmd_write(pmd))
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index eafbc65c9c47..ed3c969a5f4c 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -588,7 +588,7 @@ static void __init remap_kernel(void)
         int i, tlb_ent = sparc64_highest_locked_tlbent();
 
         tte_vaddr = (unsigned long) KERNBASE;
-        phys_page = (prom_boot_mapping_phys_low >> 22UL) << 22UL;
+        phys_page = (prom_boot_mapping_phys_low >> ILOG2_4MB) << ILOG2_4MB;
         tte_data = kern_large_tte(phys_page);
 
         kern_locked_tte_data = tte_data;
@@ -1881,7 +1881,7 @@ void __init paging_init(void)
 
         BUILD_BUG_ON(NR_CPUS > 4096);
 
-        kern_base = (prom_boot_mapping_phys_low >> 22UL) << 22UL;
+        kern_base = (prom_boot_mapping_phys_low >> ILOG2_4MB) << ILOG2_4MB;
         kern_size = (unsigned long)&_end - (unsigned long)KERNBASE;
 
         /* Invalidate both kernel TSBs.  */
@@ -1937,7 +1937,7 @@ void __init paging_init(void)
         shift = kern_base + PAGE_OFFSET - ((unsigned long)KERNBASE);
 
         real_end = (unsigned long)_end;
-        num_kernel_image_mappings = DIV_ROUND_UP(real_end - KERNBASE, 1 << 22);
+        num_kernel_image_mappings = DIV_ROUND_UP(real_end - KERNBASE, 1 << ILOG2_4MB);
         printk("Kernel: Using %d locked TLB entries for main kernel image.\n",
                num_kernel_image_mappings);
 
@@ -2094,7 +2094,7 @@ static void __init setup_valid_addr_bitmap_from_pavail(unsigned long *bitmap)
 
                                 if (new_start <= old_start &&
                                     new_end >= (old_start + PAGE_SIZE)) {
-                                        set_bit(old_start >> 22, bitmap);
+                                        set_bit(old_start >> ILOG2_4MB, bitmap);
                                         goto do_next_page;
                                 }
                         }
@@ -2143,7 +2143,7 @@ void __init mem_init(void)
         addr = PAGE_OFFSET + kern_base;
         last = PAGE_ALIGN(kern_size) + addr;
         while (addr < last) {
-                set_bit(__pa(addr) >> 22, sparc64_valid_addr_bitmap);
+                set_bit(__pa(addr) >> ILOG2_4MB, sparc64_valid_addr_bitmap);
                 addr += PAGE_SIZE;
         }
 
@@ -2267,7 +2267,7 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
                 void *block;
 
                 if (!(*vmem_pp & _PAGE_VALID)) {
-                        block = vmemmap_alloc_block(1UL << 22, node);
+                        block = vmemmap_alloc_block(1UL << ILOG2_4MB, node);
                         if (!block)
                                 return -ENOMEM;
 
diff --git a/arch/sparc/mm/tlb.c b/arch/sparc/mm/tlb.c
index b12cb5e72812..b89aba217e3b 100644
--- a/arch/sparc/mm/tlb.c
+++ b/arch/sparc/mm/tlb.c
@@ -134,7 +134,7 @@ no_cache_flush:
 
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 static void tlb_batch_pmd_scan(struct mm_struct *mm, unsigned long vaddr,
-                               pmd_t pmd, bool exec)
+                               pmd_t pmd)
 {
         unsigned long end;
         pte_t *pte;
@@ -142,8 +142,11 @@ static void tlb_batch_pmd_scan(struct mm_struct *mm, unsigned long vaddr,
         pte = pte_offset_map(&pmd, vaddr);
         end = vaddr + HPAGE_SIZE;
         while (vaddr < end) {
-                if (pte_val(*pte) & _PAGE_VALID)
+                if (pte_val(*pte) & _PAGE_VALID) {
+                        bool exec = pte_exec(*pte);
+
                         tlb_batch_add_one(mm, vaddr, exec);
+                }
                 pte++;
                 vaddr += PAGE_SIZE;
         }
@@ -177,19 +180,30 @@ void set_pmd_at(struct mm_struct *mm, unsigned long addr,
         }
 
         if (!pmd_none(orig)) {
-                pte_t orig_pte = __pte(pmd_val(orig));
-                bool exec = pte_exec(orig_pte);
-
                 addr &= HPAGE_MASK;
                 if (pmd_trans_huge(orig)) {
+                        pte_t orig_pte = __pte(pmd_val(orig));
+                        bool exec = pte_exec(orig_pte);
+
                         tlb_batch_add_one(mm, addr, exec);
                         tlb_batch_add_one(mm, addr + REAL_HPAGE_SIZE, exec);
                 } else {
-                        tlb_batch_pmd_scan(mm, addr, orig, exec);
+                        tlb_batch_pmd_scan(mm, addr, orig);
                 }
         }
 }
 
+void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
+                     pmd_t *pmdp)
+{
+        pmd_t entry = *pmdp;
+
+        pmd_val(entry) &= ~_PAGE_VALID;
+
+        set_pmd_at(vma->vm_mm, address, pmdp, entry);
+        flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
+}
+
 void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
                                 pgtable_t pgtable)
 {
diff --git a/arch/sparc/mm/tsb.c b/arch/sparc/mm/tsb.c
index f5d506fdddad..fe19b81acc09 100644
--- a/arch/sparc/mm/tsb.c
+++ b/arch/sparc/mm/tsb.c
@@ -133,7 +133,19 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
         mm->context.tsb_block[tsb_idx].tsb_nentries =
                 tsb_bytes / sizeof(struct tsb);
 
-        base = TSBMAP_BASE;
+        switch (tsb_idx) {
+        case MM_TSB_BASE:
+                base = TSBMAP_8K_BASE;
+                break;
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
+        case MM_TSB_HUGE:
+                base = TSBMAP_4M_BASE;
+                break;
+#endif
+        default:
+                BUG();
+        }
+
         tte = pgprot_val(PAGE_KERNEL_LOCKED);
         tsb_paddr = __pa(mm->context.tsb_block[tsb_idx].tsb);
         BUG_ON(tsb_paddr & (tsb_bytes - 1UL));