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