Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : #include <linux/mm.h>
3 : : #include <linux/gfp.h>
4 : : #include <linux/hugetlb.h>
5 : : #include <asm/pgalloc.h>
6 : : #include <asm/pgtable.h>
7 : : #include <asm/tlb.h>
8 : : #include <asm/fixmap.h>
9 : : #include <asm/mtrr.h>
10 : :
11 : : #ifdef CONFIG_DYNAMIC_PHYSICAL_MASK
12 : : phys_addr_t physical_mask __ro_after_init = (1ULL << __PHYSICAL_MASK_SHIFT) - 1;
13 : : EXPORT_SYMBOL(physical_mask);
14 : : #endif
15 : :
16 : : #ifdef CONFIG_HIGHPTE
17 : : #define PGTABLE_HIGHMEM __GFP_HIGHMEM
18 : : #else
19 : : #define PGTABLE_HIGHMEM 0
20 : : #endif
21 : :
22 : : gfp_t __userpte_alloc_gfp = GFP_PGTABLE_USER | PGTABLE_HIGHMEM;
23 : :
24 : 2119574 : pgtable_t pte_alloc_one(struct mm_struct *mm)
25 : : {
26 : 2119574 : return __pte_alloc_one(mm, __userpte_alloc_gfp);
27 : : }
28 : :
29 : 0 : static int __init setup_userpte(char *arg)
30 : : {
31 [ # # ]: 0 : if (!arg)
32 : : return -EINVAL;
33 : :
34 : : /*
35 : : * "userpte=nohigh" disables allocation of user pagetables in
36 : : * high memory.
37 : : */
38 [ # # ]: 0 : if (strcmp(arg, "nohigh") == 0)
39 : 0 : __userpte_alloc_gfp &= ~__GFP_HIGHMEM;
40 : : else
41 : : return -EINVAL;
42 : 0 : return 0;
43 : : }
44 : : early_param("userpte", setup_userpte);
45 : :
46 : 2110528 : void ___pte_free_tlb(struct mmu_gather *tlb, struct page *pte)
47 : : {
48 : 2110528 : pgtable_pte_page_dtor(pte);
49 : 2110528 : paravirt_release_pte(page_to_pfn(pte));
50 : 2110528 : paravirt_tlb_remove_table(tlb, pte);
51 : 2110528 : }
52 : :
53 : : #if CONFIG_PGTABLE_LEVELS > 2
54 : 1115674 : void ___pmd_free_tlb(struct mmu_gather *tlb, pmd_t *pmd)
55 : : {
56 [ + - ]: 1115674 : struct page *page = virt_to_page(pmd);
57 : 1115674 : paravirt_release_pmd(__pa(pmd) >> PAGE_SHIFT);
58 : : /*
59 : : * NOTE! For PAE, any changes to the top page-directory-pointer-table
60 : : * entries need a full cr3 reload to flush.
61 : : */
62 : : #ifdef CONFIG_X86_PAE
63 : : tlb->need_flush_all = 1;
64 : : #endif
65 : 1115674 : pgtable_pmd_page_dtor(page);
66 : 1115674 : paravirt_tlb_remove_table(tlb, page);
67 : 1115674 : }
68 : :
69 : : #if CONFIG_PGTABLE_LEVELS > 3
70 : 803041 : void ___pud_free_tlb(struct mmu_gather *tlb, pud_t *pud)
71 : : {
72 [ + - ]: 1606082 : paravirt_release_pud(__pa(pud) >> PAGE_SHIFT);
73 : 803041 : paravirt_tlb_remove_table(tlb, virt_to_page(pud));
74 : 803041 : }
75 : :
76 : : #if CONFIG_PGTABLE_LEVELS > 4
77 : 0 : void ___p4d_free_tlb(struct mmu_gather *tlb, p4d_t *p4d)
78 : : {
79 [ # # ]: 0 : paravirt_release_p4d(__pa(p4d) >> PAGE_SHIFT);
80 : 0 : paravirt_tlb_remove_table(tlb, virt_to_page(p4d));
81 : 0 : }
82 : : #endif /* CONFIG_PGTABLE_LEVELS > 4 */
83 : : #endif /* CONFIG_PGTABLE_LEVELS > 3 */
84 : : #endif /* CONFIG_PGTABLE_LEVELS > 2 */
85 : :
86 : 321067 : static inline void pgd_list_add(pgd_t *pgd)
87 : : {
88 : 321067 : struct page *page = virt_to_page(pgd);
89 : :
90 : 321067 : list_add(&page->lru, &pgd_list);
91 : : }
92 : :
93 : 320356 : static inline void pgd_list_del(pgd_t *pgd)
94 : : {
95 [ + - ]: 320356 : struct page *page = virt_to_page(pgd);
96 : :
97 : 320356 : list_del(&page->lru);
98 : 320356 : }
99 : :
100 : : #define UNSHARED_PTRS_PER_PGD \
101 : : (SHARED_KERNEL_PMD ? KERNEL_PGD_BOUNDARY : PTRS_PER_PGD)
102 : : #define MAX_UNSHARED_PTRS_PER_PGD \
103 : : max_t(size_t, KERNEL_PGD_BOUNDARY, PTRS_PER_PGD)
104 : :
105 : :
106 : 321067 : static void pgd_set_mm(pgd_t *pgd, struct mm_struct *mm)
107 : : {
108 : 642134 : virt_to_page(pgd)->pt_mm = mm;
109 : : }
110 : :
111 : 60 : struct mm_struct *pgd_page_get_mm(struct page *page)
112 : : {
113 : 60 : return page->pt_mm;
114 : : }
115 : :
116 : 321067 : static void pgd_ctor(struct mm_struct *mm, pgd_t *pgd)
117 : : {
118 : : /* If the pgd points to a shared pagetable level (either the
119 : : ptes in non-PAE, or shared PMD in PAE), then just copy the
120 : : references from swapper_pg_dir. */
121 : 321067 : if (CONFIG_PGTABLE_LEVELS == 2 ||
122 : : (CONFIG_PGTABLE_LEVELS == 3 && SHARED_KERNEL_PMD) ||
123 : : CONFIG_PGTABLE_LEVELS >= 4) {
124 : 321067 : clone_pgd_range(pgd + KERNEL_PGD_BOUNDARY,
125 : 321067 : swapper_pg_dir + KERNEL_PGD_BOUNDARY,
126 : 321067 : KERNEL_PGD_PTRS);
127 : : }
128 : :
129 : : /* list required to sync kernel mapping updates */
130 : 321067 : if (!SHARED_KERNEL_PMD) {
131 [ + - ]: 321067 : pgd_set_mm(pgd, mm);
132 : 321067 : pgd_list_add(pgd);
133 : : }
134 : 321067 : }
135 : :
136 : 320356 : static void pgd_dtor(pgd_t *pgd)
137 : : {
138 : 320356 : if (SHARED_KERNEL_PMD)
139 : : return;
140 : :
141 : 320356 : spin_lock(&pgd_lock);
142 : 320356 : pgd_list_del(pgd);
143 : 320356 : spin_unlock(&pgd_lock);
144 : : }
145 : :
146 : : /*
147 : : * List of all pgd's needed for non-PAE so it can invalidate entries
148 : : * in both cached and uncached pgd's; not needed for PAE since the
149 : : * kernel pmd is shared. If PAE were not to share the pmd a similar
150 : : * tactic would be needed. This is essentially codepath-based locking
151 : : * against pageattr.c; it is the unique case in which a valid change
152 : : * of kernel pagetables can't be lazily synchronized by vmalloc faults.
153 : : * vmalloc faults work because attached pagetables are never freed.
154 : : * -- nyc
155 : : */
156 : :
157 : : #ifdef CONFIG_X86_PAE
158 : : /*
159 : : * In PAE mode, we need to do a cr3 reload (=tlb flush) when
160 : : * updating the top-level pagetable entries to guarantee the
161 : : * processor notices the update. Since this is expensive, and
162 : : * all 4 top-level entries are used almost immediately in a
163 : : * new process's life, we just pre-populate them here.
164 : : *
165 : : * Also, if we're in a paravirt environment where the kernel pmd is
166 : : * not shared between pagetables (!SHARED_KERNEL_PMDS), we allocate
167 : : * and initialize the kernel pmds here.
168 : : */
169 : : #define PREALLOCATED_PMDS UNSHARED_PTRS_PER_PGD
170 : : #define MAX_PREALLOCATED_PMDS MAX_UNSHARED_PTRS_PER_PGD
171 : :
172 : : /*
173 : : * We allocate separate PMDs for the kernel part of the user page-table
174 : : * when PTI is enabled. We need them to map the per-process LDT into the
175 : : * user-space page-table.
176 : : */
177 : : #define PREALLOCATED_USER_PMDS (boot_cpu_has(X86_FEATURE_PTI) ? \
178 : : KERNEL_PGD_PTRS : 0)
179 : : #define MAX_PREALLOCATED_USER_PMDS KERNEL_PGD_PTRS
180 : :
181 : : void pud_populate(struct mm_struct *mm, pud_t *pudp, pmd_t *pmd)
182 : : {
183 : : paravirt_alloc_pmd(mm, __pa(pmd) >> PAGE_SHIFT);
184 : :
185 : : /* Note: almost everything apart from _PAGE_PRESENT is
186 : : reserved at the pmd (PDPT) level. */
187 : : set_pud(pudp, __pud(__pa(pmd) | _PAGE_PRESENT));
188 : :
189 : : /*
190 : : * According to Intel App note "TLBs, Paging-Structure Caches,
191 : : * and Their Invalidation", April 2007, document 317080-001,
192 : : * section 8.1: in PAE mode we explicitly have to flush the
193 : : * TLB via cr3 if the top-level pgd is changed...
194 : : */
195 : : flush_tlb_mm(mm);
196 : : }
197 : : #else /* !CONFIG_X86_PAE */
198 : :
199 : : /* No need to prepopulate any pagetable entries in non-PAE modes. */
200 : : #define PREALLOCATED_PMDS 0
201 : : #define MAX_PREALLOCATED_PMDS 0
202 : : #define PREALLOCATED_USER_PMDS 0
203 : : #define MAX_PREALLOCATED_USER_PMDS 0
204 : : #endif /* CONFIG_X86_PAE */
205 : :
206 : 0 : static void free_pmds(struct mm_struct *mm, pmd_t *pmds[], int count)
207 : : {
208 : 0 : int i;
209 : :
210 [ # # ]: 0 : for (i = 0; i < count; i++)
211 [ # # ]: 0 : if (pmds[i]) {
212 : 0 : pgtable_pmd_page_dtor(virt_to_page(pmds[i]));
213 : 0 : free_page((unsigned long)pmds[i]);
214 : 0 : mm_dec_nr_pmds(mm);
215 : : }
216 : 0 : }
217 : :
218 : 642134 : static int preallocate_pmds(struct mm_struct *mm, pmd_t *pmds[], int count)
219 : : {
220 : 642134 : int i;
221 : 642134 : bool failed = false;
222 : 642134 : gfp_t gfp = GFP_PGTABLE_USER;
223 : :
224 [ - + ]: 642134 : if (mm == &init_mm)
225 : 0 : gfp &= ~__GFP_ACCOUNT;
226 : :
227 [ - + ]: 642134 : for (i = 0; i < count; i++) {
228 : 0 : pmd_t *pmd = (pmd_t *)__get_free_page(gfp);
229 [ # # ]: 0 : if (!pmd)
230 : 0 : failed = true;
231 [ # # ]: 0 : if (pmd && !pgtable_pmd_page_ctor(virt_to_page(pmd))) {
232 : : free_page((unsigned long)pmd);
233 : : pmd = NULL;
234 : : failed = true;
235 : : }
236 [ # # ]: 0 : if (pmd)
237 : 0 : mm_inc_nr_pmds(mm);
238 : 0 : pmds[i] = pmd;
239 : : }
240 : :
241 [ - + ]: 642134 : if (failed) {
242 : 0 : free_pmds(mm, pmds, count);
243 : 0 : return -ENOMEM;
244 : : }
245 : :
246 : : return 0;
247 : : }
248 : :
249 : : /*
250 : : * Mop up any pmd pages which may still be attached to the pgd.
251 : : * Normally they will be freed by munmap/exit_mmap, but any pmd we
252 : : * preallocate which never got a corresponding vma will need to be
253 : : * freed manually.
254 : : */
255 : : static void mop_up_one_pmd(struct mm_struct *mm, pgd_t *pgdp)
256 : : {
257 : : pgd_t pgd = *pgdp;
258 : :
259 : : if (pgd_val(pgd) != 0) {
260 : : pmd_t *pmd = (pmd_t *)pgd_page_vaddr(pgd);
261 : :
262 : : pgd_clear(pgdp);
263 : :
264 : : paravirt_release_pmd(pgd_val(pgd) >> PAGE_SHIFT);
265 : : pmd_free(mm, pmd);
266 : : mm_dec_nr_pmds(mm);
267 : : }
268 : : }
269 : :
270 : 320356 : static void pgd_mop_up_pmds(struct mm_struct *mm, pgd_t *pgdp)
271 : : {
272 : 320356 : int i;
273 : :
274 : 320356 : for (i = 0; i < PREALLOCATED_PMDS; i++)
275 : : mop_up_one_pmd(mm, &pgdp[i]);
276 : :
277 : : #ifdef CONFIG_PAGE_TABLE_ISOLATION
278 : :
279 : 320356 : if (!boot_cpu_has(X86_FEATURE_PTI))
280 : : return;
281 : :
282 : 320356 : pgdp = kernel_to_user_pgdp(pgdp);
283 : :
284 : 320356 : for (i = 0; i < PREALLOCATED_USER_PMDS; i++)
285 : : mop_up_one_pmd(mm, &pgdp[i + KERNEL_PGD_BOUNDARY]);
286 : : #endif
287 : : }
288 : :
289 : 321067 : static void pgd_prepopulate_pmd(struct mm_struct *mm, pgd_t *pgd, pmd_t *pmds[])
290 : : {
291 : 321067 : p4d_t *p4d;
292 : 321067 : pud_t *pud;
293 : 321067 : int i;
294 : :
295 : 321067 : if (PREALLOCATED_PMDS == 0) /* Work around gcc-3.4.x bug */
296 : 321067 : return;
297 : :
298 : : p4d = p4d_offset(pgd, 0);
299 : : pud = pud_offset(p4d, 0);
300 : :
301 : : for (i = 0; i < PREALLOCATED_PMDS; i++, pud++) {
302 : : pmd_t *pmd = pmds[i];
303 : :
304 : : if (i >= KERNEL_PGD_BOUNDARY)
305 : : memcpy(pmd, (pmd_t *)pgd_page_vaddr(swapper_pg_dir[i]),
306 : : sizeof(pmd_t) * PTRS_PER_PMD);
307 : :
308 : : pud_populate(mm, pud, pmd);
309 : : }
310 : : }
311 : :
312 : : #ifdef CONFIG_PAGE_TABLE_ISOLATION
313 : 321067 : static void pgd_prepopulate_user_pmd(struct mm_struct *mm,
314 : : pgd_t *k_pgd, pmd_t *pmds[])
315 : : {
316 : 321067 : pgd_t *s_pgd = kernel_to_user_pgdp(swapper_pg_dir);
317 : 321067 : pgd_t *u_pgd = kernel_to_user_pgdp(k_pgd);
318 : 321067 : p4d_t *u_p4d;
319 : 321067 : pud_t *u_pud;
320 : 321067 : int i;
321 : :
322 : 321067 : u_p4d = p4d_offset(u_pgd, 0);
323 : 321067 : u_pud = pud_offset(u_p4d, 0);
324 : :
325 : 321067 : s_pgd += KERNEL_PGD_BOUNDARY;
326 : 321067 : u_pud += KERNEL_PGD_BOUNDARY;
327 : :
328 : 321067 : for (i = 0; i < PREALLOCATED_USER_PMDS; i++, u_pud++, s_pgd++) {
329 : : pmd_t *pmd = pmds[i];
330 : :
331 : : memcpy(pmd, (pmd_t *)pgd_page_vaddr(*s_pgd),
332 : : sizeof(pmd_t) * PTRS_PER_PMD);
333 : :
334 : : pud_populate(mm, u_pud, pmd);
335 : : }
336 : :
337 : : }
338 : : #else
339 : : static void pgd_prepopulate_user_pmd(struct mm_struct *mm,
340 : : pgd_t *k_pgd, pmd_t *pmds[])
341 : : {
342 : : }
343 : : #endif
344 : : /*
345 : : * Xen paravirt assumes pgd table should be in one page. 64 bit kernel also
346 : : * assumes that pgd should be in one page.
347 : : *
348 : : * But kernel with PAE paging that is not running as a Xen domain
349 : : * only needs to allocate 32 bytes for pgd instead of one page.
350 : : */
351 : : #ifdef CONFIG_X86_PAE
352 : :
353 : : #include <linux/slab.h>
354 : :
355 : : #define PGD_SIZE (PTRS_PER_PGD * sizeof(pgd_t))
356 : : #define PGD_ALIGN 32
357 : :
358 : : static struct kmem_cache *pgd_cache;
359 : :
360 : : void __init pgtable_cache_init(void)
361 : : {
362 : : /*
363 : : * When PAE kernel is running as a Xen domain, it does not use
364 : : * shared kernel pmd. And this requires a whole page for pgd.
365 : : */
366 : : if (!SHARED_KERNEL_PMD)
367 : : return;
368 : :
369 : : /*
370 : : * when PAE kernel is not running as a Xen domain, it uses
371 : : * shared kernel pmd. Shared kernel pmd does not require a whole
372 : : * page for pgd. We are able to just allocate a 32-byte for pgd.
373 : : * During boot time, we create a 32-byte slab for pgd table allocation.
374 : : */
375 : : pgd_cache = kmem_cache_create("pgd_cache", PGD_SIZE, PGD_ALIGN,
376 : : SLAB_PANIC, NULL);
377 : : }
378 : :
379 : : static inline pgd_t *_pgd_alloc(void)
380 : : {
381 : : /*
382 : : * If no SHARED_KERNEL_PMD, PAE kernel is running as a Xen domain.
383 : : * We allocate one page for pgd.
384 : : */
385 : : if (!SHARED_KERNEL_PMD)
386 : : return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
387 : : PGD_ALLOCATION_ORDER);
388 : :
389 : : /*
390 : : * Now PAE kernel is not running as a Xen domain. We can allocate
391 : : * a 32-byte slab for pgd to save memory space.
392 : : */
393 : : return kmem_cache_alloc(pgd_cache, GFP_PGTABLE_USER);
394 : : }
395 : :
396 : : static inline void _pgd_free(pgd_t *pgd)
397 : : {
398 : : if (!SHARED_KERNEL_PMD)
399 : : free_pages((unsigned long)pgd, PGD_ALLOCATION_ORDER);
400 : : else
401 : : kmem_cache_free(pgd_cache, pgd);
402 : : }
403 : : #else
404 : :
405 : 321067 : static inline pgd_t *_pgd_alloc(void)
406 : : {
407 : 642134 : return (pgd_t *)__get_free_pages(GFP_PGTABLE_USER,
408 : : PGD_ALLOCATION_ORDER);
409 : : }
410 : :
411 : 320356 : static inline void _pgd_free(pgd_t *pgd)
412 : : {
413 : 320356 : free_pages((unsigned long)pgd, PGD_ALLOCATION_ORDER);
414 : 0 : }
415 : : #endif /* CONFIG_X86_PAE */
416 : :
417 : 321067 : pgd_t *pgd_alloc(struct mm_struct *mm)
418 : : {
419 : 321067 : pgd_t *pgd;
420 : 321067 : pmd_t *u_pmds[MAX_PREALLOCATED_USER_PMDS];
421 : 321067 : pmd_t *pmds[MAX_PREALLOCATED_PMDS];
422 : :
423 : 321067 : pgd = _pgd_alloc();
424 : :
425 [ - + ]: 321067 : if (pgd == NULL)
426 : 0 : goto out;
427 : :
428 : 321067 : mm->pgd = pgd;
429 : :
430 [ - + ]: 321067 : if (preallocate_pmds(mm, pmds, PREALLOCATED_PMDS) != 0)
431 : 0 : goto out_free_pgd;
432 : :
433 [ - + ]: 321067 : if (preallocate_pmds(mm, u_pmds, PREALLOCATED_USER_PMDS) != 0)
434 : 0 : goto out_free_pmds;
435 : :
436 : 321067 : if (paravirt_pgd_alloc(mm) != 0)
437 : : goto out_free_user_pmds;
438 : :
439 : : /*
440 : : * Make sure that pre-populating the pmds is atomic with
441 : : * respect to anything walking the pgd_list, so that they
442 : : * never see a partially populated pgd.
443 : : */
444 : 321067 : spin_lock(&pgd_lock);
445 : :
446 : 321067 : pgd_ctor(mm, pgd);
447 : 321067 : pgd_prepopulate_pmd(mm, pgd, pmds);
448 : 321067 : pgd_prepopulate_user_pmd(mm, pgd, u_pmds);
449 : :
450 : 321067 : spin_unlock(&pgd_lock);
451 : :
452 : 321067 : return pgd;
453 : :
454 : : out_free_user_pmds:
455 : : free_pmds(mm, u_pmds, PREALLOCATED_USER_PMDS);
456 : : out_free_pmds:
457 : 0 : free_pmds(mm, pmds, PREALLOCATED_PMDS);
458 : 0 : out_free_pgd:
459 : 0 : _pgd_free(pgd);
460 : : out:
461 : : return NULL;
462 : : }
463 : :
464 : 320356 : void pgd_free(struct mm_struct *mm, pgd_t *pgd)
465 : : {
466 : 320356 : pgd_mop_up_pmds(mm, pgd);
467 : 320356 : pgd_dtor(pgd);
468 : 320356 : paravirt_pgd_free(mm, pgd);
469 : 320356 : _pgd_free(pgd);
470 : 320356 : }
471 : :
472 : : /*
473 : : * Used to set accessed or dirty bits in the page table entries
474 : : * on other architectures. On x86, the accessed and dirty bits
475 : : * are tracked by hardware. However, do_wp_page calls this function
476 : : * to also make the pte writeable at the same time the dirty bit is
477 : : * set. In that case we do actually need to write the PTE.
478 : : */
479 : 1855383 : int ptep_set_access_flags(struct vm_area_struct *vma,
480 : : unsigned long address, pte_t *ptep,
481 : : pte_t entry, int dirty)
482 : : {
483 [ + - ]: 1855383 : int changed = !pte_same(*ptep, entry);
484 : :
485 [ + - ]: 1855383 : if (changed && dirty)
486 : 1855383 : set_pte(ptep, entry);
487 : :
488 : 1855383 : return changed;
489 : : }
490 : :
491 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
492 : : int pmdp_set_access_flags(struct vm_area_struct *vma,
493 : : unsigned long address, pmd_t *pmdp,
494 : : pmd_t entry, int dirty)
495 : : {
496 : : int changed = !pmd_same(*pmdp, entry);
497 : :
498 : : VM_BUG_ON(address & ~HPAGE_PMD_MASK);
499 : :
500 : : if (changed && dirty) {
501 : : set_pmd(pmdp, entry);
502 : : /*
503 : : * We had a write-protection fault here and changed the pmd
504 : : * to to more permissive. No need to flush the TLB for that,
505 : : * #PF is architecturally guaranteed to do that and in the
506 : : * worst-case we'll generate a spurious fault.
507 : : */
508 : : }
509 : :
510 : : return changed;
511 : : }
512 : :
513 : : int pudp_set_access_flags(struct vm_area_struct *vma, unsigned long address,
514 : : pud_t *pudp, pud_t entry, int dirty)
515 : : {
516 : : int changed = !pud_same(*pudp, entry);
517 : :
518 : : VM_BUG_ON(address & ~HPAGE_PUD_MASK);
519 : :
520 : : if (changed && dirty) {
521 : : set_pud(pudp, entry);
522 : : /*
523 : : * We had a write-protection fault here and changed the pud
524 : : * to to more permissive. No need to flush the TLB for that,
525 : : * #PF is architecturally guaranteed to do that and in the
526 : : * worst-case we'll generate a spurious fault.
527 : : */
528 : : }
529 : :
530 : : return changed;
531 : : }
532 : : #endif
533 : :
534 : 0 : int ptep_test_and_clear_young(struct vm_area_struct *vma,
535 : : unsigned long addr, pte_t *ptep)
536 : : {
537 : 0 : int ret = 0;
538 : :
539 [ # # ]: 0 : if (pte_young(*ptep))
540 : 0 : ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
541 : 0 : (unsigned long *) &ptep->pte);
542 : :
543 : 0 : return ret;
544 : : }
545 : :
546 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
547 : : int pmdp_test_and_clear_young(struct vm_area_struct *vma,
548 : : unsigned long addr, pmd_t *pmdp)
549 : : {
550 : : int ret = 0;
551 : :
552 : : if (pmd_young(*pmdp))
553 : : ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
554 : : (unsigned long *)pmdp);
555 : :
556 : : return ret;
557 : : }
558 : : int pudp_test_and_clear_young(struct vm_area_struct *vma,
559 : : unsigned long addr, pud_t *pudp)
560 : : {
561 : : int ret = 0;
562 : :
563 : : if (pud_young(*pudp))
564 : : ret = test_and_clear_bit(_PAGE_BIT_ACCESSED,
565 : : (unsigned long *)pudp);
566 : :
567 : : return ret;
568 : : }
569 : : #endif
570 : :
571 : 0 : int ptep_clear_flush_young(struct vm_area_struct *vma,
572 : : unsigned long address, pte_t *ptep)
573 : : {
574 : : /*
575 : : * On x86 CPUs, clearing the accessed bit without a TLB flush
576 : : * doesn't cause data corruption. [ It could cause incorrect
577 : : * page aging and the (mistaken) reclaim of hot pages, but the
578 : : * chance of that should be relatively low. ]
579 : : *
580 : : * So as a performance optimization don't flush the TLB when
581 : : * clearing the accessed bit, it will eventually be flushed by
582 : : * a context switch or a VM operation anyway. [ In the rare
583 : : * event of it not getting flushed for a long time the delay
584 : : * shouldn't really matter because there's no real memory
585 : : * pressure for swapout to react to. ]
586 : : */
587 [ # # ]: 0 : return ptep_test_and_clear_young(vma, address, ptep);
588 : : }
589 : :
590 : : #ifdef CONFIG_TRANSPARENT_HUGEPAGE
591 : : int pmdp_clear_flush_young(struct vm_area_struct *vma,
592 : : unsigned long address, pmd_t *pmdp)
593 : : {
594 : : int young;
595 : :
596 : : VM_BUG_ON(address & ~HPAGE_PMD_MASK);
597 : :
598 : : young = pmdp_test_and_clear_young(vma, address, pmdp);
599 : : if (young)
600 : : flush_tlb_range(vma, address, address + HPAGE_PMD_SIZE);
601 : :
602 : : return young;
603 : : }
604 : : #endif
605 : :
606 : : /**
607 : : * reserve_top_address - reserves a hole in the top of kernel address space
608 : : * @reserve - size of hole to reserve
609 : : *
610 : : * Can be used to relocate the fixmap area and poke a hole in the top
611 : : * of kernel address space to make room for a hypervisor.
612 : : */
613 : 0 : void __init reserve_top_address(unsigned long reserve)
614 : : {
615 : : #ifdef CONFIG_X86_32
616 : : BUG_ON(fixmaps_set > 0);
617 : : __FIXADDR_TOP = round_down(-reserve, 1 << PMD_SHIFT) - PAGE_SIZE;
618 : : printk(KERN_INFO "Reserving virtual address space above 0x%08lx (rounded to 0x%08lx)\n",
619 : : -reserve, __FIXADDR_TOP + PAGE_SIZE);
620 : : #endif
621 : 0 : }
622 : :
623 : : int fixmaps_set;
624 : :
625 : 90 : void __native_set_fixmap(enum fixed_addresses idx, pte_t pte)
626 : : {
627 : 90 : unsigned long address = __fix_to_virt(idx);
628 : :
629 : : #ifdef CONFIG_X86_64
630 : : /*
631 : : * Ensure that the static initial page tables are covering the
632 : : * fixmap completely.
633 : : */
634 : 90 : BUILD_BUG_ON(__end_of_permanent_fixed_addresses >
635 : : (FIXMAP_PMD_NUM * PTRS_PER_PTE));
636 : : #endif
637 : :
638 [ - + ]: 90 : if (idx >= __end_of_fixed_addresses) {
639 : 0 : BUG();
640 : : return;
641 : : }
642 : 90 : set_pte_vaddr(address, pte);
643 : 90 : fixmaps_set++;
644 : : }
645 : :
646 : 90 : void native_set_fixmap(unsigned /* enum fixed_addresses */ idx,
647 : : phys_addr_t phys, pgprot_t flags)
648 : : {
649 : : /* Sanitize 'prot' against any unsupported bits: */
650 : 90 : pgprot_val(flags) &= __default_kernel_pte_mask;
651 : :
652 [ + - ]: 180 : __native_set_fixmap(idx, pfn_pte(phys >> PAGE_SHIFT, flags));
653 : 90 : }
654 : :
655 : : #ifdef CONFIG_HAVE_ARCH_HUGE_VMAP
656 : : #ifdef CONFIG_X86_5LEVEL
657 : : /**
658 : : * p4d_set_huge - setup kernel P4D mapping
659 : : *
660 : : * No 512GB pages yet -- always return 0
661 : : */
662 : 0 : int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
663 : : {
664 : 0 : return 0;
665 : : }
666 : :
667 : : /**
668 : : * p4d_clear_huge - clear kernel P4D mapping when it is set
669 : : *
670 : : * No 512GB pages yet -- always return 0
671 : : */
672 : 2280493 : int p4d_clear_huge(p4d_t *p4d)
673 : : {
674 : 2280493 : return 0;
675 : : }
676 : : #endif
677 : :
678 : : /**
679 : : * pud_set_huge - setup kernel PUD mapping
680 : : *
681 : : * MTRRs can override PAT memory types with 4KiB granularity. Therefore, this
682 : : * function sets up a huge page only if any of the following conditions are met:
683 : : *
684 : : * - MTRRs are disabled, or
685 : : *
686 : : * - MTRRs are enabled and the range is completely covered by a single MTRR, or
687 : : *
688 : : * - MTRRs are enabled and the corresponding MTRR memory type is WB, which
689 : : * has no effect on the requested PAT memory type.
690 : : *
691 : : * Callers should try to decrease page size (1GB -> 2MB -> 4K) if the bigger
692 : : * page mapping attempt fails.
693 : : *
694 : : * Returns 1 on success and 0 on failure.
695 : : */
696 : 0 : int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot)
697 : : {
698 : 0 : u8 mtrr, uniform;
699 : :
700 : 0 : mtrr = mtrr_type_lookup(addr, addr + PUD_SIZE, &uniform);
701 [ # # # # : 0 : if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
# # ]
702 : : (mtrr != MTRR_TYPE_WRBACK))
703 : : return 0;
704 : :
705 : : /* Bail out if we are we on a populated non-leaf entry: */
706 [ # # # # : 0 : if (pud_present(*pud) && !pud_huge(*pud))
# # ]
707 : : return 0;
708 : :
709 [ # # ]: 0 : prot = pgprot_4k_2_large(prot);
710 : :
711 [ # # ]: 0 : set_pte((pte_t *)pud, pfn_pte(
712 : : (u64)addr >> PAGE_SHIFT,
713 : : __pgprot(pgprot_val(prot) | _PAGE_PSE)));
714 : :
715 : 0 : return 1;
716 : : }
717 : :
718 : : /**
719 : : * pmd_set_huge - setup kernel PMD mapping
720 : : *
721 : : * See text over pud_set_huge() above.
722 : : *
723 : : * Returns 1 on success and 0 on failure.
724 : : */
725 : 5940 : int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot)
726 : : {
727 : 5940 : u8 mtrr, uniform;
728 : :
729 : 5940 : mtrr = mtrr_type_lookup(addr, addr + PMD_SIZE, &uniform);
730 [ + - - + : 5940 : if ((mtrr != MTRR_TYPE_INVALID) && (!uniform) &&
- - ]
731 : : (mtrr != MTRR_TYPE_WRBACK)) {
732 [ # # ]: 0 : pr_warn_once("%s: Cannot satisfy [mem %#010llx-%#010llx] with a huge-page mapping due to MTRR override.\n",
733 : : __func__, addr, addr + PMD_SIZE);
734 : 0 : return 0;
735 : : }
736 : :
737 : : /* Bail out if we are we on a populated non-leaf entry: */
738 [ + - - + : 11880 : if (pmd_present(*pmd) && !pmd_huge(*pmd))
- - ]
739 : : return 0;
740 : :
741 [ + - ]: 5940 : prot = pgprot_4k_2_large(prot);
742 : :
743 [ + - ]: 5940 : set_pte((pte_t *)pmd, pfn_pte(
744 : : (u64)addr >> PAGE_SHIFT,
745 : : __pgprot(pgprot_val(prot) | _PAGE_PSE)));
746 : :
747 : 5940 : return 1;
748 : : }
749 : :
750 : : /**
751 : : * pud_clear_huge - clear kernel PUD mapping when it is set
752 : : *
753 : : * Returns 1 on success and 0 on failure (no PUD map is found).
754 : : */
755 : 2280493 : int pud_clear_huge(pud_t *pud)
756 : : {
757 [ - + ]: 2280493 : if (pud_large(*pud)) {
758 : 0 : pud_clear(pud);
759 : 0 : return 1;
760 : : }
761 : :
762 : : return 0;
763 : : }
764 : :
765 : : /**
766 : : * pmd_clear_huge - clear kernel PMD mapping when it is set
767 : : *
768 : : * Returns 1 on success and 0 on failure (no PMD map is found).
769 : : */
770 : 2288638 : int pmd_clear_huge(pmd_t *pmd)
771 : : {
772 [ + + + + ]: 4574204 : if (pmd_large(*pmd)) {
773 : 3072 : pmd_clear(pmd);
774 : 3072 : return 1;
775 : : }
776 : :
777 : : return 0;
778 : : }
779 : :
780 : : /*
781 : : * Until we support 512GB pages, skip them in the vmap area.
782 : : */
783 : 0 : int p4d_free_pud_page(p4d_t *p4d, unsigned long addr)
784 : : {
785 : 0 : return 0;
786 : : }
787 : :
788 : : #ifdef CONFIG_X86_64
789 : : /**
790 : : * pud_free_pmd_page - Clear pud entry and free pmd page.
791 : : * @pud: Pointer to a PUD.
792 : : * @addr: Virtual address associated with pud.
793 : : *
794 : : * Context: The pud range has been unmapped and TLB purged.
795 : : * Return: 1 if clearing the entry succeeded. 0 otherwise.
796 : : *
797 : : * NOTE: Callers must allow a single page allocation.
798 : : */
799 : 0 : int pud_free_pmd_page(pud_t *pud, unsigned long addr)
800 : : {
801 : 0 : pmd_t *pmd, *pmd_sv;
802 : 0 : pte_t *pte;
803 : 0 : int i;
804 : :
805 [ # # ]: 0 : pmd = (pmd_t *)pud_page_vaddr(*pud);
806 : 0 : pmd_sv = (pmd_t *)__get_free_page(GFP_KERNEL);
807 [ # # ]: 0 : if (!pmd_sv)
808 : : return 0;
809 : :
810 [ # # ]: 0 : for (i = 0; i < PTRS_PER_PMD; i++) {
811 : 0 : pmd_sv[i] = pmd[i];
812 [ # # ]: 0 : if (!pmd_none(pmd[i]))
813 : 0 : pmd_clear(&pmd[i]);
814 : : }
815 : :
816 : 0 : pud_clear(pud);
817 : :
818 : : /* INVLPG to clear all paging-structure caches */
819 : 0 : flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
820 : :
821 [ # # ]: 0 : for (i = 0; i < PTRS_PER_PMD; i++) {
822 [ # # ]: 0 : if (!pmd_none(pmd_sv[i])) {
823 [ # # ]: 0 : pte = (pte_t *)pmd_page_vaddr(pmd_sv[i]);
824 : 0 : free_page((unsigned long)pte);
825 : : }
826 : : }
827 : :
828 : 0 : free_page((unsigned long)pmd_sv);
829 : 0 : free_page((unsigned long)pmd);
830 : :
831 : 0 : return 1;
832 : : }
833 : :
834 : : /**
835 : : * pmd_free_pte_page - Clear pmd entry and free pte page.
836 : : * @pmd: Pointer to a PMD.
837 : : * @addr: Virtual address associated with pmd.
838 : : *
839 : : * Context: The pmd range has been unmapped and TLB purged.
840 : : * Return: 1 if clearing the entry succeeded. 0 otherwise.
841 : : */
842 : 0 : int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
843 : : {
844 : 0 : pte_t *pte;
845 : :
846 [ # # ]: 0 : pte = (pte_t *)pmd_page_vaddr(*pmd);
847 : 0 : pmd_clear(pmd);
848 : :
849 : : /* INVLPG to clear all paging-structure caches */
850 : 0 : flush_tlb_kernel_range(addr, addr + PAGE_SIZE-1);
851 : :
852 : 0 : free_page((unsigned long)pte);
853 : :
854 : 0 : return 1;
855 : : }
856 : :
857 : : #else /* !CONFIG_X86_64 */
858 : :
859 : : int pud_free_pmd_page(pud_t *pud, unsigned long addr)
860 : : {
861 : : return pud_none(*pud);
862 : : }
863 : :
864 : : /*
865 : : * Disable free page handling on x86-PAE. This assures that ioremap()
866 : : * does not update sync'd pmd entries. See vmalloc_sync_one().
867 : : */
868 : : int pmd_free_pte_page(pmd_t *pmd, unsigned long addr)
869 : : {
870 : : return pmd_none(*pmd);
871 : : }
872 : :
873 : : #endif /* CONFIG_X86_64 */
874 : : #endif /* CONFIG_HAVE_ARCH_HUGE_VMAP */
|
