Merge branch 'akpm' (Andrew's patch-bomb)

Merge patches from Andrew Morton:
 "A few misc things and very nearly all of the MM tree.  A tremendous
  amount of stuff (again), including a significant rbtree library
  rework."

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (160 commits)
  sparc64: Support transparent huge pages.
  mm: thp: Use more portable PMD clearing sequenece in zap_huge_pmd().
  mm: Add and use update_mmu_cache_pmd() in transparent huge page code.
  sparc64: Document PGD and PMD layout.
  sparc64: Eliminate PTE table memory wastage.
  sparc64: Halve the size of PTE tables
  sparc64: Only support 4MB huge pages and 8KB base pages.
  memory-hotplug: suppress "Trying to free nonexistent resource <XXXXXXXXXXXXXXXX-YYYYYYYYYYYYYYYY>" warning
  mm: memcg: clean up mm_match_cgroup() signature
  mm: document PageHuge somewhat
  mm: use %pK for /proc/vmallocinfo
  mm, thp: fix mlock statistics
  mm, thp: fix mapped pages avoiding unevictable list on mlock
  memory-hotplug: update memory block's state and notify userspace
  memory-hotplug: preparation to notify memory block's state at memory hot remove
  mm: avoid section mismatch warning for memblock_type_name
  make GFP_NOTRACK definition unconditional
  cma: decrease cc.nr_migratepages after reclaiming pagelist
  CMA: migrate mlocked pages
  kpageflags: fix wrong KPF_THP on non-huge compound pages
  ...

6 files changed, 420 insertions, 108 deletions

diff --git a/arch/sparc/mm/fault_32.c b/arch/sparc/mm/fault_32.c
index 77ac917be152..e98bfda205a2 100644
--- a/arch/sparc/mm/fault_32.c
+++ b/arch/sparc/mm/fault_32.c
@@ -265,6 +265,7 @@ good_area:
                 }
                 if (fault & VM_FAULT_RETRY) {
                         flags &= ~FAULT_FLAG_ALLOW_RETRY;
+                        flags |= FAULT_FLAG_TRIED;
 
                         /* No need to up_read(&mm->mmap_sem) as we would
                          * have already released it in __lock_page_or_retry
diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c
index 1fe0429b6314..2976dba1ebaf 100644
--- a/arch/sparc/mm/fault_64.c
+++ b/arch/sparc/mm/fault_64.c
@@ -452,6 +452,7 @@ good_area:
                 }
                 if (fault & VM_FAULT_RETRY) {
                         flags &= ~FAULT_FLAG_ALLOW_RETRY;
+                        flags |= FAULT_FLAG_TRIED;
 
                         /* No need to up_read(&mm->mmap_sem) as we would
                          * have already released it in __lock_page_or_retry
@@ -464,13 +465,13 @@ good_area:
         up_read(&mm->mmap_sem);
 
         mm_rss = get_mm_rss(mm);
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         mm_rss -= (mm->context.huge_pte_count * (HPAGE_SIZE / PAGE_SIZE));
 #endif
         if (unlikely(mm_rss >
                      mm->context.tsb_block[MM_TSB_BASE].tsb_rss_limit))
                 tsb_grow(mm, MM_TSB_BASE, mm_rss);
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         mm_rss = mm->context.huge_pte_count;
         if (unlikely(mm_rss >
                      mm->context.tsb_block[MM_TSB_HUGE].tsb_rss_limit))
diff --git a/arch/sparc/mm/hugetlbpage.c b/arch/sparc/mm/hugetlbpage.c
index 07e14535375c..f76f83d5ac63 100644
--- a/arch/sparc/mm/hugetlbpage.c
+++ b/arch/sparc/mm/hugetlbpage.c
@@ -303,53 +303,3 @@ struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
 {
         return NULL;
 }
-
-static void context_reload(void *__data)
-{
-        struct mm_struct *mm = __data;
-
-        if (mm == current->mm)
-                load_secondary_context(mm);
-}
-
-void hugetlb_prefault_arch_hook(struct mm_struct *mm)
-{
-        struct tsb_config *tp = &mm->context.tsb_block[MM_TSB_HUGE];
-
-        if (likely(tp->tsb != NULL))
-                return;
-
-        tsb_grow(mm, MM_TSB_HUGE, 0);
-        tsb_context_switch(mm);
-        smp_tsb_sync(mm);
-
-        /* On UltraSPARC-III+ and later, configure the second half of
-         * the Data-TLB for huge pages.
-         */
-        if (tlb_type == cheetah_plus) {
-                unsigned long ctx;
-
-                spin_lock(&ctx_alloc_lock);
-                ctx = mm->context.sparc64_ctx_val;
-                ctx &= ~CTX_PGSZ_MASK;
-                ctx |= CTX_PGSZ_BASE << CTX_PGSZ0_SHIFT;
-                ctx |= CTX_PGSZ_HUGE << CTX_PGSZ1_SHIFT;
-
-                if (ctx != mm->context.sparc64_ctx_val) {
-                        /* When changing the page size fields, we
-                         * must perform a context flush so that no
-                         * stale entries match.  This flush must
-                         * occur with the original context register
-                         * settings.
-                         */
-                        do_flush_tlb_mm(mm);
-
-                        /* Reload the context register of all processors
-                         * also executing in this address space.
-                         */
-                        mm->context.sparc64_ctx_val = ctx;
-                        on_each_cpu(context_reload, mm, 0);
-                }
-                spin_unlock(&ctx_alloc_lock);
-        }
-}
diff --git a/arch/sparc/mm/init_64.c b/arch/sparc/mm/init_64.c
index 7a9b788c6ced..9e28a118e6a4 100644
--- a/arch/sparc/mm/init_64.c
+++ b/arch/sparc/mm/init_64.c
@@ -276,7 +276,6 @@ static inline void tsb_insert(struct tsb *ent, unsigned long tag, unsigned long
 }
 
 unsigned long _PAGE_ALL_SZ_BITS __read_mostly;
