Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e5098611 authored by Martin Schwidefsky's avatar Martin Schwidefsky
Browse files

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: default avatarGerald Schaefer <gerald.schaefer@de.ibm.com>
Signed-off-by: default avatarMartin Schwidefsky <schwidefsky@de.ibm.com>
parent 416fd0ff

arch/s390/include/asm/hugetlb.h

+33 −102
Original line number Diff line number Diff line
@@ -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)

{

	pte_val(pte) |= _PAGE_RO;

	return pte;

}



static inline int huge_pte_none(pte_t pte)

static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,

				  pte_t *ptep)

{

	return (pte_val(pte) & _SEGMENT_ENTRY_INV) &&

		!(pte_val(pte) & _SEGMENT_ENTRY_RO);

	pte_val(*ptep) = _SEGMENT_ENTRY_EMPTY;

}



static inline pte_t huge_ptep_get(pte_t *ptep)

static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,

					 unsigned long address, pte_t *ptep)

{

	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;

		}

	}

	return pte;

	huge_ptep_get_and_clear(vma->vm_mm, address, ptep);

}



static inline void __pmd_csp(pmd_t *pmdp)

static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,

					     unsigned long addr, pte_t *ptep,

					     pte_t pte, int dirty)

{

	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");

	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);

	}



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;

	return changed;

}



static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,

static inline void huge_ptep_set_wrprotect(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;

	pte_t pte = huge_ptep_get_and_clear(mm, addr, ptep);

	set_huge_pte_at(mm, addr, ptep, pte_wrprotect(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 */