4 files changed, 45 insertions, 10 deletions

diff --git a/arch/sparc/include/asm/page_64.h b/arch/sparc/include/asm/page_64.h
index 8c2a8c937540..c1263fc390db 100644
--- a/arch/sparc/include/asm/page_64.h
+++ b/arch/sparc/include/asm/page_64.h
@@ -25,6 +25,7 @@
 #define HPAGE_MASK              (~(HPAGE_SIZE - 1UL))
 #define HUGETLB_PAGE_ORDER      (HPAGE_SHIFT - PAGE_SHIFT)
 #define HAVE_ARCH_HUGETLB_UNMAPPED_AREA
+#define REAL_HPAGE_PER_HPAGE    (_AC(1,UL) << (HPAGE_SHIFT - REAL_HPAGE_SHIFT))
 #endif
 
 #ifndef __ASSEMBLY__
diff --git a/arch/sparc/mm/fault_64.c b/arch/sparc/mm/fault_64.c
index e16fdd28a931..3f291d8c57f7 100644
--- a/arch/sparc/mm/fault_64.c
+++ b/arch/sparc/mm/fault_64.c
@@ -484,6 +484,7 @@ good_area:
                 tsb_grow(mm, MM_TSB_BASE, mm_rss);
 #if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
         mm_rss = mm->context.hugetlb_pte_count + mm->context.thp_pte_count;
+        mm_rss *= REAL_HPAGE_PER_HPAGE;
         if (unlikely(mm_rss >
                      mm->context.tsb_block[MM_TSB_HUGE].tsb_rss_limit)) {
                 if (mm->context.tsb_block[MM_TSB_HUGE].tsb)
diff --git a/arch/sparc/mm/tlb.c b/arch/sparc/mm/tlb.c
index 3659d37b4d81..c56a195c9071 100644
--- a/arch/sparc/mm/tlb.c
+++ b/arch/sparc/mm/tlb.c
@@ -174,10 +174,25 @@ void set_pmd_at(struct mm_struct *mm, unsigned long addr,
                 return;
 
         if ((pmd_val(pmd) ^ pmd_val(orig)) & _PAGE_PMD_HUGE) {
-                if (pmd_val(pmd) & _PAGE_PMD_HUGE)
-                        mm->context.thp_pte_count++;
-                else
-                        mm->context.thp_pte_count--;
+                /*
+                 * Note that this routine only sets pmds for THP pages.
+                 * Hugetlb pages are handled elsewhere.  We need to check
+                 * for huge zero page.  Huge zero pages are like hugetlb
+                 * pages in that there is no RSS, but there is the need
+                 * for TSB entries.  So, huge zero page counts go into
+                 * hugetlb_pte_count.
+                 */
+                if (pmd_val(pmd) & _PAGE_PMD_HUGE) {
+                        if (is_huge_zero_page(pmd_page(pmd)))
+                                mm->context.hugetlb_pte_count++;
+                        else
+                                mm->context.thp_pte_count++;
+                } else {
+                        if (is_huge_zero_page(pmd_page(orig)))
+                                mm->context.hugetlb_pte_count--;
+                        else
+                                mm->context.thp_pte_count--;
+                }
 
                 /* Do not try to allocate the TSB hash table if we
                  * don't have one already.  We have various locks held
@@ -204,6 +219,9 @@ void set_pmd_at(struct mm_struct *mm, unsigned long addr,
         }
 }
 
+/*
+ * This routine is only called when splitting a THP
+ */
 void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
                      pmd_t *pmdp)
 {
@@ -213,6 +231,15 @@ void pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
 
         set_pmd_at(vma->vm_mm, address, pmdp, entry);
         flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
+
+        /*
+         * set_pmd_at() will not be called in a way to decrement
+         * thp_pte_count when splitting a THP, so do it now.
+         * Sanity check pmd before doing the actual decrement.
+         */
+        if ((pmd_val(entry) & _PAGE_PMD_HUGE) &&
+            !is_huge_zero_page(pmd_page(entry)))
+                (vma->vm_mm)->context.thp_pte_count--;
 }
 
 void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
diff --git a/arch/sparc/mm/tsb.c b/arch/sparc/mm/tsb.c
index 6725ed45580e..f2b77112e9d8 100644
--- a/arch/sparc/mm/tsb.c
+++ b/arch/sparc/mm/tsb.c
@@ -469,8 +469,10 @@ retry_tsb_alloc:
 
 int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
 {
+        unsigned long mm_rss = get_mm_rss(mm);
 #if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
-        unsigned long total_huge_pte_count;
+        unsigned long saved_hugetlb_pte_count;
+        unsigned long saved_thp_pte_count;
 #endif
         unsigned int i;
 
@@ -483,10 +485,12 @@ int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
          * will re-increment the counters as the parent PTEs are
          * copied into the child address space.
          */
-        total_huge_pte_count = mm->context.hugetlb_pte_count +
-                         mm->context.thp_pte_count;
+        saved_hugetlb_pte_count = mm->context.hugetlb_pte_count;
+        saved_thp_pte_count = mm->context.thp_pte_count;
         mm->context.hugetlb_pte_count = 0;
         mm->context.thp_pte_count = 0;
+
+        mm_rss -= saved_thp_pte_count * (HPAGE_SIZE / PAGE_SIZE);
 #endif
 
         /* copy_mm() copies over the parent's mm_struct before calling
@@ -499,11 +503,13 @@ int init_new_context(struct task_struct *tsk, struct mm_struct *mm)
         /* If this is fork, inherit the parent's TSB size.  We would
          * grow it to that size on the first page fault anyways.
          */
-        tsb_grow(mm, MM_TSB_BASE, get_mm_rss(mm));
+        tsb_grow(mm, MM_TSB_BASE, mm_rss);
 
 #if defined(CONFIG_HUGETLB_PAGE) || defined(CONFIG_TRANSPARENT_HUGEPAGE)
-        if (unlikely(total_huge_pte_count))
-                tsb_grow(mm, MM_TSB_HUGE, total_huge_pte_count);
+        if (unlikely(saved_hugetlb_pte_count + saved_thp_pte_count))
+                tsb_grow(mm, MM_TSB_HUGE,
+                         (saved_hugetlb_pte_count + saved_thp_pte_count) *
+                         REAL_HPAGE_PER_HPAGE);
 #endif
 
         if (unlikely(!mm->context.tsb_block[MM_TSB_BASE].tsb))