-unsigned long _PAGE_SZBITS __read_mostly;
 
 static void flush_dcache(unsigned long pfn)
 {
@@ -307,12 +306,24 @@ static void flush_dcache(unsigned long pfn)
         }
 }
 
+/* mm->context.lock must be held */
+static void __update_mmu_tsb_insert(struct mm_struct *mm, unsigned long tsb_index,
+                                    unsigned long tsb_hash_shift, unsigned long address,
+                                    unsigned long tte)
+{
+        struct tsb *tsb = mm->context.tsb_block[tsb_index].tsb;
+        unsigned long tag;
+
+        tsb += ((address >> tsb_hash_shift) &
+                (mm->context.tsb_block[tsb_index].tsb_nentries - 1UL));
+        tag = (address >> 22UL);
+        tsb_insert(tsb, tag, tte);
+}
+
 void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t *ptep)
 {
+        unsigned long tsb_index, tsb_hash_shift, flags;
         struct mm_struct *mm;
-        struct tsb *tsb;
-        unsigned long tag, flags;
-        unsigned long tsb_index, tsb_hash_shift;
         pte_t pte = *ptep;
 
         if (tlb_type != hypervisor) {
@@ -329,7 +340,7 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t *
 
         spin_lock_irqsave(&mm->context.lock, flags);
 
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         if (mm->context.tsb_block[MM_TSB_HUGE].tsb != NULL) {
                 if ((tlb_type == hypervisor &&
                      (pte_val(pte) & _PAGE_SZALL_4V) == _PAGE_SZHUGE_4V) ||
@@ -341,11 +352,8 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long address, pte_t *
         }
 #endif
 
-        tsb = mm->context.tsb_block[tsb_index].tsb;
-        tsb += ((address >> tsb_hash_shift) &
-                (mm->context.tsb_block[tsb_index].tsb_nentries - 1UL));
-        tag = (address >> 22UL);
-        tsb_insert(tsb, tag, pte_val(pte));
+        __update_mmu_tsb_insert(mm, tsb_index, tsb_hash_shift,
+                                address, pte_val(pte));
 
         spin_unlock_irqrestore(&mm->context.lock, flags);
 }
@@ -2275,8 +2283,7 @@ static void __init sun4u_pgprot_init(void)
                      __ACCESS_BITS_4U | _PAGE_E_4U);
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
-        kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZBITS_4U) ^
-                0xfffff80000000000UL;
+        kern_linear_pte_xor[0] = _PAGE_VALID ^ 0xfffff80000000000UL;
 #else
         kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4U) ^
                 0xfffff80000000000UL;
@@ -2287,7 +2294,6 @@ static void __init sun4u_pgprot_init(void)
         for (i = 1; i < 4; i++)
                 kern_linear_pte_xor[i] = kern_linear_pte_xor[0];
 
