710bf935a47368156a4d8f98dac1ab1bd76cdd2d
[muen/linux.git] / arch / arm64 / mm / hugetlbpage.c
1 /*
2  * arch/arm64/mm/hugetlbpage.c
3  *
4  * Copyright (C) 2013 Linaro Ltd.
5  *
6  * Based on arch/x86/mm/hugetlbpage.c.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  */
17
18 #include <linux/init.h>
19 #include <linux/fs.h>
20 #include <linux/mm.h>
21 #include <linux/hugetlb.h>
22 #include <linux/pagemap.h>
23 #include <linux/err.h>
24 #include <linux/sysctl.h>
25 #include <asm/mman.h>
26 #include <asm/tlb.h>
27 #include <asm/tlbflush.h>
28 #include <asm/pgalloc.h>
29
30 int pmd_huge(pmd_t pmd)
31 {
32         return pmd_val(pmd) && !(pmd_val(pmd) & PMD_TABLE_BIT);
33 }
34
35 int pud_huge(pud_t pud)
36 {
37 #ifndef __PAGETABLE_PMD_FOLDED
38         return pud_val(pud) && !(pud_val(pud) & PUD_TABLE_BIT);
39 #else
40         return 0;
41 #endif
42 }
43
44 static int find_num_contig(struct mm_struct *mm, unsigned long addr,
45                            pte_t *ptep, size_t *pgsize)
46 {
47         pgd_t *pgd = pgd_offset(mm, addr);
48         pud_t *pud;
49         pmd_t *pmd;
50
51         *pgsize = PAGE_SIZE;
52         pud = pud_offset(pgd, addr);
53         pmd = pmd_offset(pud, addr);
54         if ((pte_t *)pmd == ptep) {
55                 *pgsize = PMD_SIZE;
56                 return CONT_PMDS;
57         }
58         return CONT_PTES;
59 }
60
61 void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
62                             pte_t *ptep, pte_t pte)
63 {
64         size_t pgsize;
65         int i;
66         int ncontig;
67         unsigned long pfn;
68         pgprot_t hugeprot;
69
70         if (!pte_cont(pte)) {
71                 set_pte_at(mm, addr, ptep, pte);
72                 return;
73         }
74
75         ncontig = find_num_contig(mm, addr, ptep, &pgsize);
76         pfn = pte_pfn(pte);
77         hugeprot = __pgprot(pte_val(pfn_pte(pfn, __pgprot(0))) ^ pte_val(pte));
78         for (i = 0; i < ncontig; i++) {
79                 pr_debug("%s: set pte %p to 0x%llx\n", __func__, ptep,
80                          pte_val(pfn_pte(pfn, hugeprot)));
81                 set_pte_at(mm, addr, ptep, pfn_pte(pfn, hugeprot));
82                 ptep++;
83                 pfn += pgsize >> PAGE_SHIFT;
84                 addr += pgsize;
85         }
86 }
87
88 pte_t *huge_pte_alloc(struct mm_struct *mm,
89                       unsigned long addr, unsigned long sz)
90 {
91         pgd_t *pgd;
92         pud_t *pud;
93         pte_t *pte = NULL;
94
95         pr_debug("%s: addr:0x%lx sz:0x%lx\n", __func__, addr, sz);
96         pgd = pgd_offset(mm, addr);
97         pud = pud_alloc(mm, pgd, addr);
98         if (!pud)
99                 return NULL;
100
101         if (sz == PUD_SIZE) {
102                 pte = (pte_t *)pud;
103         } else if (sz == (PAGE_SIZE * CONT_PTES)) {
104                 pmd_t *pmd = pmd_alloc(mm, pud, addr);
105
106                 WARN_ON(addr & (sz - 1));
107                 /*
108                  * Note that if this code were ever ported to the
109                  * 32-bit arm platform then it will cause trouble in
110                  * the case where CONFIG_HIGHPTE is set, since there
111                  * will be no pte_unmap() to correspond with this
112                  * pte_alloc_map().
113                  */
114                 pte = pte_alloc_map(mm, pmd, addr);
115         } else if (sz == PMD_SIZE) {
116                 if (IS_ENABLED(CONFIG_ARCH_WANT_HUGE_PMD_SHARE) &&
117                     pud_none(*pud))
118                         pte = huge_pmd_share(mm, addr, pud);
119                 else
120                         pte = (pte_t *)pmd_alloc(mm, pud, addr);
121         } else if (sz == (PMD_SIZE * CONT_PMDS)) {
122                 pmd_t *pmd;
123
124                 pmd = pmd_alloc(mm, pud, addr);
125                 WARN_ON(addr & (sz - 1));
126                 return (pte_t *)pmd;
127         }
128
129         pr_debug("%s: addr:0x%lx sz:0x%lx ret pte=%p/0x%llx\n", __func__, addr,
130                sz, pte, pte_val(*pte));
131         return pte;
132 }
133
134 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr)
135 {
136         pgd_t *pgd;
137         pud_t *pud;
138         pmd_t *pmd;
139
140         pgd = pgd_offset(mm, addr);
141         pr_debug("%s: addr:0x%lx pgd:%p\n", __func__, addr, pgd);
142         if (!pgd_present(*pgd))
143                 return NULL;
144
145         pud = pud_offset(pgd, addr);
146         if (pud_none(*pud))
147                 return NULL;
148         /* swap or huge page */
149         if (!pud_present(*pud) || pud_huge(*pud))
150                 return (pte_t *)pud;
151         /* table; check the next level */
152
153         pmd = pmd_offset(pud, addr);
154         if (pmd_none(*pmd))
155                 return NULL;
156         if (!pmd_present(*pmd) || pmd_huge(*pmd))
157                 return (pte_t *)pmd;
158
159         return NULL;
160 }
161
162 pte_t arch_make_huge_pte(pte_t entry, struct vm_area_struct *vma,
163                          struct page *page, int writable)
164 {
165         size_t pagesize = huge_page_size(hstate_vma(vma));
166
167         if (pagesize == CONT_PTE_SIZE) {
168                 entry = pte_mkcont(entry);
169         } else if (pagesize == CONT_PMD_SIZE) {
170                 entry = pmd_pte(pmd_mkcont(pte_pmd(entry)));
171         } else if (pagesize != PUD_SIZE && pagesize != PMD_SIZE) {
172                 pr_warn("%s: unrecognized huge page size 0x%lx\n",
173                         __func__, pagesize);
174         }
175         return entry;
176 }
177
178 pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
179                               unsigned long addr, pte_t *ptep)
180 {
181         pte_t pte;
182
183         if (pte_cont(*ptep)) {
184                 int ncontig, i;
185                 size_t pgsize;
186                 pte_t *cpte;
187                 bool is_dirty = false;
188
189                 cpte = huge_pte_offset(mm, addr);
190                 ncontig = find_num_contig(mm, addr, cpte, &pgsize);
191                 /* save the 1st pte to return */
192                 pte = ptep_get_and_clear(mm, addr, cpte);
193                 for (i = 1, addr += pgsize; i < ncontig; ++i, addr += pgsize) {
194                         /*
195                          * If HW_AFDBM is enabled, then the HW could
196                          * turn on the dirty bit for any of the page
197                          * in the set, so check them all.
198                          */
199                         ++cpte;
200                         if (pte_dirty(ptep_get_and_clear(mm, addr, cpte)))
201                                 is_dirty = true;
202                 }
203                 if (is_dirty)
204                         return pte_mkdirty(pte);
205                 else
206                         return pte;
207         } else {
208                 return ptep_get_and_clear(mm, addr, ptep);
209         }
210 }
211
212 int huge_ptep_set_access_flags(struct vm_area_struct *vma,
213                                unsigned long addr, pte_t *ptep,
214                                pte_t pte, int dirty)
215 {
216         pte_t *cpte;
217
218         if (pte_cont(pte)) {
219                 int ncontig, i, changed = 0;
220                 size_t pgsize = 0;
221                 unsigned long pfn = pte_pfn(pte);
222                 /* Select all bits except the pfn */
223                 pgprot_t hugeprot =
224                         __pgprot(pte_val(pfn_pte(pfn, __pgprot(0))) ^
225                                  pte_val(pte));
226
227                 cpte = huge_pte_offset(vma->vm_mm, addr);
228                 pfn = pte_pfn(*cpte);
229                 ncontig = find_num_contig(vma->vm_mm, addr, cpte,
230                                           &pgsize);
231                 for (i = 0; i < ncontig; ++i, ++cpte, addr += pgsize) {
232                         changed |= ptep_set_access_flags(vma, addr, cpte,
233                                                         pfn_pte(pfn,
234                                                                 hugeprot),
235                                                         dirty);
236                         pfn += pgsize >> PAGE_SHIFT;
237                 }
238                 return changed;
239         } else {
240                 return ptep_set_access_flags(vma, addr, ptep, pte, dirty);
241         }
242 }
243
244 void huge_ptep_set_wrprotect(struct mm_struct *mm,
245                              unsigned long addr, pte_t *ptep)
246 {
247         if (pte_cont(*ptep)) {
248                 int ncontig, i;
249                 pte_t *cpte;
250                 size_t pgsize = 0;
251
252                 cpte = huge_pte_offset(mm, addr);
253                 ncontig = find_num_contig(mm, addr, cpte, &pgsize);
254                 for (i = 0; i < ncontig; ++i, ++cpte, addr += pgsize)
255                         ptep_set_wrprotect(mm, addr, cpte);
256         } else {
257                 ptep_set_wrprotect(mm, addr, ptep);
258         }
259 }
260
261 void huge_ptep_clear_flush(struct vm_area_struct *vma,
262                            unsigned long addr, pte_t *ptep)
263 {
264         if (pte_cont(*ptep)) {
265                 int ncontig, i;
266                 pte_t *cpte;
267                 size_t pgsize = 0;
268
269                 cpte = huge_pte_offset(vma->vm_mm, addr);
270                 ncontig = find_num_contig(vma->vm_mm, addr, cpte,
271                                           &pgsize);
272                 for (i = 0; i < ncontig; ++i, ++cpte, addr += pgsize)
273                         ptep_clear_flush(vma, addr, cpte);
274         } else {
275                 ptep_clear_flush(vma, addr, ptep);
276         }
277 }
278
279 static __init int setup_hugepagesz(char *opt)
280 {
281         unsigned long ps = memparse(opt, &opt);
282
283         if (ps == PMD_SIZE) {
284                 hugetlb_add_hstate(PMD_SHIFT - PAGE_SHIFT);
285         } else if (ps == PUD_SIZE) {
286                 hugetlb_add_hstate(PUD_SHIFT - PAGE_SHIFT);
287         } else {
288                 hugetlb_bad_size();
289                 pr_err("hugepagesz: Unsupported page size %lu K\n", ps >> 10);
290                 return 0;
291         }
292         return 1;
293 }
294 __setup("hugepagesz=", setup_hugepagesz);