arm64: Enable contiguous pte hugepage support
Subsystems (3)
v4 cover arm64: Enable contiguous pte hugepage support
Hi,
This patchset addresses all the known issues with contiguous hugetlb pages. Support for contiguous hugepages is useful on systems where the PMD hugepage size is too large (512MB hugepage when using 64k page granule) and contiguous hugepages can be used to provide reasonable hugepage sizes to the user.
The patches can be split as
* Patches 1-3, 9 cleanups and improvements
* Patch 4 addresses the break-before-make requirement of the architecture for contiguous hugepages. These patches depend on enabling memory failure handling on arm64[2].
* Patch 5-7 add support for handling swap entries for contiguous pte hugepages. These patches depend on fixes to core code required to support contiguous hugepages[3].
* Patch 8 enables contiguous hugepage support for arm64
The patches are based on v4.12-rc2. Previous postings can be found at [0], [1].
All feedback welcome.
Thanks,
Punit
[0] https://www.spinics.net/lists/arm-kernel/msg570422.html
[1] http://lists.infradead.org/pipermail/linux-arm-kernel/2017-March/497027.html
[2] https://www.spinics.net/lists/arm-kernel/msg581657.html
[3] https://www.spinics.net/lists/arm-kernel/msg583342.html
Changes v3 -> v4
* Moved Patches 2 and 4 to [3] due to dependencies
Changes v2 -> v3
* Rebased on v4.12-rc2
* Included swap related fixes in this series
* Enable contiguous pte hugepages
Changes v1 -> v2:
* Marked patch 2 for stable
* Fixed comment issues in patch 7
* Added tags
Punit Agrawal (4):
arm64: hugetlbpages: Handle swap entries in huge_pte_offset() for
contiguous hugepages
arm64: hugetlb: Override huge_pte_clear() to support contiguous
hugepages
arm64: hugetlb: Override set_huge_swap_pte_at() to support contiguous
hugepages
arm64: Re-enable support for contiguous hugepages
Steve Capper (5):
arm64: hugetlb: set_huge_pte_at Add WARN_ON on !pte_present
arm64: hugetlb: Introduce pte_pgprot helper
arm64: hugetlb: Spring clean huge pte accessors
arm64: hugetlb: Add break-before-make logic for contiguous entries
arm64: hugetlb: Cleanup setup_hugepagesz
arch/arm64/include/asm/hugetlb.h | 9 +- arch/arm64/mm/hugetlbpage.c | 287 ++++++++++++++++++++++++++++----------- 2 files changed, 213 insertions(+), 83 deletions(-)
Signature · 1 line
2.11.0
PATCH v4 1/9 arm64: hugetlb: set_huge_pte_at Add WARN_ON on !pte_present
From: Steve Capper <[email protected]>
This patch adds a WARN_ON to set_huge_pte_at as the accessor assumes that entries to be written down are all present. (There are separate accessors to clear huge ptes).
We will need to handle the !pte_present case where memory offlining is used on hugetlb pages. swap and migration entries will be supplied to set_huge_pte_at in this case.
--- arch/arm64/mm/hugetlbpage.c | 6 ++++++ 1 file changed, 6 insertions(+)
arch/arm64/mm/hugetlbpage.c +6 -0
@@ -67,6 +67,12 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,unsigned long pfn;pgprot_t hugeprot; +/* +* Code needs to be expanded to handle huge swap and migration +* entries. Needed for HUGETLB and MEMORY_FAILURE. +*/ +WARN_ON (!pte_present (pte)); +if (!pte_cont (pte)) {set_pte_at (mm, addr, ptep, pte);return ;
Signature · 1 line
2.11.0
PATCH v4 2/9 arm64: hugetlb: Introduce pte_pgprot helper
In reply to Punit AgrawalFrom: Steve Capper <[email protected]>
Rather than xor pte bits in various places, use this helper function.
--- arch/arm64/mm/hugetlbpage.c | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-)
arch/arm64/mm/hugetlbpage.c +12 -4
@@ -41,6 +41,16 @@ int pud_huge(pud_t pud)#endif } +/* +* Select all bits except the pfn +*/ +static inline pgprot_t pte_pgprot (pte_t pte) +{ +unsigned long pfn =pte_pfn (pte); + +return __pgprot (pte_val (pfn_pte (pfn,__pgprot (0 ))) ^pte_val (pte)); +} +static int find_num_contig (struct mm_struct *mm,unsigned long addr,pte_t *ptep,size_t *pgsize) {
@@ -80,7 +90,7 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, ncontig =find_num_contig (mm, addr, ptep, &pgsize); pfn =pte_pfn (pte); - hugeprot =__pgprot (pte_val (pfn_pte (pfn,__pgprot (0 ))) ^pte_val (pte)); + hugeprot =pte_pgprot (pte);for (i =0 ; i < ncontig; i++) {pr_debug ("%s: set pte %p to 0x%llx\n" , __func__, ptep,pte_val (pfn_pte (pfn, hugeprot)));
@@ -223,9 +233,7 @@ int huge_ptep_set_access_flags(struct vm_area_struct *vma,size_t pgsize =0 ;unsigned long pfn =pte_pfn (pte);/* Select all bits except the pfn */ -pgprot_t hugeprot = -__pgprot (pte_val (pfn_pte (pfn,__pgprot (0 ))) ^ -pte_val (pte)); +pgprot_t hugeprot =pte_pgprot (pte); pfn =pte_pfn (pte); ncontig = find_num_contig(vma->vm_mm, addr, ptep,
Signature · 1 line
2.11.0
PATCH v4 3/9 arm64: hugetlb: Spring clean huge pte accessors
In reply to Punit AgrawalFrom: Steve Capper <[email protected]>
This patch aims to re-structure the huge pte accessors without affecting their functionality. Control flow is changed to reduce indentation and expanded use is made of post for loop variable modification.
It is then much easier to add break-before-make semantics in a subsequent patch.
--- arch/arm64/mm/hugetlbpage.c | 119 ++++++++++++++++++++------------------------ 1 file changed, 54 insertions(+), 65 deletions(-)
arch/arm64/mm/hugetlbpage.c +54 -65
@@ -74,7 +74,7 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,size_t pgsize;int i;int ncontig; -unsigned long pfn; +unsigned long pfn, dpfn;pgprot_t hugeprot;/*
@@ -90,14 +90,13 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, ncontig =find_num_contig (mm, addr, ptep, &pgsize); pfn =pte_pfn (pte); + dpfn = pgsize >>PAGE_SHIFT ; hugeprot =pte_pgprot (pte); -for (i =0 ; i < ncontig; i++) { + +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) {pr_debug ("%s: set pte %p to 0x%llx\n" , __func__, ptep,pte_val (pfn_pte (pfn, hugeprot)));set_pte_at (mm, addr, ptep,pfn_pte (pfn, hugeprot)); - ptep++; - pfn += pgsize >>PAGE_SHIFT ; - addr += pgsize; } }
@@ -195,91 +194,81 @@ pte_t arch_make_huge_pte(pte_t entry, struct vm_area_struct *vma,pte_t huge_ptep_get_and_clear (struct mm_struct *mm,unsigned long addr,pte_t *ptep) { -pte_t pte; - -if (pte_cont (*ptep)) { -int ncontig, i; -size_t pgsize; -bool is_dirty = false; - - ncontig =find_num_contig (mm, addr, ptep, &pgsize); -/* save the 1st pte to return */ - pte =ptep_get_and_clear (mm, addr, ptep); -for (i =1 , addr += pgsize; i < ncontig; ++i, addr += pgsize) { -/* -* If HW_AFDBM is enabled, then the HW could -* turn on the dirty bit for any of the page -* in the set, so check them all. -*/ - ++ptep; -if (pte_dirty (ptep_get_and_clear (mm, addr, ptep))) - is_dirty = true; - } -if (is_dirty) -return pte_mkdirty (pte); -else -return pte; - }else { +int ncontig, i; +size_t pgsize; +pte_t orig_pte =huge_ptep_get (ptep); + +if (!pte_cont (orig_pte))return ptep_get_and_clear (mm, addr, ptep); + + ncontig =find_num_contig (mm, addr, ptep, &pgsize); +for (i =0 ; i < ncontig; i++, addr += pgsize, ptep++) { +/* +* If HW_AFDBM is enabled, then the HW could +* turn on the dirty bit for any of the page +* in the set, so check them all. +*/ +if (pte_dirty (ptep_get_and_clear (mm, addr, ptep))) + orig_pte =pte_mkdirty (orig_pte); } + +return orig_pte; }int huge_ptep_set_access_flags (struct vm_area_struct *vma,unsigned long addr,pte_t *ptep,pte_t pte,int dirty) { -if (pte_cont (pte)) { -int ncontig, i, changed =0 ; -size_t pgsize =0 ; -unsigned long pfn =pte_pfn (pte); -/* Select all bits except the pfn */ -pgprot_t hugeprot =pte_pgprot (pte); - - pfn =pte_pfn (pte); - ncontig =find_num_contig (vma->vm_mm, addr, ptep, - &pgsize); -for (i =0 ; i < ncontig; ++i, ++ptep, addr += pgsize) { - changed |=ptep_set_access_flags (vma, addr, ptep, -pfn_pte (pfn, - hugeprot), - dirty); - pfn += pgsize >>PAGE_SHIFT ; - } -return changed; - }else { +int ncontig, i, changed =0 ; +size_t pgsize =0 ; +unsigned long pfn =pte_pfn (pte), dpfn; +pgprot_t hugeprot; + +if (!pte_cont (pte))return ptep_set_access_flags (vma, addr, ptep, pte, dirty); + + ncontig =find_num_contig (vma->vm_mm, addr, ptep, &pgsize); + dpfn = pgsize >>PAGE_SHIFT ; + hugeprot =pte_pgprot (pte); + +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) { + changed |=ptep_set_access_flags (vma, addr, ptep, +pfn_pte (pfn, hugeprot), dirty); } + +return changed; }void huge_ptep_set_wrprotect (struct mm_struct *mm,unsigned long addr,pte_t *ptep) { -if (pte_cont (*ptep)) { -int ncontig, i; -size_t pgsize =0 ; +int ncontig, i; +size_t pgsize; - ncontig =find_num_contig (mm, addr, ptep, &pgsize); -for (i =0 ; i < ncontig; ++i, ++ptep, addr += pgsize) -ptep_set_wrprotect (mm, addr, ptep); - }else { +if (!pte_cont (*ptep)) {ptep_set_wrprotect (mm, addr, ptep); +return ; } + + ncontig =find_num_contig (mm, addr, ptep, &pgsize); +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize) +ptep_set_wrprotect (mm, addr, ptep); }void huge_ptep_clear_flush (struct vm_area_struct *vma,unsigned long addr,pte_t *ptep) { -if (pte_cont (*ptep)) { -int ncontig, i; -size_t pgsize =0 ; - - ncontig =find_num_contig (vma->vm_mm, addr, ptep, - &pgsize); -for (i =0 ; i < ncontig; ++i, ++ptep, addr += pgsize) -ptep_clear_flush (vma, addr, ptep); - }else { +int ncontig, i; +size_t pgsize; + +if (!pte_cont (*ptep)) {ptep_clear_flush (vma, addr, ptep); +return ; } + + ncontig =find_num_contig (vma->vm_mm, addr, ptep, &pgsize); +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize) +ptep_clear_flush (vma, addr, ptep); }static __init int setup_hugepagesz (char *opt)
Signature · 1 line
2.11.0
PATCH v4 4/9 arm64: hugetlb: Add break-before-make logic for contiguous entries
In reply to Punit AgrawalFrom: Steve Capper <[email protected]>
It has become apparent that one has to take special care when modifying attributes of memory mappings that employ the contiguous bit.
Both the requirement and the architecturally correct "Break-Before-Make" technique of updating contiguous entries can be found described in:
ARM DDI 0487A.k_iss10775, "Misprogramming of the Contiguous bit", page D4-1762.
The huge pte accessors currently replace the attributes of contiguous pte entries in place thus can, on certain platforms, lead to TLB conflict aborts or even erroneous results returned from TLB lookups.
This patch adds a helper function get_clear_flush(.) that clears a contiguous entry and returns the head pte (whilst taking care to retain dirty bit information that could have been modified by DBM). A tlb invalidate is performed to then ensure that there is no possibility of multiple tlb entries being present for the same region.
(Fixed indentation and some comments cleanup)
--- arch/arm64/mm/hugetlbpage.c | 81 +++++++++++++++++++++++++++++++++++---------- 1 file changed, 64 insertions(+), 17 deletions(-)
arch/arm64/mm/hugetlbpage.c +64 -17
@@ -68,6 +68,47 @@ static int find_num_contig(struct mm_struct *mm, unsigned long addr,return CONT_PTES ; } +/* +* Changing some bits of contiguous entries requires us to follow a +* Break-Before-Make approach, breaking the whole contiguous set +* before we can change any entries. See ARM DDI 0487A.k_iss10775, +* "Misprogramming of the Contiguous bit", page D4-1762. +* +* This helper performs the break step. +*/ +static pte_t get_clear_flush (struct mm_struct *mm, +unsigned long addr, +pte_t *ptep, +unsigned long pgsize, +unsigned long ncontig) +{ +unsigned long i, saddr = addr; +struct vm_area_struct vma = { .vm_mm = mm }; +pte_t orig_pte =huge_ptep_get (ptep); + +/* +* If we already have a faulting entry then we don't need +* to break before make (there won't be a tlb entry cached). +*/ +if (!pte_present (orig_pte)) +return orig_pte; + +for (i =0 ; i < ncontig; i++, addr += pgsize, ptep++) { +pte_t pte =ptep_get_and_clear (mm, addr, ptep); + +/* +* If HW_AFDBM is enabled, then the HW could turn on +* the dirty bit for any page in the set, so check +* them all. All hugetlb entries are already young. +*/ +if (IS_ENABLED (CONFIG_ARM64_HW_AFDBM ) &&pte_dirty (pte)) + orig_pte =pte_mkdirty (orig_pte); + } + +flush_tlb_range (&vma, saddr, addr); +return orig_pte; +} +void set_huge_pte_at (struct mm_struct *mm,unsigned long addr,pte_t *ptep,pte_t pte) {
@@ -93,6 +134,8 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, dpfn = pgsize >>PAGE_SHIFT ; hugeprot =pte_pgprot (pte); +get_clear_flush (mm, addr, ptep, pgsize, ncontig); +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) {pr_debug ("%s: set pte %p to 0x%llx\n" , __func__, ptep,pte_val (pfn_pte (pfn, hugeprot)));
@@ -194,7 +237,7 @@ pte_t arch_make_huge_pte(pte_t entry, struct vm_area_struct *vma,pte_t huge_ptep_get_and_clear (struct mm_struct *mm,unsigned long addr,pte_t *ptep) { -int ncontig, i; +int ncontig;size_t pgsize;pte_t orig_pte =huge_ptep_get (ptep);
@@ -202,17 +245,8 @@ pte_t huge_ptep_get_and_clear(struct mm_struct *mm,return ptep_get_and_clear (mm, addr, ptep); ncontig =find_num_contig (mm, addr, ptep, &pgsize); -for (i =0 ; i < ncontig; i++, addr += pgsize, ptep++) { -/* -* If HW_AFDBM is enabled, then the HW could -* turn on the dirty bit for any of the page -* in the set, so check them all. -*/ -if (pte_dirty (ptep_get_and_clear (mm, addr, ptep))) - orig_pte =pte_mkdirty (orig_pte); - } -return orig_pte; +return get_clear_flush (mm, addr, ptep, pgsize, ncontig); } int huge_ptep_set_access_flags(struct vm_area_struct *vma,
@@ -222,6 +256,7 @@ int huge_ptep_set_access_flags(struct vm_area_struct *vma,int ncontig, i, changed =0 ;size_t pgsize =0 ;unsigned long pfn =pte_pfn (pte), dpfn; +pte_t orig_pte;pgprot_t hugeprot;if (!pte_cont (pte))
@@ -231,10 +266,12 @@ int huge_ptep_set_access_flags(struct vm_area_struct *vma, dpfn = pgsize >>PAGE_SHIFT ; hugeprot =pte_pgprot (pte); -for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) { - changed |=ptep_set_access_flags (vma, addr, ptep, -pfn_pte (pfn, hugeprot), dirty); - } + orig_pte =get_clear_flush (vma->vm_mm, addr, ptep, pgsize, ncontig); +if (!pte_same (orig_pte, pte)) + changed =1 ; + +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) +set_pte_at (vma->vm_mm, addr, ptep,pfn_pte (pfn, hugeprot));return changed; }
@@ -244,6 +281,9 @@ void huge_ptep_set_wrprotect(struct mm_struct *mm, {int ncontig, i;size_t pgsize; +pte_t pte =pte_wrprotect (huge_ptep_get (ptep)), orig_pte; +unsigned long pfn =pte_pfn (pte), dpfn; +pgprot_t hugeprot;if (!pte_cont (*ptep)) {ptep_set_wrprotect (mm, addr, ptep);
@@ -251,8 +291,15 @@ void huge_ptep_set_wrprotect(struct mm_struct *mm, } ncontig =find_num_contig (mm, addr, ptep, &pgsize); -for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize) -ptep_set_wrprotect (mm, addr, ptep); + dpfn = pgsize >>PAGE_SHIFT ; + + orig_pte =get_clear_flush (mm, addr, ptep, pgsize, ncontig); +if (pte_dirty (orig_pte)) + pte =pte_mkdirty (pte); + + hugeprot =pte_pgprot (pte); +for (i =0 ; i < ncontig; i++, ptep++, addr += pgsize, pfn += dpfn) +set_pte_at (mm, addr, ptep,pfn_pte (pfn, hugeprot)); } void huge_ptep_clear_flush(struct vm_area_struct *vma,
Signature · 1 line
2.11.0
PATCH v4 5/9 arm64: hugetlbpages: Handle swap entries in huge_pte_offset() for contiguous hugepages
In reply to Punit Agrawalhuge_pte_offset() was updated to correctly handle swap entries for hugepages. With the addition of the size parameter, it is now possible to disambiguate whether the request is for a regular hugepage or a contiguous hugepage.
Fix huge_pte_offset() for contiguous hugepages by using the size to find the correct page table entry.
--- arch/arm64/mm/hugetlbpage.c | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-)
arch/arm64/mm/hugetlbpage.c +13 -2
@@ -195,6 +195,7 @@ pte_t *huge_pte_offset(struct mm_struct *mm,pgd_t *pgd;pud_t *pud;pmd_t *pmd; +pte_t *pte; pgd =pgd_offset (mm, addr);pr_debug ("%s: addr:0x%lx pgd:%p\n" , __func__, addr, pgd);
@@ -202,19 +203,29 @@ pte_t *huge_pte_offset(struct mm_struct *mm,return NULL ; pud =pud_offset (pgd, addr); -if (pud_none (*pud)) +if (pud_none (*pud) && sz !=PUD_SIZE )return NULL ;/* swap or huge page */ if (!pud_present (*pud) ||pud_huge (*pud))return (pte_t *)pud;/* table; check the next level */ +if (sz ==CONT_PMD_SIZE ) + addr &=CONT_PMD_MASK ; + pmd =pmd_offset (pud, addr); -if (pmd_none (*pmd)) +if (pmd_none (*pmd) && + !(sz ==PMD_SIZE || sz ==CONT_PMD_SIZE ))return NULL ;if (!pmd_present (*pmd) ||pmd_huge (*pmd))return (pte_t *)pmd; +if (sz ==CONT_PTE_SIZE ) { + pte =pte_offset_kernel ( + pmd, (addr &CONT_PTE_MASK )); +return pte; + } +return NULL ; }
Signature · 1 line
2.11.0
PATCH v4 6/9 arm64: hugetlb: Override huge_pte_clear() to support contiguous hugepages
In reply to Punit AgrawalThe default huge_pte_clear() implementation does not clear contiguous page table entries when it encounters contiguous hugepages that are supported on arm64.
Fix this by overriding the default implementation to clear all the entries associated with contiguous hugepages.
--- arch/arm64/include/asm/hugetlb.h | 6 +++++- arch/arm64/mm/hugetlbpage.c | 36 ++++++++++++++++++++++++++++++++++++ 2 files changed, 41 insertions(+), 1 deletion(-)
arch/arm64/include/asm/hugetlb.h +5 -1
@@ -18,7 +18,6 @@#ifndef __ASM_HUGETLB_H#define __ASM_HUGETLB_H -#include <asm-generic/hugetlb.h> #include <asm/page.h> static inline pte_t huge_ptep_get (pte_t *ptep)
@@ -82,5 +81,10 @@ extern void huge_ptep_set_wrprotect(struct mm_struct *mm, unsigned long addr, pte_t *ptep);extern void huge_ptep_clear_flush (struct vm_area_struct *vma,unsigned long addr,pte_t *ptep); +extern void huge_pte_clear (struct mm_struct *mm,unsigned long addr, +pte_t *ptep,unsigned long sz); +#define huge_pte_clear huge_pte_clear + +#include <asm-generic/hugetlb.h> #endif /* __ASM_HUGETLB_H */
arch/arm64/mm/hugetlbpage.c +36 -0
@@ -68,6 +68,30 @@ static int find_num_contig(struct mm_struct *mm, unsigned long addr,return CONT_PTES ; } +static inline int num_contig_ptes (unsigned long size,size_t *pgsize) +{ +int contig_ptes =0 ; + + *pgsize = size; + +switch (size) { +case PUD_SIZE : +case PMD_SIZE : + contig_ptes =1 ; +break ; +case CONT_PMD_SIZE : + *pgsize =PMD_SIZE ; + contig_ptes =CONT_PMDS ; +break ; +case CONT_PTE_SIZE : + *pgsize =PAGE_SIZE ; + contig_ptes =CONT_PTES ; +break ; + } + +return contig_ptes; +} +/* * Changing some bits of contiguous entries requires us to follow a * Break-Before-Make approach, breaking the whole contiguous set
@@ -245,6 +269,18 @@ pte_t arch_make_huge_pte(pte_t entry, struct vm_area_struct *vma,return entry; } +void huge_pte_clear (struct mm_struct *mm,unsigned long addr, +pte_t *ptep,unsigned long sz) +{ +int i, ncontig; +size_t pgsize; + + ncontig =num_contig_ptes (sz, &pgsize); + +for (i =0 ; i < ncontig; i++, addr += pgsize, ptep++) +pte_clear (mm, addr, ptep); +} +pte_t huge_ptep_get_and_clear (struct mm_struct *mm,unsigned long addr,pte_t *ptep) {
Signature · 1 line
2.11.0
PATCH v4 7/9 arm64: hugetlb: Override set_huge_swap_pte_at() to support contiguous hugepages
In reply to Punit AgrawalThe default implementation of set_huge_swap_pte_at() does not support hugepages consisting of contiguous ptes. Override it to add support for contiguous hugepages.
--- arch/arm64/include/asm/hugetlb.h | 3 +++ arch/arm64/mm/hugetlbpage.c | 12 ++++++++++++ 2 files changed, 15 insertions(+)
arch/arm64/include/asm/hugetlb.h +3 -0
@@ -84,6 +84,9 @@ extern void huge_ptep_clear_flush(struct vm_area_struct *vma,extern void huge_pte_clear (struct mm_struct *mm,unsigned long addr,pte_t *ptep,unsigned long sz);#define huge_pte_clear huge_pte_clear +extern void set_huge_swap_pte_at (struct mm_struct *mm,unsigned long addr, +pte_t *ptep,pte_t pte,unsigned long sz); +#define set_huge_swap_pte_at set_huge_swap_pte_at#include <asm-generic/hugetlb.h>
arch/arm64/mm/hugetlbpage.c +12 -0
@@ -167,6 +167,18 @@ void set_huge_pte_at(struct mm_struct *mm, unsigned long addr, } } +void set_huge_swap_pte_at (struct mm_struct *mm,unsigned long addr, +pte_t *ptep,pte_t pte,unsigned long sz) +{ +int i, ncontig; +size_t pgsize; + + ncontig =num_contig_ptes (sz, &pgsize); + +for (i =0 ; i < ncontig; i++, ptep++) +set_pte (ptep, pte); +} +pte_t *huge_pte_alloc (struct mm_struct *mm,unsigned long addr,unsigned long sz) {
Signature · 1 line
2.11.0
PATCH v4 8/9 arm64: Re-enable support for contiguous hugepages
In reply to Punit Agrawalalso known as -
Revert "Revert "Revert "arm64: hugetlb: partial revert of 66b3923a1a0f"""
Now that our hugetlb implementation is compliant with the break-before-make requirements of the architecture and we have addressed some of the issues in core code required for properly dealing with hardware poisoning of contiguous hugepages let's re-enable support for contiguous hugepages.
This reverts commit 6ae979ab39a368c18ceb0424bf824d172d6ab56f.
--- arch/arm64/mm/hugetlbpage.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
arch/arm64/mm/hugetlbpage.c +14 -0
@@ -385,6 +385,10 @@ static __init int setup_hugepagesz(char *opt)hugetlb_add_hstate (PMD_SHIFT -PAGE_SHIFT ); }else if (ps ==PUD_SIZE ) {hugetlb_add_hstate (PUD_SHIFT -PAGE_SHIFT ); + }else if (ps == (PAGE_SIZE *CONT_PTES )) { +hugetlb_add_hstate (CONT_PTE_SHIFT ); + }else if (ps == (PMD_SIZE *CONT_PMDS )) { +hugetlb_add_hstate ((PMD_SHIFT +CONT_PMD_SHIFT ) -PAGE_SHIFT ); }else {hugetlb_bad_size ();pr_err ("hugepagesz: Unsupported page size %lu K\n" , ps >>10 );
@@ -393,3 +397,13 @@ static __init int setup_hugepagesz(char *opt)return 1 ; }__setup ("hugepagesz=" , setup_hugepagesz); + +#ifdef CONFIG_ARM64_64K_PAGES +static __init int add_default_hugepagesz (void ) +{ +if (size_to_hstate (CONT_PTES *PAGE_SIZE ) ==NULL ) +hugetlb_add_hstate (CONT_PTE_SHIFT ); +return 0 ; +} +arch_initcall (add_default_hugepagesz); +#endif
Signature · 1 line
2.11.0
PATCH v4 9/9 arm64: hugetlb: Cleanup setup_hugepagesz
In reply to Punit AgrawalFrom: Steve Capper <[email protected]>
Replace a lot of if statements with switch and case labels to make it much clearer which huge page sizes are supported.
Also, we prevent PUD_SIZE from being used on systems not running with 4KB PAGE_SIZE. Before if one supplied PUD_SIZE in these circumstances, then unusuable huge page sizes would be in use.
--- arch/arm64/mm/hugetlbpage.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
arch/arm64/mm/hugetlbpage.c +13 -13
@@ -381,20 +381,20 @@ static __init int setup_hugepagesz(char *opt) {unsigned long ps =memparse (opt, &opt); -if (ps ==PMD_SIZE ) { -hugetlb_add_hstate (PMD_SHIFT -PAGE_SHIFT ); - }else if (ps ==PUD_SIZE ) { -hugetlb_add_hstate (PUD_SHIFT -PAGE_SHIFT ); - }else if (ps == (PAGE_SIZE *CONT_PTES )) { -hugetlb_add_hstate (CONT_PTE_SHIFT ); - }else if (ps == (PMD_SIZE *CONT_PMDS )) { -hugetlb_add_hstate ((PMD_SHIFT +CONT_PMD_SHIFT ) -PAGE_SHIFT ); - }else { -hugetlb_bad_size (); -pr_err ("hugepagesz: Unsupported page size %lu K\n" , ps >>10 ); -return 0 ; +switch (ps) { +#ifdef CONFIG_ARM64_4K_PAGES +case PUD_SIZE : +#endif +case PMD_SIZE *CONT_PMDS : +case PMD_SIZE : +case PAGE_SIZE *CONT_PTES : +hugetlb_add_hstate (ilog2 (ps) -PAGE_SHIFT ); +return 1 ; } -return 1 ; + +hugetlb_bad_size (); +pr_err ("hugepagesz: Unsupported page size %lu K\n" , ps >>10 ); +return 0 ; }__setup ("hugepagesz=" , setup_hugepagesz);
Signature · 1 line
2.11.0