-        _PAGE_SZBITS = _PAGE_SZBITS_4U;
         _PAGE_ALL_SZ_BITS =  (_PAGE_SZ4MB_4U | _PAGE_SZ512K_4U |
                               _PAGE_SZ64K_4U | _PAGE_SZ8K_4U |
                               _PAGE_SZ32MB_4U | _PAGE_SZ256MB_4U);
@@ -2324,8 +2330,7 @@ static void __init sun4v_pgprot_init(void)
         _PAGE_CACHE = _PAGE_CACHE_4V;
 
 #ifdef CONFIG_DEBUG_PAGEALLOC
-        kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZBITS_4V) ^
-                0xfffff80000000000UL;
+        kern_linear_pte_xor[0] = _PAGE_VALID ^ 0xfffff80000000000UL;
 #else
         kern_linear_pte_xor[0] = (_PAGE_VALID | _PAGE_SZ4MB_4V) ^
                 0xfffff80000000000UL;
@@ -2339,7 +2344,6 @@ static void __init sun4v_pgprot_init(void)
         pg_iobits = (_PAGE_VALID | _PAGE_PRESENT_4V | __DIRTY_BITS_4V |
                      __ACCESS_BITS_4V | _PAGE_E_4V);
 
-        _PAGE_SZBITS = _PAGE_SZBITS_4V;
         _PAGE_ALL_SZ_BITS = (_PAGE_SZ16GB_4V | _PAGE_SZ2GB_4V |
                              _PAGE_SZ256MB_4V | _PAGE_SZ32MB_4V |
                              _PAGE_SZ4MB_4V | _PAGE_SZ512K_4V |
@@ -2472,3 +2476,281 @@ void __flush_tlb_all(void)
         __asm__ __volatile__("wrpr      %0, 0, %%pstate"
                              : : "r" (pstate));
 }
