arch/arm/include/asm/hugetlb.h

   1 /*
   2  * hugetlb.h, ARM Huge Tlb Page support.
   3  *
   4  * Copyright (c) Bill Carson
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  13  * See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  18  *
  19  */
  20
  21 #ifndef __ASM_HUGETLB_H
  22 #define __ASM_HUGETLB_H
  23
  24 #include <asm/page.h>
  25 #include <asm/pgtable-2level.h>
  26 #include <asm/tlb.h>
  27
  28
  29 /* 2M and 16M hugepage linux ptes are stored in mmu_context_t->huge_linux_pte
  30  *
  31  * 2M hugepage
  32  * ===========
  33  * one huge linux pte caters to two HW ptes,
  34  *
  35  * 16M hugepage
  36  * ============
  37  * one huge linux pte caters for sixteen HW ptes,
  38  *
  39  * The number of huge linux ptes depends on PAGE_OFFSET configuration
  40  * which is defined as following:
  41  */
  42 #define HUGE_LINUX_PTE_COUNT    ( PAGE_OFFSET >> HPAGE_SHIFT)
  43 #define HUGE_LINUX_PTE_SIZE             (HUGE_LINUX_PTE_COUNT * sizeof(pte_t *))
  44 #define HUGE_LINUX_PTE_INDEX(addr) (addr >> HPAGE_SHIFT)
  45
  46 static inline int is_hugepage_only_range(struct mm_struct *mm,
  47                                          unsigned long addr,
  48                                          unsigned long len)
  49 {
  50         return 0;
  51 }
  52
  53 static inline int prepare_hugepage_range(struct file *file,
  54                                          unsigned long addr,
  55                                          unsigned long len)
  56 {
  57         struct hstate *h = hstate_file(file);
  58         /* addr/len should be aligned with huge page size */
  59         if (len & ~huge_page_mask(h))
  60                 return -EINVAL;
  61         if (addr & ~huge_page_mask(h))
  62                 return -EINVAL;
  63
  64         return 0;
  65 }
  66
  67 static inline void hugetlb_prefault_arch_hook(struct mm_struct *mm)
  68 {
  69 }
  70
  71 static inline void hugetlb_free_pgd_range(struct mmu_gather *tlb,
  72                         unsigned long addr, unsigned long end,
  73                         unsigned long floor, unsigned long ceiling)
  74 {
  75 }
  76
  77 static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
  78                                    pte_t *ptep, pte_t pte)
  79 {
  80         pgd_t *pgd;
  81         pud_t *pud;
  82         pmd_t *pmd;
  83         pte_t *linuxpte = mm->context.huge_linux_pte;
  84
  85         BUG_ON(linuxpte == NULL);
  86         BUG_ON(HUGE_LINUX_PTE_INDEX(addr) >= HUGE_LINUX_PTE_COUNT);
  87         BUG_ON(ptep != &linuxpte[HUGE_LINUX_PTE_INDEX(addr)]);
  88
  89         /* set huge linux pte first */
  90         *ptep = pte;
  91
  92         /* then set hardware pte */
  93         addr &= HPAGE_MASK;
  94         pgd = pgd_offset(mm, addr);
  95         pud = pud_offset(pgd, addr);
  96         pmd = pmd_offset(pud, addr);
  97         set_hugepte_at(mm, addr, pmd, pte);
  98 }
  99
 100 static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
 101                                             unsigned long addr, pte_t *ptep)
 102 {
 103         pte_t pte = *ptep;
 104         pte_t fake = L_PTE_YOUNG;
 105         pgd_t *pgd;
 106         pud_t *pud;
 107         pmd_t *pmd;
 108
 109         /* clear linux pte */
 110         *ptep = 0;
 111
 112         /* let set_hugepte_at clear HW entry */
 113         addr &= HPAGE_MASK;
 114         pgd = pgd_offset(mm, addr);
 115         pud = pud_offset(pgd, addr);
 116         pmd = pmd_offset(pud, addr);
 117         set_hugepte_at(mm, addr, pmd, fake);
 118         return pte;
 119 }
 120
 121 static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
 122                                          unsigned long addr, pte_t *ptep)
 123 {
 124         if (HPAGE_SHIFT == SUPERSECTION_SHIFT)
 125                 flush_tlb_page(vma, addr & SUPERSECTION_MASK);
 126         else {
 127                 flush_tlb_page(vma, addr & SECTION_MASK);
 128                 flush_tlb_page(vma, (addr & SECTION_MASK)^0x100000);
 129         }
 130 }
 131
 132 static inline int huge_pte_none(pte_t pte)
 133 {
 134         return pte_none(pte);
 135 }
 136
 137 static inline pte_t huge_pte_wrprotect(pte_t pte)
 138 {
 139         return pte_wrprotect(pte);
 140 }
 141
 142 static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
 143                                            unsigned long addr, pte_t *ptep)
 144 {
 145         pte_t old_pte = *ptep;
 146         set_huge_pte_at(mm, addr, ptep, pte_wrprotect(old_pte));
 147 }
 148
 149 static inline pte_t huge_ptep_get(pte_t *ptep)
 150 {
 151         return *ptep;
 152 }
 153
 154 static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,
 155                                              unsigned long addr,
 156                                              pte_t *ptep, pte_t pte,
 157                                              int dirty)
 158 {
 159         int changed = !pte_same(huge_ptep_get(ptep), pte);
 160         if (changed) {
 161                 set_huge_pte_at(vma->vm_mm, addr, ptep, pte);
 162                 huge_ptep_clear_flush(vma, addr, &pte);
 163         }
 164
 165         return changed;
 166 }
 167
 168 static inline int arch_prepare_hugepage(struct page *page)
 169 {
 170         return 0;
 171 }
 172
 173 static inline void arch_release_hugepage(struct page *page)
 174 {
 175 }
 176
 177 #endif /* __ASM_HUGETLB_H */
 178