s390/mm: cleanup page table definitions

Improve the encoding of the different pte types and the naming of the
page, segment table and region table bits. Due to the different pte
encoding the hugetlbfs primitives need to be adapted as well. To improve
compatability with common code make the huge ptes use the encoding of
normal ptes. The conversion between the pte and pmd encoding for a huge
pte is done with set_huge_pte_at and huge_ptep_get.
Overall the code is now easier to understand.

Reviewed-by: Gerald Schaefer <gerald.schaefer@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 33 insertions, 102 deletions

diff --git a/arch/s390/include/asm/hugetlb.h b/arch/s390/include/asm/hugetlb.h
index bd90359d6d22..11eae5f55b70 100644
--- a/arch/s390/include/asm/hugetlb.h
+++ b/arch/s390/include/asm/hugetlb.h
@@ -17,6 +17,9 @@
 
 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
                      pte_t *ptep, pte_t pte);
+pte_t huge_ptep_get(pte_t *ptep);
+pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
+                              unsigned long addr, pte_t *ptep);
 
 /*
  * If the arch doesn't supply something else, assume that hugepage
@@ -38,147 +41,75 @@ static inline int prepare_hugepage_range(struct file *file,
 int arch_prepare_hugepage(struct page *page);
 void arch_release_hugepage(struct page *page);
 
-static inline pte_t huge_pte_wrprotect(pte_t pte)
+static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,
+                                  pte_t *ptep)
 {
-        pte_val(pte) |= _PAGE_RO;
-        return pte;
+        pte_val(*ptep) = _SEGMENT_ENTRY_EMPTY;
 }
 
-static inline int huge_pte_none(pte_t pte)
+static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
+                                         unsigned long address, pte_t *ptep)
 {
-        return (pte_val(pte) & _SEGMENT_ENTRY_INV) &&
-                !(pte_val(pte) & _SEGMENT_ENTRY_RO);
+        huge_ptep_get_and_clear(vma->vm_mm, address, ptep);
 }
 
-static inline pte_t huge_ptep_get(pte_t *ptep)
+static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,
+                                             unsigned long addr, pte_t *ptep,
+                                             pte_t pte, int dirty)
 {
-        pte_t pte = *ptep;
-        unsigned long mask;
-
-        if (!MACHINE_HAS_HPAGE) {
-                ptep = (pte_t *) (pte_val(pte) & _SEGMENT_ENTRY_ORIGIN);
-                if (ptep) {
-                        mask = pte_val(pte) &
-                                (_SEGMENT_ENTRY_INV | _SEGMENT_ENTRY_RO);
-                        pte = pte_mkhuge(*ptep);
-                        pte_val(pte) |= mask;
-                }
+        int changed = !pte_same(huge_ptep_get(ptep), pte);
+        if (changed) {
+                huge_ptep_get_and_clear(vma->vm_mm, addr, ptep);
+                set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
         }
-        return pte;
+        return changed;
 }
 
-static inline void __pmd_csp(pmd_t *pmdp)
+static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
+                                           unsigned long addr, pte_t *ptep)
 {
-        register unsigned long reg2 asm("2") = pmd_val(*pmdp);
-        register unsigned long reg3 asm("3") = pmd_val(*pmdp) |
-                                               _SEGMENT_ENTRY_INV;
-        register unsigned long reg4 asm("4") = ((unsigned long) pmdp) + 5;
-
-        asm volatile(
-                "       csp %1,%3"
-                : "=m" (*pmdp)
-                : "d" (reg2), "d" (reg3), "d" (reg4), "m" (*pmdp) : "cc");
+        pte_t pte = huge_ptep_get_and_clear(mm, addr, ptep);
+        set_huge_pte_at(mm, addr, ptep, pte_wrprotect(pte));
 }
 
-static inline void huge_ptep_invalidate(struct mm_struct *mm,
-                                        unsigned long address, pte_t *ptep)
-{
-        pmd_t *pmdp = (pmd_t *) ptep;
-
-        if (MACHINE_HAS_IDTE)
-                __pmd_idte(address, pmdp);
-        else
-                __pmd_csp(pmdp);
-        pmd_val(*pmdp) = _SEGMENT_ENTRY_INV | _SEGMENT_ENTRY;
-}
-
-static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
-                                            unsigned long addr, pte_t *ptep)
-{
-        pte_t pte = huge_ptep_get(ptep);
-
-        huge_ptep_invalidate(mm, addr, ptep);
-        return pte;
-}
-
-#define huge_ptep_set_access_flags(__vma, __addr, __ptep, __entry, __dirty) \
-({                                                                          \
-        int __changed = !pte_same(huge_ptep_get(__ptep), __entry);          \
-        if (__changed) {                                                    \
-                huge_ptep_invalidate((__vma)->vm_mm, __addr, __ptep);       \
-                set_huge_pte_at((__vma)->vm_mm, __addr, __ptep, __entry);   \
-        }                                                                   \
-        __changed;                                                          \
-})
-
-#define huge_ptep_set_wrprotect(__mm, __addr, __ptep)                   \
-({                                                                      \
-        pte_t __pte = huge_ptep_get(__ptep);                            \
-        if (huge_pte_write(__pte)) {                                    \
-                huge_ptep_invalidate(__mm, __addr, __ptep);             \
-                set_huge_pte_at(__mm, __addr, __ptep,                   \
-                                huge_pte_wrprotect(__pte));             \
-        }                                                               \
-})
-
-static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
-                                         unsigned long address, pte_t *ptep)
+static inline pte_t mk_huge_pte(struct page *page, pgprot_t pgprot)
 {
-        huge_ptep_invalidate(vma->vm_mm, address, ptep);
+        return mk_pte(page, pgprot);
 }
 
-static inline pte_t mk_huge_pte(struct page *page, pgprot_t pgprot)
+static inline int huge_pte_none(pte_t pte)
 {
-        pte_t pte;
-        pmd_t pmd;
-
-        pmd = mk_pmd_phys(page_to_phys(page), pgprot);
-        pte_val(pte) = pmd_val(pmd);
-        return pte;
+        return pte_none(pte);
 }
 
 static inline int huge_pte_write(pte_t pte)
 {
-        pmd_t pmd;
-
-        pmd_val(pmd) = pte_val(pte);
-        return pmd_write(pmd);
+        return pte_write(pte);
 }
 
 static inline int huge_pte_dirty(pte_t pte)
 {
-        /* No dirty bit in the segment table entry. */
-        return 0;
+        return pte_dirty(pte);
 }
 
 static inline pte_t huge_pte_mkwrite(pte_t pte)
 {
-        pmd_t pmd;
-
-        pmd_val(pmd) = pte_val(pte);
-        pte_val(pte) = pmd_val(pmd_mkwrite(pmd));
-        return pte;
+        return pte_mkwrite(pte);
 }
 
 static inline pte_t huge_pte_mkdirty(pte_t pte)
 {
-        /* No dirty bit in the segment table entry. */
-        return pte;
+        return pte_mkdirty(pte);
 }
 
-static inline pte_t huge_pte_modify(pte_t pte, pgprot_t newprot)
+static inline pte_t huge_pte_wrprotect(pte_t pte)
 {
-        pmd_t pmd;
-
-        pmd_val(pmd) = pte_val(pte);
-        pte_val(pte) = pmd_val(pmd_modify(pmd, newprot));
-        return pte;
+        return pte_wrprotect(pte);
 }
 
-static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,
-                                  pte_t *ptep)
+static inline pte_t huge_pte_modify(pte_t pte, pgprot_t newprot)
 {
-        pmd_clear((pmd_t *) ptep);
+        return pte_modify(pte, newprot);
 }
 
 #endif /* _ASM_S390_HUGETLB_H */