+
+static pte_t *get_from_cache(struct mm_struct *mm)
+{
+        struct page *page;
+        pte_t *ret;
+
+        spin_lock(&mm->page_table_lock);
+        page = mm->context.pgtable_page;
+        ret = NULL;
+        if (page) {
+                void *p = page_address(page);
+
+                mm->context.pgtable_page = NULL;
+
+                ret = (pte_t *) (p + (PAGE_SIZE / 2));
+        }
+        spin_unlock(&mm->page_table_lock);
+
+        return ret;
+}
+
+static struct page *__alloc_for_cache(struct mm_struct *mm)
+{
+        struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
+                                       __GFP_REPEAT | __GFP_ZERO);
+
+        if (page) {
+                spin_lock(&mm->page_table_lock);
+                if (!mm->context.pgtable_page) {
+                        atomic_set(&page->_count, 2);
+                        mm->context.pgtable_page = page;
+                }
+                spin_unlock(&mm->page_table_lock);
+        }
+        return page;
+}
+
+pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
+                            unsigned long address)
+{
+        struct page *page;
+        pte_t *pte;
+
+        pte = get_from_cache(mm);
+        if (pte)
+                return pte;
+
+        page = __alloc_for_cache(mm);
+        if (page)
+                pte = (pte_t *) page_address(page);
+
+        return pte;
+}
+
+pgtable_t pte_alloc_one(struct mm_struct *mm,
+                        unsigned long address)
+{
+        struct page *page;
+        pte_t *pte;
+
+        pte = get_from_cache(mm);
+        if (pte)
+                return pte;
+
+        page = __alloc_for_cache(mm);
+        if (page) {
+                pgtable_page_ctor(page);
+                pte = (pte_t *) page_address(page);
+        }
+
+        return pte;
+}
+
+void pte_free_kernel(struct mm_struct *mm, pte_t *pte)
+{
+        struct page *page = virt_to_page(pte);
+        if (put_page_testzero(page))
+                free_hot_cold_page(page, 0);
+}
+
+static void __pte_free(pgtable_t pte)
+{
+        struct page *page = virt_to_page(pte);
+        if (put_page_testzero(page)) {
+                pgtable_page_dtor(page);
+                free_hot_cold_page(page, 0);
+        }
+}
+
+void pte_free(struct mm_struct *mm, pgtable_t pte)
+{
+        __pte_free(pte);
+}
+
+void pgtable_free(void *table, bool is_page)
+{
+        if (is_page)
+                __pte_free(table);
+        else
+                kmem_cache_free(pgtable_cache, table);
+}
+
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+static pmd_t pmd_set_protbits(pmd_t pmd, pgprot_t pgprot, bool for_modify)
+{
+        if (pgprot_val(pgprot) & _PAGE_VALID)
+                pmd_val(pmd) |= PMD_HUGE_PRESENT;
+        if (tlb_type == hypervisor) {
+                if (pgprot_val(pgprot) & _PAGE_WRITE_4V)
+                        pmd_val(pmd) |= PMD_HUGE_WRITE;
+                if (pgprot_val(pgprot) & _PAGE_EXEC_4V)
+                        pmd_val(pmd) |= PMD_HUGE_EXEC;
+
+                if (!for_modify) {
+                        if (pgprot_val(pgprot) & _PAGE_ACCESSED_4V)
+                                pmd_val(pmd) |= PMD_HUGE_ACCESSED;
+                        if (pgprot_val(pgprot) & _PAGE_MODIFIED_4V)
+                                pmd_val(pmd) |= PMD_HUGE_DIRTY;
+                }
+        } else {
+                if (pgprot_val(pgprot) & _PAGE_WRITE_4U)
+                        pmd_val(pmd) |= PMD_HUGE_WRITE;
+                if (pgprot_val(pgprot) & _PAGE_EXEC_4U)
+                        pmd_val(pmd) |= PMD_HUGE_EXEC;
+
+                if (!for_modify) {
+                        if (pgprot_val(pgprot) & _PAGE_ACCESSED_4U)
+                                pmd_val(pmd) |= PMD_HUGE_ACCESSED;
+                        if (pgprot_val(pgprot) & _PAGE_MODIFIED_4U)
+                                pmd_val(pmd) |= PMD_HUGE_DIRTY;
+                }
+        }
+
+        return pmd;
+}
+
+pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
+{
+        pmd_t pmd;
+
+        pmd_val(pmd) = (page_nr << ((PAGE_SHIFT - PMD_PADDR_SHIFT)));
+        pmd_val(pmd) |= PMD_ISHUGE;
+        pmd = pmd_set_protbits(pmd, pgprot, false);
+        return pmd;
+}
+
+pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
+{
+        pmd_val(pmd) &= ~(PMD_HUGE_PRESENT |
+                          PMD_HUGE_WRITE |
+                          PMD_HUGE_EXEC);
+        pmd = pmd_set_protbits(pmd, newprot, true);
+        return pmd;
+}
+
+pgprot_t pmd_pgprot(pmd_t entry)
+{
+        unsigned long pte = 0;
+
+        if (pmd_val(entry) & PMD_HUGE_PRESENT)
+                pte |= _PAGE_VALID;
+
+        if (tlb_type == hypervisor) {
+                if (pmd_val(entry) & PMD_HUGE_PRESENT)
+                        pte |= _PAGE_PRESENT_4V;
+                if (pmd_val(entry) & PMD_HUGE_EXEC)
+                        pte |= _PAGE_EXEC_4V;
+                if (pmd_val(entry) & PMD_HUGE_WRITE)
+                        pte |= _PAGE_W_4V;
+                if (pmd_val(entry) & PMD_HUGE_ACCESSED)
+                        pte |= _PAGE_ACCESSED_4V;
+                if (pmd_val(entry) & PMD_HUGE_DIRTY)
+                        pte |= _PAGE_MODIFIED_4V;
+                pte |= _PAGE_CP_4V|_PAGE_CV_4V;
+        } else {
+                if (pmd_val(entry) & PMD_HUGE_PRESENT)
+                        pte |= _PAGE_PRESENT_4U;
+                if (pmd_val(entry) & PMD_HUGE_EXEC)
+                        pte |= _PAGE_EXEC_4U;
+                if (pmd_val(entry) & PMD_HUGE_WRITE)
+                        pte |= _PAGE_W_4U;
+                if (pmd_val(entry) & PMD_HUGE_ACCESSED)
+                        pte |= _PAGE_ACCESSED_4U;
+                if (pmd_val(entry) & PMD_HUGE_DIRTY)
+                        pte |= _PAGE_MODIFIED_4U;
+                pte |= _PAGE_CP_4U|_PAGE_CV_4U;
+        }
+
+        return __pgprot(pte);
+}
+
+void update_mmu_cache_pmd(struct vm_area_struct *vma, unsigned long addr,
+                          pmd_t *pmd)
+{
+        unsigned long pte, flags;
+        struct mm_struct *mm;
+        pmd_t entry = *pmd;
+        pgprot_t prot;
+
+        if (!pmd_large(entry) || !pmd_young(entry))
+                return;
+
+        pte = (pmd_val(entry) & ~PMD_HUGE_PROTBITS);
+        pte <<= PMD_PADDR_SHIFT;
+        pte |= _PAGE_VALID;
+
+        prot = pmd_pgprot(entry);
+
+        if (tlb_type == hypervisor)
+                pgprot_val(prot) |= _PAGE_SZHUGE_4V;
+        else
+                pgprot_val(prot) |= _PAGE_SZHUGE_4U;
+
+        pte |= pgprot_val(prot);
+
+        mm = vma->vm_mm;
+
+        spin_lock_irqsave(&mm->context.lock, flags);
+
+        if (mm->context.tsb_block[MM_TSB_HUGE].tsb != NULL)
+                __update_mmu_tsb_insert(mm, MM_TSB_HUGE, HPAGE_SHIFT,
+                                        addr, pte);
+
+        spin_unlock_irqrestore(&mm->context.lock, flags);
+}
+#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
+
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
+static void context_reload(void *__data)
+{
+        struct mm_struct *mm = __data;
+
+        if (mm == current->mm)
+                load_secondary_context(mm);
+}
+
+void hugetlb_setup(struct mm_struct *mm)
+{
+        struct tsb_config *tp = &mm->context.tsb_block[MM_TSB_HUGE];
+
+        if (likely(tp->tsb != NULL))
+                return;
+
+        tsb_grow(mm, MM_TSB_HUGE, 0);
+        tsb_context_switch(mm);
+        smp_tsb_sync(mm);
+
+        /* On UltraSPARC-III+ and later, configure the second half of
+         * the Data-TLB for huge pages.
+         */
+        if (tlb_type == cheetah_plus) {
+                unsigned long ctx;
+
+                spin_lock(&ctx_alloc_lock);
+                ctx = mm->context.sparc64_ctx_val;
+                ctx &= ~CTX_PGSZ_MASK;
+                ctx |= CTX_PGSZ_BASE << CTX_PGSZ0_SHIFT;
+                ctx |= CTX_PGSZ_HUGE << CTX_PGSZ1_SHIFT;
+
+                if (ctx != mm->context.sparc64_ctx_val) {
+                        /* When changing the page size fields, we
+                         * must perform a context flush so that no
+                         * stale entries match.  This flush must
+                         * occur with the original context register
+                         * settings.
+                         */
+                        do_flush_tlb_mm(mm);
+
+                        /* Reload the context register of all processors
+                         * also executing in this address space.
+                         */
+                        mm->context.sparc64_ctx_val = ctx;
+                        on_each_cpu(context_reload, mm, 0);
+                }
+                spin_unlock(&ctx_alloc_lock);
+        }
+}
+#endif
diff --git a/arch/sparc/mm/tlb.c b/arch/sparc/mm/tlb.c
index b1f279cd00bf..3e8fec391fe0 100644
--- a/arch/sparc/mm/tlb.c
+++ b/arch/sparc/mm/tlb.c
@@ -43,16 +43,37 @@ void flush_tlb_pending(void)
         put_cpu_var(tlb_batch);
 }
 
-void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr,
-                   pte_t *ptep, pte_t orig, int fullmm)
+static void tlb_batch_add_one(struct mm_struct *mm, unsigned long vaddr,
+                              bool exec)
 {
         struct tlb_batch *tb = &get_cpu_var(tlb_batch);
         unsigned long nr;
 
         vaddr &= PAGE_MASK;
-        if (pte_exec(orig))
+        if (exec)
                 vaddr |= 0x1UL;
 
+        nr = tb->tlb_nr;
+
+        if (unlikely(nr != 0 && mm != tb->mm)) {
+                flush_tlb_pending();
+                nr = 0;
+        }
+
+        if (nr == 0)
+                tb->mm = mm;
+
+        tb->vaddrs[nr] = vaddr;
+        tb->tlb_nr = ++nr;
+        if (nr >= TLB_BATCH_NR)
+                flush_tlb_pending();
+
+        put_cpu_var(tlb_batch);
+}
+
+void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr,
+                   pte_t *ptep, pte_t orig, int fullmm)
+{
         if (tlb_type != hypervisor &&
             pte_dirty(orig)) {
                 unsigned long paddr, pfn = pte_pfn(orig);
@@ -77,26 +98,91 @@ void tlb_batch_add(struct mm_struct *mm, unsigned long vaddr,
         }
 
 no_cache_flush:
+        if (!fullmm)
+                tlb_batch_add_one(mm, vaddr, pte_exec(orig));
+}
+
+#ifdef CONFIG_TRANSPARENT_HUGEPAGE
+static void tlb_batch_pmd_scan(struct mm_struct *mm, unsigned long vaddr,
+                               pmd_t pmd, bool exec)
+{
+        unsigned long end;
+        pte_t *pte;
+
+        pte = pte_offset_map(&pmd, vaddr);
+        end = vaddr + HPAGE_SIZE;
+        while (vaddr < end) {
+                if (pte_val(*pte) & _PAGE_VALID)
+                        tlb_batch_add_one(mm, vaddr, exec);
+                pte++;
+                vaddr += PAGE_SIZE;
+        }
+        pte_unmap(pte);
+}
 
-        if (fullmm) {
-                put_cpu_var(tlb_batch);
+void set_pmd_at(struct mm_struct *mm, unsigned long addr,
+                pmd_t *pmdp, pmd_t pmd)
+{
+        pmd_t orig = *pmdp;
+
+        *pmdp = pmd;
+
+        if (mm == &init_mm)
                 return;
+
+        if ((pmd_val(pmd) ^ pmd_val(orig)) & PMD_ISHUGE) {
+                if (pmd_val(pmd) & PMD_ISHUGE)
+                        mm->context.huge_pte_count++;
+                else
+                        mm->context.huge_pte_count--;
+                if (mm->context.huge_pte_count == 1)
+                        hugetlb_setup(mm);
         }
 
-        nr = tb->tlb_nr;
+        if (!pmd_none(orig)) {
+                bool exec = ((pmd_val(orig) & PMD_HUGE_EXEC) != 0);
 
-        if (unlikely(nr != 0 && mm != tb->mm)) {
-                flush_tlb_pending();
-                nr = 0;
+                addr &= HPAGE_MASK;
+                if (pmd_val(orig) & PMD_ISHUGE)
+                        tlb_batch_add_one(mm, addr, exec);
+                else
+                        tlb_batch_pmd_scan(mm, addr, orig, exec);
         }
+}
 
-        if (nr == 0)
-                tb->mm = mm;
+void pgtable_trans_huge_deposit(struct mm_struct *mm, pgtable_t pgtable)
+{
+        struct list_head *lh = (struct list_head *) pgtable;
 
-        tb->vaddrs[nr] = vaddr;
-        tb->tlb_nr = ++nr;
-        if (nr >= TLB_BATCH_NR)
-                flush_tlb_pending();
+        assert_spin_locked(&mm->page_table_lock);
 
-        put_cpu_var(tlb_batch);
+        /* FIFO */
+        if (!mm->pmd_huge_pte)
+                INIT_LIST_HEAD(lh);
+        else
+                list_add(lh, (struct list_head *) mm->pmd_huge_pte);
+        mm->pmd_huge_pte = pgtable;
+}
+
+pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm)
+{
+        struct list_head *lh;
+        pgtable_t pgtable;
+
+        assert_spin_locked(&mm->page_table_lock);
+
+        /* FIFO */
+        pgtable = mm->pmd_huge_pte;
+        lh = (struct list_head *) pgtable;
+        if (list_empty(lh))
+                mm->pmd_huge_pte = NULL;
+        else {
+                mm->pmd_huge_pte = (pgtable_t) lh->next;
+                list_del(lh);
+        }
+        pte_val(pgtable[0]) = 0;
+        pte_val(pgtable[1]) = 0;
+
+        return pgtable;
 }
+#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
diff --git a/arch/sparc/mm/tsb.c b/arch/sparc/mm/tsb.c
index c52add79b83d..7f6474347491 100644
--- a/arch/sparc/mm/tsb.c
+++ b/arch/sparc/mm/tsb.c
@@ -78,7 +78,7 @@ void flush_tsb_user(struct tlb_batch *tb)
                 base = __pa(base);
         __flush_tsb_one(tb, PAGE_SHIFT, base, nentries);
 
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         if (mm->context.tsb_block[MM_TSB_HUGE].tsb) {
                 base = (unsigned long) mm->context.tsb_block[MM_TSB_HUGE].tsb;
                 nentries = mm->context.tsb_block[MM_TSB_HUGE].tsb_nentries;
@@ -90,29 +90,12 @@ void flush_tsb_user(struct tlb_batch *tb)
         spin_unlock_irqrestore(&mm->context.lock, flags);
 }
 
-#if defined(CONFIG_SPARC64_PAGE_SIZE_8KB)
 #define HV_PGSZ_IDX_BASE        HV_PGSZ_IDX_8K
 #define HV_PGSZ_MASK_BASE       HV_PGSZ_MASK_8K
-#elif defined(CONFIG_SPARC64_PAGE_SIZE_64KB)
-#define HV_PGSZ_IDX_BASE        HV_PGSZ_IDX_64K
-#define HV_PGSZ_MASK_BASE       HV_PGSZ_MASK_64K
-#else
-#error Broken base page size setting...
-#endif
 
-#ifdef CONFIG_HUGETLB_PAGE
-#if defined(CONFIG_HUGETLB_PAGE_SIZE_64K)
-#define HV_PGSZ_IDX_HUGE        HV_PGSZ_IDX_64K
-#define HV_PGSZ_MASK_HUGE       HV_PGSZ_MASK_64K
-#elif defined(CONFIG_HUGETLB_PAGE_SIZE_512K)
-#define HV_PGSZ_IDX_HUGE        HV_PGSZ_IDX_512K
-#define HV_PGSZ_MASK_HUGE       HV_PGSZ_MASK_512K
-#elif defined(CONFIG_HUGETLB_PAGE_SIZE_4MB)
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
 #define HV_PGSZ_IDX_HUGE        HV_PGSZ_IDX_4MB
 #define HV_PGSZ_MASK_HUGE       HV_PGSZ_MASK_4MB
-#else
-#error Broken huge page size setting...
-#endif
 #endif
 
 static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsigned long tsb_bytes)
@@ -207,7 +190,7 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
                 case MM_TSB_BASE:
                         hp->pgsz_idx = HV_PGSZ_IDX_BASE;
                         break;
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
                 case MM_TSB_HUGE:
                         hp->pgsz_idx = HV_PGSZ_IDX_HUGE;
                         break;
@@ -222,7 +205,7 @@ static void setup_tsb_params(struct mm_struct *mm, unsigned long tsb_idx, unsign
                 case MM_TSB_BASE:
                         hp->pgsz_mask = HV_PGSZ_MASK_BASE;
                         break;
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
                 case MM_TSB_HUGE:
                         hp->pgsz_mask = HV_PGSZ_MASK_HUGE;
                         break;
@@ -444,7 +427,7 @@ retry_tsb_alloc:
 
 int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
 {
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         unsigned long huge_pte_count;
 #endif
         unsigned int i;
@@ -453,7 +436,7 @@ int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
 
         mm->context.sparc64_ctx_val = 0UL;
 
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         /* We reset it to zero because the fork() page copying
          * will re-increment the counters as the parent PTEs are
          * copied into the child address space.
@@ -462,6 +445,8 @@ int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
         mm->context.huge_pte_count = 0;
 #endif
 
+        mm->context.pgtable_page = NULL;
+
         /* copy_mm() copies over the parent's mm_struct before calling
          * us, so we need to zero out the TSB pointer or else tsb_grow()
          * will be confused and think there is an older TSB to free up.
@@ -474,7 +459,7 @@ int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
          */
         tsb_grow(mm, MM_TSB_BASE, get_mm_rss(mm));
 
-#ifdef CONFIG_HUGETLB_PAGE
+#if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         if (unlikely(huge_pte_count))
                 tsb_grow(mm, MM_TSB_HUGE, huge_pte_count);
 #endif
@@ -500,10 +485,17 @@ static void tsb_destroy_one(struct tsb_config *tp)
 void destroy_context(struct mm_struct *mm)
 {
         unsigned long flags, i;
+        struct page *page;
 
         for (i = 0; i < MM_NUM_TSBS; i++)
                 tsb_destroy_one(&mm->context.tsb_block[i]);
 
+        page = mm->context.pgtable_page;
+        if (page && put_page_testzero(page)) {
+                pgtable_page_dtor(page);
+                free_hot_cold_page(page, 0);
+        }
+
         spin_lock_irqsave(&ctx_alloc_lock, flags);
 
         if (CTX_VALID(mm->context)) {