Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * Copyright 2002 Andi Kleen, SuSE Labs.
4 : : * Thanks to Ben LaHaise for precious feedback.
5 : : */
6 : : #include <linux/highmem.h>
7 : : #include <linux/memblock.h>
8 : : #include <linux/sched.h>
9 : : #include <linux/mm.h>
10 : : #include <linux/interrupt.h>
11 : : #include <linux/seq_file.h>
12 : : #include <linux/debugfs.h>
13 : : #include <linux/pfn.h>
14 : : #include <linux/percpu.h>
15 : : #include <linux/gfp.h>
16 : : #include <linux/pci.h>
17 : : #include <linux/vmalloc.h>
18 : :
19 : : #include <asm/e820/api.h>
20 : : #include <asm/processor.h>
21 : : #include <asm/tlbflush.h>
22 : : #include <asm/sections.h>
23 : : #include <asm/setup.h>
24 : : #include <linux/uaccess.h>
25 : : #include <asm/pgalloc.h>
26 : : #include <asm/proto.h>
27 : : #include <asm/memtype.h>
28 : : #include <asm/set_memory.h>
29 : :
30 : : #include "../mm_internal.h"
31 : :
32 : : /*
33 : : * The current flushing context - we pass it instead of 5 arguments:
34 : : */
35 : : struct cpa_data {
36 : : unsigned long *vaddr;
37 : : pgd_t *pgd;
38 : : pgprot_t mask_set;
39 : : pgprot_t mask_clr;
40 : : unsigned long numpages;
41 : : unsigned long curpage;
42 : : unsigned long pfn;
43 : : unsigned int flags;
44 : : unsigned int force_split : 1,
45 : : force_static_prot : 1;
46 : : struct page **pages;
47 : : };
48 : :
49 : : enum cpa_warn {
50 : : CPA_CONFLICT,
51 : : CPA_PROTECT,
52 : : CPA_DETECT,
53 : : };
54 : :
55 : : static const int cpa_warn_level = CPA_PROTECT;
56 : :
57 : : /*
58 : : * Serialize cpa() (for !DEBUG_PAGEALLOC which uses large identity mappings)
59 : : * using cpa_lock. So that we don't allow any other cpu, with stale large tlb
60 : : * entries change the page attribute in parallel to some other cpu
61 : : * splitting a large page entry along with changing the attribute.
62 : : */
63 : : static DEFINE_SPINLOCK(cpa_lock);
64 : :
65 : : #define CPA_FLUSHTLB 1
66 : : #define CPA_ARRAY 2
67 : : #define CPA_PAGES_ARRAY 4
68 : : #define CPA_NO_CHECK_ALIAS 8 /* Do not search for aliases */
69 : :
70 : : #ifdef CONFIG_PROC_FS
71 : : static unsigned long direct_pages_count[PG_LEVEL_NUM];
72 : :
73 : 45 : void update_page_count(int level, unsigned long pages)
74 : : {
75 : : /* Protect against CPA */
76 : 45 : spin_lock(&pgd_lock);
77 : 45 : direct_pages_count[level] += pages;
78 : 45 : spin_unlock(&pgd_lock);
79 : 45 : }
80 : :
81 : 70 : static void split_page_count(int level)
82 : : {
83 : 70 : if (direct_pages_count[level] == 0)
84 : : return;
85 : :
86 : 70 : direct_pages_count[level]--;
87 : 70 : direct_pages_count[level - 1] += PTRS_PER_PTE;
88 : : }
89 : :
90 : 3 : void arch_report_meminfo(struct seq_file *m)
91 : : {
92 : 3 : seq_printf(m, "DirectMap4k: %8lu kB\n",
93 : 3 : direct_pages_count[PG_LEVEL_4K] << 2);
94 : : #if defined(CONFIG_X86_64) || defined(CONFIG_X86_PAE)
95 : 3 : seq_printf(m, "DirectMap2M: %8lu kB\n",
96 : 3 : direct_pages_count[PG_LEVEL_2M] << 11);
97 : : #else
98 : : seq_printf(m, "DirectMap4M: %8lu kB\n",
99 : : direct_pages_count[PG_LEVEL_2M] << 12);
100 : : #endif
101 [ - + ]: 3 : if (direct_gbpages)
102 : 0 : seq_printf(m, "DirectMap1G: %8lu kB\n",
103 : 0 : direct_pages_count[PG_LEVEL_1G] << 20);
104 : 3 : }
105 : : #else
106 : : static inline void split_page_count(int level) { }
107 : : #endif
108 : :
109 : : #ifdef CONFIG_X86_CPA_STATISTICS
110 : :
111 : : static unsigned long cpa_1g_checked;
112 : : static unsigned long cpa_1g_sameprot;
113 : : static unsigned long cpa_1g_preserved;
114 : : static unsigned long cpa_2m_checked;
115 : : static unsigned long cpa_2m_sameprot;
116 : : static unsigned long cpa_2m_preserved;
117 : : static unsigned long cpa_4k_install;
118 : :
119 : : static inline void cpa_inc_1g_checked(void)
120 : : {
121 : : cpa_1g_checked++;
122 : : }
123 : :
124 : : static inline void cpa_inc_2m_checked(void)
125 : : {
126 : : cpa_2m_checked++;
127 : : }
128 : :
129 : : static inline void cpa_inc_4k_install(void)
130 : : {
131 : : cpa_4k_install++;
132 : : }
133 : :
134 : : static inline void cpa_inc_lp_sameprot(int level)
135 : : {
136 : : if (level == PG_LEVEL_1G)
137 : : cpa_1g_sameprot++;
138 : : else
139 : : cpa_2m_sameprot++;
140 : : }
141 : :
142 : : static inline void cpa_inc_lp_preserved(int level)
143 : : {
144 : : if (level == PG_LEVEL_1G)
145 : : cpa_1g_preserved++;
146 : : else
147 : : cpa_2m_preserved++;
148 : : }
149 : :
150 : : static int cpastats_show(struct seq_file *m, void *p)
151 : : {
152 : : seq_printf(m, "1G pages checked: %16lu\n", cpa_1g_checked);
153 : : seq_printf(m, "1G pages sameprot: %16lu\n", cpa_1g_sameprot);
154 : : seq_printf(m, "1G pages preserved: %16lu\n", cpa_1g_preserved);
155 : : seq_printf(m, "2M pages checked: %16lu\n", cpa_2m_checked);
156 : : seq_printf(m, "2M pages sameprot: %16lu\n", cpa_2m_sameprot);
157 : : seq_printf(m, "2M pages preserved: %16lu\n", cpa_2m_preserved);
158 : : seq_printf(m, "4K pages set-checked: %16lu\n", cpa_4k_install);
159 : : return 0;
160 : : }
161 : :
162 : : static int cpastats_open(struct inode *inode, struct file *file)
163 : : {
164 : : return single_open(file, cpastats_show, NULL);
165 : : }
166 : :
167 : : static const struct file_operations cpastats_fops = {
168 : : .open = cpastats_open,
169 : : .read = seq_read,
170 : : .llseek = seq_lseek,
171 : : .release = single_release,
172 : : };
173 : :
174 : : static int __init cpa_stats_init(void)
175 : : {
176 : : debugfs_create_file("cpa_stats", S_IRUSR, arch_debugfs_dir, NULL,
177 : : &cpastats_fops);
178 : : return 0;
179 : : }
180 : : late_initcall(cpa_stats_init);
181 : : #else
182 : 0 : static inline void cpa_inc_1g_checked(void) { }
183 : 1903 : static inline void cpa_inc_2m_checked(void) { }
184 : 15750 : static inline void cpa_inc_4k_install(void) { }
185 : : static inline void cpa_inc_lp_sameprot(int level) { }
186 : 276 : static inline void cpa_inc_lp_preserved(int level) { }
187 : : #endif
188 : :
189 : :
190 : : static inline int
191 : 9480 : within(unsigned long addr, unsigned long start, unsigned long end)
192 : : {
193 : 9480 : return addr >= start && addr < end;
194 : : }
195 : :
196 : : static inline int
197 : 411 : within_inclusive(unsigned long addr, unsigned long start, unsigned long end)
198 : : {
199 : 411 : return addr >= start && addr <= end;
200 : : }
201 : :
202 : : #ifdef CONFIG_X86_64
203 : :
204 : 411 : static inline unsigned long highmap_start_pfn(void)
205 : : {
206 : 411 : return __pa_symbol(_text) >> PAGE_SHIFT;
207 : : }
208 : :
209 : 411 : static inline unsigned long highmap_end_pfn(void)
210 : : {
211 : : /* Do not reference physical address outside the kernel. */
212 : 411 : return __pa_symbol(roundup(_brk_end, PMD_SIZE) - 1) >> PAGE_SHIFT;
213 : : }
214 : :
215 : 411 : static bool __cpa_pfn_in_highmap(unsigned long pfn)
216 : : {
217 : : /*
218 : : * Kernel text has an alias mapping at a high address, known
219 : : * here as "highmap".
220 : : */
221 : 411 : return within_inclusive(pfn, highmap_start_pfn(), highmap_end_pfn());
222 : : }
223 : :
224 : : #else
225 : :
226 : : static bool __cpa_pfn_in_highmap(unsigned long pfn)
227 : : {
228 : : /* There is no highmap on 32-bit */
229 : : return false;
230 : : }
231 : :
232 : : #endif
233 : :
234 : : /*
235 : : * See set_mce_nospec().
236 : : *
237 : : * Machine check recovery code needs to change cache mode of poisoned pages to
238 : : * UC to avoid speculative access logging another error. But passing the
239 : : * address of the 1:1 mapping to set_memory_uc() is a fine way to encourage a
240 : : * speculative access. So we cheat and flip the top bit of the address. This
241 : : * works fine for the code that updates the page tables. But at the end of the
242 : : * process we need to flush the TLB and cache and the non-canonical address
243 : : * causes a #GP fault when used by the INVLPG and CLFLUSH instructions.
244 : : *
245 : : * But in the common case we already have a canonical address. This code
246 : : * will fix the top bit if needed and is a no-op otherwise.
247 : : */
248 : 414 : static inline unsigned long fix_addr(unsigned long addr)
249 : : {
250 : : #ifdef CONFIG_X86_64
251 : 414 : return (long)(addr << 1) >> 1;
252 : : #else
253 : : return addr;
254 : : #endif
255 : : }
256 : :
257 : 22737 : static unsigned long __cpa_addr(struct cpa_data *cpa, unsigned long idx)
258 : : {
259 [ - + ]: 22737 : if (cpa->flags & CPA_PAGES_ARRAY) {
260 : 0 : struct page *page = cpa->pages[idx];
261 : :
262 : 0 : if (unlikely(PageHighMem(page)))
263 : : return 0;
264 : :
265 : 0 : return (unsigned long)page_address(page);
266 : : }
267 : :
268 [ - + ]: 22737 : if (cpa->flags & CPA_ARRAY)
269 : 0 : return cpa->vaddr[idx];
270 : :
271 : 22737 : return *cpa->vaddr + idx * PAGE_SIZE;
272 : : }
273 : :
274 : : /*
275 : : * Flushing functions
276 : : */
277 : :
278 : 0 : static void clflush_cache_range_opt(void *vaddr, unsigned int size)
279 : : {
280 : 0 : const unsigned long clflush_size = boot_cpu_data.x86_clflush_size;
281 : 0 : void *p = (void *)((unsigned long)vaddr & ~(clflush_size - 1));
282 : 0 : void *vend = vaddr + size;
283 : :
284 : 0 : if (p >= vend)
285 : : return;
286 : :
287 [ # # # # : 0 : for (; p < vend; p += clflush_size)
# # ]
288 : 0 : clflushopt(p);
289 : : }
290 : :
291 : : /**
292 : : * clflush_cache_range - flush a cache range with clflush
293 : : * @vaddr: virtual start address
294 : : * @size: number of bytes to flush
295 : : *
296 : : * CLFLUSHOPT is an unordered instruction which needs fencing with MFENCE or
297 : : * SFENCE to avoid ordering issues.
298 : : */
299 : 0 : void clflush_cache_range(void *vaddr, unsigned int size)
300 : : {
301 : 0 : mb();
302 [ # # # # ]: 0 : clflush_cache_range_opt(vaddr, size);
303 : 0 : mb();
304 : 0 : }
305 : : EXPORT_SYMBOL_GPL(clflush_cache_range);
306 : :
307 : 0 : void arch_invalidate_pmem(void *addr, size_t size)
308 : : {
309 : 0 : clflush_cache_range(addr, size);
310 : 0 : }
311 : : EXPORT_SYMBOL_GPL(arch_invalidate_pmem);
312 : :
313 : 0 : static void __cpa_flush_all(void *arg)
314 : : {
315 : 0 : unsigned long cache = (unsigned long)arg;
316 : :
317 : : /*
318 : : * Flush all to work around Errata in early athlons regarding
319 : : * large page flushing.
320 : : */
321 : 0 : __flush_tlb_all();
322 : :
323 [ # # # # ]: 0 : if (cache && boot_cpu_data.x86 >= 4)
324 : 0 : wbinvd();
325 : 0 : }
326 : :
327 : 0 : static void cpa_flush_all(unsigned long cache)
328 : : {
329 [ # # # # ]: 0 : BUG_ON(irqs_disabled() && !early_boot_irqs_disabled);
330 : :
331 : 0 : on_each_cpu(__cpa_flush_all, (void *) cache, 1);
332 : 0 : }
333 : :
334 : 222 : static void __cpa_flush_tlb(void *data)
335 : : {
336 : 222 : struct cpa_data *cpa = data;
337 : 222 : unsigned int i;
338 : :
339 [ + + ]: 636 : for (i = 0; i < cpa->numpages; i++)
340 : 414 : __flush_tlb_one_kernel(fix_addr(__cpa_addr(cpa, i)));
341 : 222 : }
342 : :
343 : 237 : static void cpa_flush(struct cpa_data *data, int cache)
344 : : {
345 : 237 : struct cpa_data *cpa = data;
346 : 237 : unsigned int i;
347 : :
348 [ - + - - ]: 237 : BUG_ON(irqs_disabled() && !early_boot_irqs_disabled);
349 : :
350 [ - + ]: 237 : if (cache && !static_cpu_has(X86_FEATURE_CLFLUSH)) {
351 : 0 : cpa_flush_all(cache);
352 : 0 : return;
353 : : }
354 : :
355 [ + + ]: 237 : if (cpa->numpages <= tlb_single_page_flush_ceiling)
356 : 222 : on_each_cpu(__cpa_flush_tlb, cpa, 1);
357 : : else
358 : 15 : flush_tlb_all();
359 : :
360 [ - + ]: 237 : if (!cache)
361 : : return;
362 : :
363 : 0 : mb();
364 [ # # ]: 0 : for (i = 0; i < cpa->numpages; i++) {
365 : 0 : unsigned long addr = __cpa_addr(cpa, i);
366 : 0 : unsigned int level;
367 : :
368 : 0 : pte_t *pte = lookup_address(addr, &level);
369 : :
370 : : /*
371 : : * Only flush present addresses:
372 : : */
373 [ # # # # ]: 0 : if (pte && (pte_val(*pte) & _PAGE_PRESENT))
374 [ # # ]: 0 : clflush_cache_range_opt((void *)fix_addr(addr), PAGE_SIZE);
375 : : }
376 : 0 : mb();
377 : : }
378 : :
379 : 43262 : static bool overlaps(unsigned long r1_start, unsigned long r1_end,
380 : : unsigned long r2_start, unsigned long r2_end)
381 : : {
382 : 43262 : return (r1_start <= r2_end && r1_end >= r2_start) ||
383 : : (r2_start <= r1_end && r2_end >= r1_start);
384 : : }
385 : :
386 : : #ifdef CONFIG_PCI_BIOS
387 : : /*
388 : : * The BIOS area between 640k and 1Mb needs to be executable for PCI BIOS
389 : : * based config access (CONFIG_PCI_GOBIOS) support.
390 : : */
391 : : #define BIOS_PFN PFN_DOWN(BIOS_BEGIN)
392 : : #define BIOS_PFN_END PFN_DOWN(BIOS_END - 1)
393 : :
394 : : static pgprotval_t protect_pci_bios(unsigned long spfn, unsigned long epfn)
395 : : {
396 : : if (pcibios_enabled && overlaps(spfn, epfn, BIOS_PFN, BIOS_PFN_END))
397 : : return _PAGE_NX;
398 : : return 0;
399 : : }
400 : : #else
401 : 17884 : static pgprotval_t protect_pci_bios(unsigned long spfn, unsigned long epfn)
402 : : {
403 : 17884 : return 0;
404 : : }
405 : : #endif
406 : :
407 : : /*
408 : : * The .rodata section needs to be read-only. Using the pfn catches all
409 : : * aliases. This also includes __ro_after_init, so do not enforce until
410 : : * kernel_set_to_readonly is true.
411 : : */
412 : 17884 : static pgprotval_t protect_rodata(unsigned long spfn, unsigned long epfn)
413 : : {
414 : 17884 : unsigned long epfn_ro, spfn_ro = PFN_DOWN(__pa_symbol(__start_rodata));
415 : :
416 : : /*
417 : : * Note: __end_rodata is at page aligned and not inclusive, so
418 : : * subtract 1 to get the last enforced PFN in the rodata area.
419 : : */
420 : 17884 : epfn_ro = PFN_DOWN(__pa_symbol(__end_rodata)) - 1;
421 : :
422 [ + + ]: 12817 : if (kernel_set_to_readonly && overlaps(spfn, epfn, spfn_ro, epfn_ro))
423 : 45 : return _PAGE_RW;
424 : : return 0;
425 : : }
426 : :
427 : : /*
428 : : * Protect kernel text against becoming non executable by forbidding
429 : : * _PAGE_NX. This protects only the high kernel mapping (_text -> _etext)
430 : : * out of which the kernel actually executes. Do not protect the low
431 : : * mapping.
432 : : *
433 : : * This does not cover __inittext since that is gone after boot.
434 : : */
435 : 17884 : static pgprotval_t protect_kernel_text(unsigned long start, unsigned long end)
436 : : {
437 : 17884 : unsigned long t_end = (unsigned long)_etext - 1;
438 : 17884 : unsigned long t_start = (unsigned long)_text;
439 : :
440 : 17884 : if (overlaps(start, end, t_start, t_end))
441 : 147 : return _PAGE_NX;
442 : : return 0;
443 : : }
444 : :
445 : : #if defined(CONFIG_X86_64)
446 : : /*
447 : : * Once the kernel maps the text as RO (kernel_set_to_readonly is set),
448 : : * kernel text mappings for the large page aligned text, rodata sections
449 : : * will be always read-only. For the kernel identity mappings covering the
450 : : * holes caused by this alignment can be anything that user asks.
451 : : *
452 : : * This will preserve the large page mappings for kernel text/data at no
453 : : * extra cost.
454 : : */
455 : 15705 : static pgprotval_t protect_kernel_text_ro(unsigned long start,
456 : : unsigned long end)
457 : : {
458 : 15705 : unsigned long t_end = (unsigned long)__end_rodata_hpage_align - 1;
459 : 15705 : unsigned long t_start = (unsigned long)_text;
460 : 15705 : unsigned int level;
461 : :
462 [ + + + + ]: 15705 : if (!kernel_set_to_readonly || !overlaps(start, end, t_start, t_end))
463 : : return 0;
464 : : /*
465 : : * Don't enforce the !RW mapping for the kernel text mapping, if
466 : : * the current mapping is already using small page mapping. No
467 : : * need to work hard to preserve large page mappings in this case.
468 : : *
469 : : * This also fixes the Linux Xen paravirt guest boot failure caused
470 : : * by unexpected read-only mappings for kernel identity
471 : : * mappings. In this paravirt guest case, the kernel text mapping
472 : : * and the kernel identity mapping share the same page-table pages,
473 : : * so the protections for kernel text and identity mappings have to
474 : : * be the same.
475 : : */
476 [ + - - + ]: 5745 : if (lookup_address(start, &level) && (level != PG_LEVEL_4K))
477 : 0 : return _PAGE_RW;
478 : : return 0;
479 : : }
480 : : #else
481 : : static pgprotval_t protect_kernel_text_ro(unsigned long start,
482 : : unsigned long end)
483 : : {
484 : : return 0;
485 : : }
486 : : #endif
487 : :
488 : 68529 : static inline bool conflicts(pgprot_t prot, pgprotval_t val)
489 : : {
490 : 68529 : return (pgprot_val(prot) & ~val) != pgprot_val(prot);
491 : : }
492 : :
493 : 69357 : static inline void check_conflict(int warnlvl, pgprot_t prot, pgprotval_t val,
494 : : unsigned long start, unsigned long end,
495 : : unsigned long pfn, const char *txt)
496 : : {
497 : 69357 : static const char *lvltxt[] = {
498 : : [CPA_CONFLICT] = "conflict",
499 : : [CPA_PROTECT] = "protect",
500 : : [CPA_DETECT] = "detect",
501 : : };
502 : :
503 [ + + - + ]: 69357 : if (warnlvl > cpa_warn_level || !conflicts(prot, val))
504 : : return;
505 : :
506 : 0 : pr_warn("CPA %8s %10s: 0x%016lx - 0x%016lx PFN %lx req %016llx prevent %016llx\n",
507 : : lvltxt[warnlvl], txt, start, end, pfn, (unsigned long long)pgprot_val(prot),
508 : : (unsigned long long)val);
509 : : }
510 : :
511 : : /*
512 : : * Certain areas of memory on x86 require very specific protection flags,
513 : : * for example the BIOS area or kernel text. Callers don't always get this
514 : : * right (again, ioremap() on BIOS memory is not uncommon) so this function
515 : : * checks and fixes these known static required protection bits.
516 : : */
517 : 17929 : static inline pgprot_t static_protections(pgprot_t prot, unsigned long start,
518 : : unsigned long pfn, unsigned long npg,
519 : : unsigned long lpsize, int warnlvl)
520 : : {
521 : 17929 : pgprotval_t forbidden, res;
522 : 17929 : unsigned long end;
523 : :
524 : : /*
525 : : * There is no point in checking RW/NX conflicts when the requested
526 : : * mapping is setting the page !PRESENT.
527 : : */
528 [ + + ]: 17929 : if (!(pgprot_val(prot) & _PAGE_PRESENT))
529 : 45 : return prot;
530 : :
531 : : /* Operate on the virtual address */
532 : 17884 : end = start + npg * PAGE_SIZE - 1;
533 : :
534 [ + + ]: 17884 : res = protect_kernel_text(start, end);
535 : 17884 : check_conflict(warnlvl, prot, res, start, end, pfn, "Text NX");
536 : 17884 : forbidden = res;
537 : :
538 : : /*
539 : : * Special case to preserve a large page. If the change spawns the
540 : : * full large page mapping then there is no point to split it
541 : : * up. Happens with ftrace and is going to be removed once ftrace
542 : : * switched to text_poke().
543 : : */
544 [ + + - + ]: 17884 : if (lpsize != (npg * PAGE_SIZE) || (start & (lpsize - 1))) {
545 : 15705 : res = protect_kernel_text_ro(start, end);
546 : 15705 : check_conflict(warnlvl, prot, res, start, end, pfn, "Text RO");
547 : 15705 : forbidden |= res;
548 : : }
549 : :
550 : : /* Check the PFN directly */
551 : 17884 : res = protect_pci_bios(pfn, pfn + npg - 1);
552 : 17884 : check_conflict(warnlvl, prot, res, start, end, pfn, "PCIBIOS NX");
553 : 17884 : forbidden |= res;
554 : :
555 [ + + ]: 17884 : res = protect_rodata(pfn, pfn + npg - 1);
556 : 17884 : check_conflict(warnlvl, prot, res, start, end, pfn, "Rodata RO");
557 : 17884 : forbidden |= res;
558 : :
559 : 17884 : return __pgprot(pgprot_val(prot) & ~forbidden);
560 : : }
561 : :
562 : : /*
563 : : * Lookup the page table entry for a virtual address in a specific pgd.
564 : : * Return a pointer to the entry and the level of the mapping.
565 : : */
566 : 25392 : pte_t *lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
567 : : unsigned int *level)
568 : : {
569 : 25392 : p4d_t *p4d;
570 : 25392 : pud_t *pud;
571 : 25392 : pmd_t *pmd;
572 : :
573 : 25392 : *level = PG_LEVEL_NONE;
574 : :
575 [ + - ]: 25392 : if (pgd_none(*pgd))
576 : : return NULL;
577 : :
578 : 25392 : p4d = p4d_offset(pgd, address);
579 [ + - ]: 25392 : if (p4d_none(*p4d))
580 : : return NULL;
581 : :
582 : 25392 : *level = PG_LEVEL_512G;
583 [ + - ]: 25392 : if (p4d_large(*p4d) || !p4d_present(*p4d))
584 : : return (pte_t *)p4d;
585 : :
586 [ + - ]: 25392 : pud = pud_offset(p4d, address);
587 [ + - ]: 25392 : if (pud_none(*pud))
588 : : return NULL;
589 : :
590 : 25392 : *level = PG_LEVEL_1G;
591 [ + - + - ]: 50784 : if (pud_large(*pud) || !pud_present(*pud))
592 : : return (pte_t *)pud;
593 : :
594 [ + - ]: 25392 : pmd = pmd_offset(pud, address);
595 [ + - ]: 25392 : if (pmd_none(*pmd))
596 : : return NULL;
597 : :
598 : 25392 : *level = PG_LEVEL_2M;
599 [ + + + + : 46887 : if (pmd_large(*pmd) || !pmd_present(*pmd))
+ - ]
600 : : return (pte_t *)pmd;
601 : :
602 : 21495 : *level = PG_LEVEL_4K;
603 : :
604 [ + - ]: 42990 : return pte_offset_kernel(pmd, address);
605 : : }
606 : :
607 : : /*
608 : : * Lookup the page table entry for a virtual address. Return a pointer
609 : : * to the entry and the level of the mapping.
610 : : *
611 : : * Note: We return pud and pmd either when the entry is marked large
612 : : * or when the present bit is not set. Otherwise we would return a
613 : : * pointer to a nonexisting mapping.
614 : : */
615 : 5766 : pte_t *lookup_address(unsigned long address, unsigned int *level)
616 : : {
617 : 5745 : return lookup_address_in_pgd(pgd_offset_k(address), address, level);
618 : : }
619 : : EXPORT_SYMBOL_GPL(lookup_address);
620 : :
621 : : /*
622 : : * Lookup the page table entry for a virtual address in a given mm. Return a
623 : : * pointer to the entry and the level of the mapping.
624 : : */
625 : 0 : pte_t *lookup_address_in_mm(struct mm_struct *mm, unsigned long address,
626 : : unsigned int *level)
627 : : {
628 : 0 : return lookup_address_in_pgd(pgd_offset(mm, address), address, level);
629 : : }
630 : : EXPORT_SYMBOL_GPL(lookup_address_in_mm);
631 : :
632 : : static pte_t *_lookup_address_cpa(struct cpa_data *cpa, unsigned long address,
633 : : unsigned int *level)
634 : : {
635 : : if (cpa->pgd)
636 : : return lookup_address_in_pgd(cpa->pgd + pgd_index(address),
637 : : address, level);
638 : :
639 : : return lookup_address(address, level);
640 : : }
641 : :
642 : : /*
643 : : * Lookup the PMD entry for a virtual address. Return a pointer to the entry
644 : : * or NULL if not present.
645 : : */
646 : 0 : pmd_t *lookup_pmd_address(unsigned long address)
647 : : {
648 : 0 : pgd_t *pgd;
649 : 0 : p4d_t *p4d;
650 : 0 : pud_t *pud;
651 : :
652 : 0 : pgd = pgd_offset_k(address);
653 [ # # ]: 0 : if (pgd_none(*pgd))
654 : : return NULL;
655 : :
656 : 0 : p4d = p4d_offset(pgd, address);
657 [ # # # # ]: 0 : if (p4d_none(*p4d) || p4d_large(*p4d) || !p4d_present(*p4d))
658 : : return NULL;
659 : :
660 [ # # ]: 0 : pud = pud_offset(p4d, address);
661 [ # # # # : 0 : if (pud_none(*pud) || pud_large(*pud) || !pud_present(*pud))
# # ]
662 : : return NULL;
663 : :
664 : 0 : return pmd_offset(pud, address);
665 : : }
666 : :
667 : : /*
668 : : * This is necessary because __pa() does not work on some
669 : : * kinds of memory, like vmalloc() or the alloc_remap()
670 : : * areas on 32-bit NUMA systems. The percpu areas can
671 : : * end up in this kind of memory, for instance.
672 : : *
673 : : * This could be optimized, but it is only intended to be
674 : : * used at inititalization time, and keeping it
675 : : * unoptimized should increase the testing coverage for
676 : : * the more obscure platforms.
677 : : */
678 : 21 : phys_addr_t slow_virt_to_phys(void *__virt_addr)
679 : : {
680 : 21 : unsigned long virt_addr = (unsigned long)__virt_addr;
681 : 21 : phys_addr_t phys_addr;
682 : 21 : unsigned long offset;
683 : 21 : enum pg_level level;
684 : 21 : pte_t *pte;
685 : :
686 : 21 : pte = lookup_address(virt_addr, &level);
687 [ - + ]: 21 : BUG_ON(!pte);
688 : :
689 : : /*
690 : : * pXX_pfn() returns unsigned long, which must be cast to phys_addr_t
691 : : * before being left-shifted PAGE_SHIFT bits -- this trick is to
692 : : * make 32-PAE kernel work correctly.
693 : : */
694 [ - + - ]: 21 : switch (level) {
695 : 0 : case PG_LEVEL_1G:
696 [ # # ]: 0 : phys_addr = (phys_addr_t)pud_pfn(*(pud_t *)pte) << PAGE_SHIFT;
697 : 0 : offset = virt_addr & ~PUD_PAGE_MASK;
698 : 0 : break;
699 : 21 : case PG_LEVEL_2M:
700 [ + - ]: 21 : phys_addr = (phys_addr_t)pmd_pfn(*(pmd_t *)pte) << PAGE_SHIFT;
701 : 21 : offset = virt_addr & ~PMD_PAGE_MASK;
702 : 21 : break;
703 : 0 : default:
704 [ # # ]: 0 : phys_addr = (phys_addr_t)pte_pfn(*pte) << PAGE_SHIFT;
705 : 0 : offset = virt_addr & ~PAGE_MASK;
706 : : }
707 : :
708 : 21 : return (phys_addr_t)(phys_addr | offset);
709 : : }
710 : : EXPORT_SYMBOL_GPL(slow_virt_to_phys);
711 : :
712 : : /*
713 : : * Set the new pmd in all the pgds we know about:
714 : : */
715 : 346 : static void __set_pmd_pte(pte_t *kpte, unsigned long address, pte_t pte)
716 : : {
717 : : /* change init_mm */
718 : 70 : set_pte_atomic(kpte, pte);
719 : : #ifdef CONFIG_X86_32
720 : : if (!SHARED_KERNEL_PMD) {
721 : : struct page *page;
722 : :
723 : : list_for_each_entry(page, &pgd_list, lru) {
724 : : pgd_t *pgd;
725 : : p4d_t *p4d;
726 : : pud_t *pud;
727 : : pmd_t *pmd;
728 : :
729 : : pgd = (pgd_t *)page_address(page) + pgd_index(address);
730 : : p4d = p4d_offset(pgd, address);
731 : : pud = pud_offset(p4d, address);
732 : : pmd = pmd_offset(pud, address);
733 : : set_pte_atomic((pte_t *)pmd, pte);
734 : : }
735 : : }
736 : : #endif
737 : : }
738 : :
739 : 17723 : static pgprot_t pgprot_clear_protnone_bits(pgprot_t prot)
740 : : {
741 : : /*
742 : : * _PAGE_GLOBAL means "global page" for present PTEs.
743 : : * But, it is also used to indicate _PAGE_PROTNONE
744 : : * for non-present PTEs.
745 : : *
746 : : * This ensures that a _PAGE_GLOBAL PTE going from
747 : : * present to non-present is not confused as
748 : : * _PAGE_PROTNONE.
749 : : */
750 : 17723 : if (!(pgprot_val(prot) & _PAGE_PRESENT))
751 : 46 : pgprot_val(prot) &= ~_PAGE_GLOBAL;
752 : :
753 : 17723 : return prot;
754 : : }
755 : :
756 : 1903 : static int __should_split_large_page(pte_t *kpte, unsigned long address,
757 : : struct cpa_data *cpa)
758 : : {
759 : 1903 : unsigned long numpages, pmask, psize, lpaddr, pfn, old_pfn;
760 : 1903 : pgprot_t old_prot, new_prot, req_prot, chk_prot;
761 : 1903 : pte_t new_pte, *tmp;
762 : 1903 : enum pg_level level;
763 : :
764 : : /*
765 : : * Check for races, another CPU might have split this page
766 : : * up already:
767 : : */
768 : 1903 : tmp = _lookup_address_cpa(cpa, address, &level);
769 [ + - ]: 1903 : if (tmp != kpte)
770 : : return 1;
771 : :
772 [ + - - ]: 1903 : switch (level) {
773 : 1903 : case PG_LEVEL_2M:
774 [ - + ]: 1903 : old_prot = pmd_pgprot(*(pmd_t *)kpte);
775 [ + - ]: 1903 : old_pfn = pmd_pfn(*(pmd_t *)kpte);
776 : 1903 : cpa_inc_2m_checked();
777 : : break;
778 : 0 : case PG_LEVEL_1G:
779 [ # # ]: 0 : old_prot = pud_pgprot(*(pud_t *)kpte);
780 [ # # ]: 0 : old_pfn = pud_pfn(*(pud_t *)kpte);
781 : 0 : cpa_inc_1g_checked();
782 : : break;
783 : : default:
784 : : return -EINVAL;
785 : : }
786 : :
787 [ + + ]: 1903 : psize = page_level_size(level);
788 [ + + ]: 1903 : pmask = page_level_mask(level);
789 : :
790 : : /*
791 : : * Calculate the number of pages, which fit into this large
792 : : * page starting at address:
793 : : */
794 : 1903 : lpaddr = (address + psize) & pmask;
795 : 1903 : numpages = (lpaddr - address) >> PAGE_SHIFT;
796 [ + + ]: 1903 : if (numpages < cpa->numpages)
797 : 186 : cpa->numpages = numpages;
798 : :
799 : : /*
800 : : * We are safe now. Check whether the new pgprot is the same:
801 : : * Convert protection attributes to 4k-format, as cpa->mask* are set
802 : : * up accordingly.
803 : : */
804 : :
805 : : /* Clear PSE (aka _PAGE_PAT) and move PAT bit to correct position */
806 [ + + ]: 1903 : req_prot = pgprot_large_2_4k(old_prot);
807 : :
808 : 1903 : pgprot_val(req_prot) &= ~pgprot_val(cpa->mask_clr);
809 : 1903 : pgprot_val(req_prot) |= pgprot_val(cpa->mask_set);
810 : :
811 : : /*
812 : : * req_prot is in format of 4k pages. It must be converted to large
813 : : * page format: the caching mode includes the PAT bit located at
814 : : * different bit positions in the two formats.
815 : : */
816 [ + + ]: 1903 : req_prot = pgprot_4k_2_large(req_prot);
817 [ + + ]: 1903 : req_prot = pgprot_clear_protnone_bits(req_prot);
818 [ + + ]: 1903 : if (pgprot_val(req_prot) & _PAGE_PRESENT)
819 : 1902 : pgprot_val(req_prot) |= _PAGE_PSE;
820 : :
821 : : /*
822 : : * old_pfn points to the large page base pfn. So we need to add the
823 : : * offset of the virtual address:
824 : : */
825 : 1903 : pfn = old_pfn + ((address & (psize - 1)) >> PAGE_SHIFT);
826 : 1903 : cpa->pfn = pfn;
827 : :
828 : : /*
829 : : * Calculate the large page base address and the number of 4K pages
830 : : * in the large page
831 : : */
832 : 1903 : lpaddr = address & pmask;
833 : 1903 : numpages = psize >> PAGE_SHIFT;
834 : :
835 : : /*
836 : : * Sanity check that the existing mapping is correct versus the static
837 : : * protections. static_protections() guards against !PRESENT, so no
838 : : * extra conditional required here.
839 : : */
840 : 1903 : chk_prot = static_protections(old_prot, lpaddr, old_pfn, numpages,
841 : : psize, CPA_CONFLICT);
842 : :
843 [ - + - + ]: 1903 : if (WARN_ON_ONCE(pgprot_val(chk_prot) != pgprot_val(old_prot))) {
844 : : /*
845 : : * Split the large page and tell the split code to
846 : : * enforce static protections.
847 : : */
848 : 0 : cpa->force_static_prot = 1;
849 : 0 : return 1;
850 : : }
851 : :
852 : : /*
853 : : * Optimization: If the requested pgprot is the same as the current
854 : : * pgprot, then the large page can be preserved and no updates are
855 : : * required independent of alignment and length of the requested
856 : : * range. The above already established that the current pgprot is
857 : : * correct, which in consequence makes the requested pgprot correct
858 : : * as well if it is the same. The static protection scan below will
859 : : * not come to a different conclusion.
860 : : */
861 [ + + ]: 1903 : if (pgprot_val(req_prot) == pgprot_val(old_prot)) {
862 : : cpa_inc_lp_sameprot(level);
863 : : return 0;
864 : : }
865 : :
866 : : /*
867 : : * If the requested range does not cover the full page, split it up
868 : : */
869 [ + + + - ]: 346 : if (address != lpaddr || cpa->numpages != numpages)
870 : : return 1;
871 : :
872 : : /*
873 : : * Check whether the requested pgprot is conflicting with a static
874 : : * protection requirement in the large page.
875 : : */
876 : 276 : new_prot = static_protections(req_prot, lpaddr, old_pfn, numpages,
877 : : psize, CPA_DETECT);
878 : :
879 : : /*
880 : : * If there is a conflict, split the large page.
881 : : *
882 : : * There used to be a 4k wise evaluation trying really hard to
883 : : * preserve the large pages, but experimentation has shown, that this
884 : : * does not help at all. There might be corner cases which would
885 : : * preserve one large page occasionally, but it's really not worth the
886 : : * extra code and cycles for the common case.
887 : : */
888 [ + - ]: 276 : if (pgprot_val(req_prot) != pgprot_val(new_prot))
889 : : return 1;
890 : :
891 : : /* All checks passed. Update the large page mapping. */
892 [ + - ]: 276 : new_pte = pfn_pte(old_pfn, new_prot);
893 : 276 : __set_pmd_pte(kpte, address, new_pte);
894 : 276 : cpa->flags |= CPA_FLUSHTLB;
895 : 276 : cpa_inc_lp_preserved(level);
896 : 276 : return 0;
897 : : }
898 : :
899 : 1903 : static int should_split_large_page(pte_t *kpte, unsigned long address,
900 : : struct cpa_data *cpa)
901 : : {
902 : 1903 : int do_split;
903 : :
904 [ + - ]: 1903 : if (cpa->force_split)
905 : : return 1;
906 : :
907 : 1903 : spin_lock(&pgd_lock);
908 : 1903 : do_split = __should_split_large_page(kpte, address, cpa);
909 : 1903 : spin_unlock(&pgd_lock);
910 : :
911 : 1903 : return do_split;
912 : : }
913 : :
914 : 35840 : static void split_set_pte(struct cpa_data *cpa, pte_t *pte, unsigned long pfn,
915 : : pgprot_t ref_prot, unsigned long address,
916 : : unsigned long size)
917 : : {
918 : 35840 : unsigned int npg = PFN_DOWN(size);
919 : 35840 : pgprot_t prot;
920 : :
921 : : /*
922 : : * If should_split_large_page() discovered an inconsistent mapping,
923 : : * remove the invalid protection in the split mapping.
924 : : */
925 [ + - ]: 35840 : if (!cpa->force_static_prot)
926 : 35840 : goto set;
927 : :
928 : : /* Hand in lpsize = 0 to enforce the protection mechanism */
929 : 0 : prot = static_protections(ref_prot, address, pfn, npg, 0, CPA_PROTECT);
930 : :
931 [ # # ]: 0 : if (pgprot_val(prot) == pgprot_val(ref_prot))
932 : 0 : goto set;
933 : :
934 : : /*
935 : : * If this is splitting a PMD, fix it up. PUD splits cannot be
936 : : * fixed trivially as that would require to rescan the newly
937 : : * installed PMD mappings after returning from split_large_page()
938 : : * so an eventual further split can allocate the necessary PTE
939 : : * pages. Warn for now and revisit it in case this actually
940 : : * happens.
941 : : */
942 [ # # ]: 0 : if (size == PAGE_SIZE)
943 : : ref_prot = prot;
944 : : else
945 [ # # ]: 0 : pr_warn_once("CPA: Cannot fixup static protections for PUD split\n");
946 : 35840 : set:
947 [ + - ]: 35840 : set_pte(pte, pfn_pte(pfn, ref_prot));
948 : 35840 : }
949 : :
950 : : static int
951 : 70 : __split_large_page(struct cpa_data *cpa, pte_t *kpte, unsigned long address,
952 : : struct page *base)
953 : : {
954 : 70 : unsigned long lpaddr, lpinc, ref_pfn, pfn, pfninc = 1;
955 : 70 : pte_t *pbase = (pte_t *)page_address(base);
956 : 70 : unsigned int i, level;
957 : 70 : pgprot_t ref_prot;
958 : 70 : pte_t *tmp;
959 : :
960 : 70 : spin_lock(&pgd_lock);
961 : : /*
962 : : * Check for races, another CPU might have split this page
963 : : * up for us already:
964 : : */
965 : 70 : tmp = _lookup_address_cpa(cpa, address, &level);
966 [ - + ]: 70 : if (tmp != kpte) {
967 : 0 : spin_unlock(&pgd_lock);
968 : 0 : return 1;
969 : : }
970 : :
971 [ + - - ]: 70 : paravirt_alloc_pte(&init_mm, page_to_pfn(base));
972 : :
973 [ + - - ]: 70 : switch (level) {
974 : 70 : case PG_LEVEL_2M:
975 [ - + ]: 70 : ref_prot = pmd_pgprot(*(pmd_t *)kpte);
976 : : /*
977 : : * Clear PSE (aka _PAGE_PAT) and move
978 : : * PAT bit to correct position.
979 : : */
980 [ + - ]: 70 : ref_prot = pgprot_large_2_4k(ref_prot);
981 [ + - ]: 70 : ref_pfn = pmd_pfn(*(pmd_t *)kpte);
982 : 70 : lpaddr = address & PMD_MASK;
983 : 70 : lpinc = PAGE_SIZE;
984 : 70 : break;
985 : :
986 : 0 : case PG_LEVEL_1G:
987 [ # # ]: 0 : ref_prot = pud_pgprot(*(pud_t *)kpte);
988 [ # # ]: 0 : ref_pfn = pud_pfn(*(pud_t *)kpte);
989 : 0 : pfninc = PMD_PAGE_SIZE >> PAGE_SHIFT;
990 : 0 : lpaddr = address & PUD_MASK;
991 : 0 : lpinc = PMD_SIZE;
992 : : /*
993 : : * Clear the PSE flags if the PRESENT flag is not set
994 : : * otherwise pmd_present/pmd_huge will return true
995 : : * even on a non present pmd.
996 : : */
997 [ # # ]: 0 : if (!(pgprot_val(ref_prot) & _PAGE_PRESENT))
998 : 0 : pgprot_val(ref_prot) &= ~_PAGE_PSE;
999 : : break;
1000 : :
1001 : : default:
1002 : 0 : spin_unlock(&pgd_lock);
1003 : 0 : return 1;
1004 : : }
1005 : :
1006 [ - + ]: 70 : ref_prot = pgprot_clear_protnone_bits(ref_prot);
1007 : :
1008 : : /*
1009 : : * Get the target pfn from the original entry:
1010 : : */
1011 : 70 : pfn = ref_pfn;
1012 [ + + ]: 35910 : for (i = 0; i < PTRS_PER_PTE; i++, pfn += pfninc, lpaddr += lpinc)
1013 : 35840 : split_set_pte(cpa, pbase + i, pfn, ref_prot, lpaddr, lpinc);
1014 : :
1015 [ + - ]: 70 : if (virt_addr_valid(address)) {
1016 [ + + ]: 70 : unsigned long pfn = PFN_DOWN(__pa(address));
1017 : :
1018 [ + - ]: 70 : if (pfn_range_is_mapped(pfn, pfn + 1))
1019 [ + - ]: 70 : split_page_count(level);
1020 : : }
1021 : :
1022 : : /*
1023 : : * Install the new, split up pagetable.
1024 : : *
1025 : : * We use the standard kernel pagetable protections for the new
1026 : : * pagetable protections, the actual ptes set above control the
1027 : : * primary protection behavior:
1028 : : */
1029 : 70 : __set_pmd_pte(kpte, address, mk_pte(base, __pgprot(_KERNPG_TABLE)));
1030 : :
1031 : : /*
1032 : : * Do a global flush tlb after splitting the large page
1033 : : * and before we do the actual change page attribute in the PTE.
1034 : : *
1035 : : * Without this, we violate the TLB application note, that says:
1036 : : * "The TLBs may contain both ordinary and large-page
1037 : : * translations for a 4-KByte range of linear addresses. This
1038 : : * may occur if software modifies the paging structures so that
1039 : : * the page size used for the address range changes. If the two
1040 : : * translations differ with respect to page frame or attributes
1041 : : * (e.g., permissions), processor behavior is undefined and may
1042 : : * be implementation-specific."
1043 : : *
1044 : : * We do this global tlb flush inside the cpa_lock, so that we
1045 : : * don't allow any other cpu, with stale tlb entries change the
1046 : : * page attribute in parallel, that also falls into the
1047 : : * just split large page entry.
1048 : : */
1049 : 70 : flush_tlb_all();
1050 : 70 : spin_unlock(&pgd_lock);
1051 : :
1052 : 70 : return 0;
1053 : : }
1054 : :
1055 : 70 : static int split_large_page(struct cpa_data *cpa, pte_t *kpte,
1056 : : unsigned long address)
1057 : : {
1058 : 70 : struct page *base;
1059 : :
1060 : 70 : if (!debug_pagealloc_enabled())
1061 : 70 : spin_unlock(&cpa_lock);
1062 : 70 : base = alloc_pages(GFP_KERNEL, 0);
1063 : 70 : if (!debug_pagealloc_enabled())
1064 : 70 : spin_lock(&cpa_lock);
1065 [ + - ]: 70 : if (!base)
1066 : : return -ENOMEM;
1067 : :
1068 [ - + ]: 70 : if (__split_large_page(cpa, kpte, address, base))
1069 : 0 : __free_page(base);
1070 : :
1071 : : return 0;
1072 : : }
1073 : :
1074 : 0 : static bool try_to_free_pte_page(pte_t *pte)
1075 : : {
1076 : 0 : int i;
1077 : :
1078 [ # # ]: 0 : for (i = 0; i < PTRS_PER_PTE; i++)
1079 [ # # ]: 0 : if (!pte_none(pte[i]))
1080 : : return false;
1081 : :
1082 : 0 : free_page((unsigned long)pte);
1083 : 0 : return true;
1084 : : }
1085 : :
1086 : 0 : static bool try_to_free_pmd_page(pmd_t *pmd)
1087 : : {
1088 : 0 : int i;
1089 : :
1090 [ # # ]: 0 : for (i = 0; i < PTRS_PER_PMD; i++)
1091 [ # # ]: 0 : if (!pmd_none(pmd[i]))
1092 : : return false;
1093 : :
1094 : 0 : free_page((unsigned long)pmd);
1095 : 0 : return true;
1096 : : }
1097 : :
1098 : 0 : static bool unmap_pte_range(pmd_t *pmd, unsigned long start, unsigned long end)
1099 : : {
1100 [ # # ]: 0 : pte_t *pte = pte_offset_kernel(pmd, start);
1101 : :
1102 [ # # ]: 0 : while (start < end) {
1103 : 0 : set_pte(pte, __pte(0));
1104 : :
1105 : 0 : start += PAGE_SIZE;
1106 : 0 : pte++;
1107 : : }
1108 : :
1109 [ # # # # ]: 0 : if (try_to_free_pte_page((pte_t *)pmd_page_vaddr(*pmd))) {
1110 : 0 : pmd_clear(pmd);
1111 : 0 : return true;
1112 : : }
1113 : : return false;
1114 : : }
1115 : :
1116 : 0 : static void __unmap_pmd_range(pud_t *pud, pmd_t *pmd,
1117 : : unsigned long start, unsigned long end)
1118 : : {
1119 [ # # ]: 0 : if (unmap_pte_range(pmd, start, end))
1120 [ # # # # ]: 0 : if (try_to_free_pmd_page((pmd_t *)pud_page_vaddr(*pud)))
1121 : 0 : pud_clear(pud);
1122 : 0 : }
1123 : :
1124 : 0 : static void unmap_pmd_range(pud_t *pud, unsigned long start, unsigned long end)
1125 : : {
1126 [ # # ]: 0 : pmd_t *pmd = pmd_offset(pud, start);
1127 : :
1128 : : /*
1129 : : * Not on a 2MB page boundary?
1130 : : */
1131 [ # # ]: 0 : if (start & (PMD_SIZE - 1)) {
1132 : 0 : unsigned long next_page = (start + PMD_SIZE) & PMD_MASK;
1133 : 0 : unsigned long pre_end = min_t(unsigned long, end, next_page);
1134 : :
1135 : 0 : __unmap_pmd_range(pud, pmd, start, pre_end);
1136 : :
1137 : 0 : start = pre_end;
1138 : 0 : pmd++;
1139 : : }
1140 : :
1141 : : /*
1142 : : * Try to unmap in 2M chunks.
1143 : : */
1144 [ # # ]: 0 : while (end - start >= PMD_SIZE) {
1145 [ # # # # ]: 0 : if (pmd_large(*pmd))
1146 : 0 : pmd_clear(pmd);
1147 : : else
1148 : 0 : __unmap_pmd_range(pud, pmd, start, start + PMD_SIZE);
1149 : :
1150 : 0 : start += PMD_SIZE;
1151 : 0 : pmd++;
1152 : : }
1153 : :
1154 : : /*
1155 : : * 4K leftovers?
1156 : : */
1157 [ # # ]: 0 : if (start < end)
1158 : 0 : return __unmap_pmd_range(pud, pmd, start, end);
1159 : :
1160 : : /*
1161 : : * Try again to free the PMD page if haven't succeeded above.
1162 : : */
1163 [ # # ]: 0 : if (!pud_none(*pud))
1164 [ # # # # ]: 0 : if (try_to_free_pmd_page((pmd_t *)pud_page_vaddr(*pud)))
1165 : 0 : pud_clear(pud);
1166 : : }
1167 : :
1168 : 0 : static void unmap_pud_range(p4d_t *p4d, unsigned long start, unsigned long end)
1169 : : {
1170 [ # # ]: 0 : pud_t *pud = pud_offset(p4d, start);
1171 : :
1172 : : /*
1173 : : * Not on a GB page boundary?
1174 : : */
1175 [ # # ]: 0 : if (start & (PUD_SIZE - 1)) {
1176 : 0 : unsigned long next_page = (start + PUD_SIZE) & PUD_MASK;
1177 : 0 : unsigned long pre_end = min_t(unsigned long, end, next_page);
1178 : :
1179 : 0 : unmap_pmd_range(pud, start, pre_end);
1180 : :
1181 : 0 : start = pre_end;
1182 : 0 : pud++;
1183 : : }
1184 : :
1185 : : /*
1186 : : * Try to unmap in 1G chunks?
1187 : : */
1188 [ # # ]: 0 : while (end - start >= PUD_SIZE) {
1189 : :
1190 [ # # ]: 0 : if (pud_large(*pud))
1191 : 0 : pud_clear(pud);
1192 : : else
1193 : 0 : unmap_pmd_range(pud, start, start + PUD_SIZE);
1194 : :
1195 : 0 : start += PUD_SIZE;
1196 : 0 : pud++;
1197 : : }
1198 : :
1199 : : /*
1200 : : * 2M leftovers?
1201 : : */
1202 [ # # ]: 0 : if (start < end)
1203 : 0 : unmap_pmd_range(pud, start, end);
1204 : :
1205 : : /*
1206 : : * No need to try to free the PUD page because we'll free it in
1207 : : * populate_pgd's error path
1208 : : */
1209 : 0 : }
1210 : :
1211 : 0 : static int alloc_pte_page(pmd_t *pmd)
1212 : : {
1213 : 0 : pte_t *pte = (pte_t *)get_zeroed_page(GFP_KERNEL);
1214 [ # # ]: 0 : if (!pte)
1215 : : return -1;
1216 : :
1217 [ # # ]: 0 : set_pmd(pmd, __pmd(__pa(pte) | _KERNPG_TABLE));
1218 : 0 : return 0;
1219 : : }
1220 : :
1221 : 0 : static int alloc_pmd_page(pud_t *pud)
1222 : : {
1223 : 0 : pmd_t *pmd = (pmd_t *)get_zeroed_page(GFP_KERNEL);
1224 [ # # ]: 0 : if (!pmd)
1225 : : return -1;
1226 : :
1227 [ # # ]: 0 : set_pud(pud, __pud(__pa(pmd) | _KERNPG_TABLE));
1228 : 0 : return 0;
1229 : : }
1230 : :
1231 : : static void populate_pte(struct cpa_data *cpa,
1232 : : unsigned long start, unsigned long end,
1233 : : unsigned num_pages, pmd_t *pmd, pgprot_t pgprot)
1234 : : {
1235 : : pte_t *pte;
1236 : :
1237 : : pte = pte_offset_kernel(pmd, start);
1238 : :
1239 : : pgprot = pgprot_clear_protnone_bits(pgprot);
1240 : :
1241 : : while (num_pages-- && start < end) {
1242 : : set_pte(pte, pfn_pte(cpa->pfn, pgprot));
1243 : :
1244 : : start += PAGE_SIZE;
1245 : : cpa->pfn++;
1246 : : pte++;
1247 : : }
1248 : : }
1249 : :
1250 : 0 : static long populate_pmd(struct cpa_data *cpa,
1251 : : unsigned long start, unsigned long end,
1252 : : unsigned num_pages, pud_t *pud, pgprot_t pgprot)
1253 : : {
1254 : 0 : long cur_pages = 0;
1255 : 0 : pmd_t *pmd;
1256 : 0 : pgprot_t pmd_pgprot;
1257 : :
1258 : : /*
1259 : : * Not on a 2M boundary?
1260 : : */
1261 [ # # ]: 0 : if (start & (PMD_SIZE - 1)) {
1262 : 0 : unsigned long pre_end = start + (num_pages << PAGE_SHIFT);
1263 : 0 : unsigned long next_page = (start + PMD_SIZE) & PMD_MASK;
1264 : :
1265 : 0 : pre_end = min_t(unsigned long, pre_end, next_page);
1266 : 0 : cur_pages = (pre_end - start) >> PAGE_SHIFT;
1267 : 0 : cur_pages = min_t(unsigned int, num_pages, cur_pages);
1268 : :
1269 : : /*
1270 : : * Need a PTE page?
1271 : : */
1272 [ # # ]: 0 : pmd = pmd_offset(pud, start);
1273 [ # # ]: 0 : if (pmd_none(*pmd))
1274 [ # # ]: 0 : if (alloc_pte_page(pmd))
1275 : : return -1;
1276 : :
1277 : 0 : populate_pte(cpa, start, pre_end, cur_pages, pmd, pgprot);
1278 : :
1279 : 0 : start = pre_end;
1280 : : }
1281 : :
1282 : : /*
1283 : : * We mapped them all?
1284 : : */
1285 [ # # ]: 0 : if (num_pages == cur_pages)
1286 : : return cur_pages;
1287 : :
1288 : 0 : pmd_pgprot = pgprot_4k_2_large(pgprot);
1289 : :
1290 [ # # ]: 0 : while (end - start >= PMD_SIZE) {
1291 : :
1292 : : /*
1293 : : * We cannot use a 1G page so allocate a PMD page if needed.
1294 : : */
1295 [ # # ]: 0 : if (pud_none(*pud))
1296 [ # # ]: 0 : if (alloc_pmd_page(pud))
1297 : : return -1;
1298 : :
1299 [ # # ]: 0 : pmd = pmd_offset(pud, start);
1300 : :
1301 [ # # # # ]: 0 : set_pmd(pmd, pmd_mkhuge(pfn_pmd(cpa->pfn,
1302 : : canon_pgprot(pmd_pgprot))));
1303 : :
1304 : 0 : start += PMD_SIZE;
1305 : 0 : cpa->pfn += PMD_SIZE >> PAGE_SHIFT;
1306 : 0 : cur_pages += PMD_SIZE >> PAGE_SHIFT;
1307 : : }
1308 : :
1309 : : /*
1310 : : * Map trailing 4K pages.
1311 : : */
1312 [ # # ]: 0 : if (start < end) {
1313 [ # # ]: 0 : pmd = pmd_offset(pud, start);
1314 [ # # ]: 0 : if (pmd_none(*pmd))
1315 [ # # ]: 0 : if (alloc_pte_page(pmd))
1316 : : return -1;
1317 : :
1318 : 0 : populate_pte(cpa, start, end, num_pages - cur_pages,
1319 : : pmd, pgprot);
1320 : : }
1321 : : return num_pages;
1322 : : }
1323 : :
1324 : 0 : static int populate_pud(struct cpa_data *cpa, unsigned long start, p4d_t *p4d,
1325 : : pgprot_t pgprot)
1326 : : {
1327 : 0 : pud_t *pud;
1328 : 0 : unsigned long end;
1329 : 0 : long cur_pages = 0;
1330 : 0 : pgprot_t pud_pgprot;
1331 : :
1332 : 0 : end = start + (cpa->numpages << PAGE_SHIFT);
1333 : :
1334 : : /*
1335 : : * Not on a Gb page boundary? => map everything up to it with
1336 : : * smaller pages.
1337 : : */
1338 [ # # ]: 0 : if (start & (PUD_SIZE - 1)) {
1339 : 0 : unsigned long pre_end;
1340 : 0 : unsigned long next_page = (start + PUD_SIZE) & PUD_MASK;
1341 : :
1342 : 0 : pre_end = min_t(unsigned long, end, next_page);
1343 : 0 : cur_pages = (pre_end - start) >> PAGE_SHIFT;
1344 : 0 : cur_pages = min_t(int, (int)cpa->numpages, cur_pages);
1345 : :
1346 [ # # ]: 0 : pud = pud_offset(p4d, start);
1347 : :
1348 : : /*
1349 : : * Need a PMD page?
1350 : : */
1351 [ # # ]: 0 : if (pud_none(*pud))
1352 [ # # ]: 0 : if (alloc_pmd_page(pud))
1353 : : return -1;
1354 : :
1355 : 0 : cur_pages = populate_pmd(cpa, start, pre_end, cur_pages,
1356 : : pud, pgprot);
1357 [ # # ]: 0 : if (cur_pages < 0)
1358 : 0 : return cur_pages;
1359 : :
1360 : : start = pre_end;
1361 : : }
1362 : :
1363 : : /* We mapped them all? */
1364 [ # # ]: 0 : if (cpa->numpages == cur_pages)
1365 : 0 : return cur_pages;
1366 : :
1367 : 0 : pud = pud_offset(p4d, start);
1368 : 0 : pud_pgprot = pgprot_4k_2_large(pgprot);
1369 : :
1370 : : /*
1371 : : * Map everything starting from the Gb boundary, possibly with 1G pages
1372 : : */
1373 [ # # # # ]: 0 : while (boot_cpu_has(X86_FEATURE_GBPAGES) && end - start >= PUD_SIZE) {
1374 [ # # # # ]: 0 : set_pud(pud, pud_mkhuge(pfn_pud(cpa->pfn,
1375 : : canon_pgprot(pud_pgprot))));
1376 : :
1377 : 0 : start += PUD_SIZE;
1378 : 0 : cpa->pfn += PUD_SIZE >> PAGE_SHIFT;
1379 : 0 : cur_pages += PUD_SIZE >> PAGE_SHIFT;
1380 : 0 : pud++;
1381 : : }
1382 : :
1383 : : /* Map trailing leftover */
1384 [ # # ]: 0 : if (start < end) {
1385 : 0 : long tmp;
1386 : :
1387 [ # # ]: 0 : pud = pud_offset(p4d, start);
1388 [ # # ]: 0 : if (pud_none(*pud))
1389 [ # # ]: 0 : if (alloc_pmd_page(pud))
1390 : : return -1;
1391 : :
1392 : 0 : tmp = populate_pmd(cpa, start, end, cpa->numpages - cur_pages,
1393 : : pud, pgprot);
1394 [ # # ]: 0 : if (tmp < 0)
1395 : 0 : return cur_pages;
1396 : :
1397 : 0 : cur_pages += tmp;
1398 : : }
1399 : 0 : return cur_pages;
1400 : : }
1401 : :
1402 : : /*
1403 : : * Restrictions for kernel page table do not necessarily apply when mapping in
1404 : : * an alternate PGD.
1405 : : */
1406 : 0 : static int populate_pgd(struct cpa_data *cpa, unsigned long addr)
1407 : : {
1408 : 0 : pgprot_t pgprot = __pgprot(_KERNPG_TABLE);
1409 : 0 : pud_t *pud = NULL; /* shut up gcc */
1410 : 0 : p4d_t *p4d;
1411 : 0 : pgd_t *pgd_entry;
1412 : 0 : long ret;
1413 : :
1414 : 0 : pgd_entry = cpa->pgd + pgd_index(addr);
1415 : :
1416 [ # # ]: 0 : if (pgd_none(*pgd_entry)) {
1417 : 0 : p4d = (p4d_t *)get_zeroed_page(GFP_KERNEL);
1418 [ # # ]: 0 : if (!p4d)
1419 : : return -1;
1420 : :
1421 [ # # ]: 0 : set_pgd(pgd_entry, __pgd(__pa(p4d) | _KERNPG_TABLE));
1422 : : }
1423 : :
1424 : : /*
1425 : : * Allocate a PUD page and hand it down for mapping.
1426 : : */
1427 : 0 : p4d = p4d_offset(pgd_entry, addr);
1428 [ # # ]: 0 : if (p4d_none(*p4d)) {
1429 : 0 : pud = (pud_t *)get_zeroed_page(GFP_KERNEL);
1430 [ # # ]: 0 : if (!pud)
1431 : : return -1;
1432 : :
1433 [ # # ]: 0 : set_p4d(p4d, __p4d(__pa(pud) | _KERNPG_TABLE));
1434 : : }
1435 : :
1436 : 0 : pgprot_val(pgprot) &= ~pgprot_val(cpa->mask_clr);
1437 : 0 : pgprot_val(pgprot) |= pgprot_val(cpa->mask_set);
1438 : :
1439 : 0 : ret = populate_pud(cpa, addr, p4d, pgprot);
1440 [ # # ]: 0 : if (ret < 0) {
1441 : : /*
1442 : : * Leave the PUD page in place in case some other CPU or thread
1443 : : * already found it, but remove any useless entries we just
1444 : : * added to it.
1445 : : */
1446 : 0 : unmap_pud_range(p4d, addr,
1447 : 0 : addr + (cpa->numpages << PAGE_SHIFT));
1448 : 0 : return ret;
1449 : : }
1450 : :
1451 : 0 : cpa->numpages = ret;
1452 : 0 : return 0;
1453 : : }
1454 : :
1455 : 0 : static int __cpa_process_fault(struct cpa_data *cpa, unsigned long vaddr,
1456 : : int primary)
1457 : : {
1458 [ # # ]: 0 : if (cpa->pgd) {
1459 : : /*
1460 : : * Right now, we only execute this code path when mapping
1461 : : * the EFI virtual memory map regions, no other users
1462 : : * provide a ->pgd value. This may change in the future.
1463 : : */
1464 : 0 : return populate_pgd(cpa, vaddr);
1465 : : }
1466 : :
1467 : : /*
1468 : : * Ignore all non primary paths.
1469 : : */
1470 [ # # ]: 0 : if (!primary) {
1471 : 0 : cpa->numpages = 1;
1472 : 0 : return 0;
1473 : : }
1474 : :
1475 : : /*
1476 : : * Ignore the NULL PTE for kernel identity mapping, as it is expected
1477 : : * to have holes.
1478 : : * Also set numpages to '1' indicating that we processed cpa req for
1479 : : * one virtual address page and its pfn. TBD: numpages can be set based
1480 : : * on the initial value and the level returned by lookup_address().
1481 : : */
1482 : 0 : if (within(vaddr, PAGE_OFFSET,
1483 [ # # ]: 0 : PAGE_OFFSET + (max_pfn_mapped << PAGE_SHIFT))) {
1484 : 0 : cpa->numpages = 1;
1485 [ # # ]: 0 : cpa->pfn = __pa(vaddr) >> PAGE_SHIFT;
1486 : 0 : return 0;
1487 : :
1488 [ # # ]: 0 : } else if (__cpa_pfn_in_highmap(cpa->pfn)) {
1489 : : /* Faults in the highmap are OK, so do not warn: */
1490 : : return -EFAULT;
1491 : : } else {
1492 : 0 : WARN(1, KERN_WARNING "CPA: called for zero pte. "
1493 : : "vaddr = %lx cpa->vaddr = %lx\n", vaddr,
1494 : : *cpa->vaddr);
1495 : :
1496 : 0 : return -EFAULT;
1497 : : }
1498 : : }
1499 : :
1500 : 17583 : static int __change_page_attr(struct cpa_data *cpa, int primary)
1501 : : {
1502 : 17583 : unsigned long address;
1503 : 17583 : int do_split, err;
1504 : 17583 : unsigned int level;
1505 : 17583 : pte_t *kpte, old_pte;
1506 : :
1507 : 17583 : address = __cpa_addr(cpa, cpa->curpage);
1508 : 17653 : repeat:
1509 : 17653 : kpte = _lookup_address_cpa(cpa, address, &level);
1510 [ - + ]: 17653 : if (!kpte)
1511 : 0 : return __cpa_process_fault(cpa, address, primary);
1512 : :
1513 : 17653 : old_pte = *kpte;
1514 [ - + ]: 17653 : if (pte_none(old_pte))
1515 : 0 : return __cpa_process_fault(cpa, address, primary);
1516 : :
1517 [ + + ]: 17653 : if (level == PG_LEVEL_4K) {
1518 : 15750 : pte_t new_pte;
1519 [ + + ]: 15750 : pgprot_t new_prot = pte_pgprot(old_pte);
1520 [ + + ]: 15750 : unsigned long pfn = pte_pfn(old_pte);
1521 : :
1522 : 15750 : pgprot_val(new_prot) &= ~pgprot_val(cpa->mask_clr);
1523 : 15750 : pgprot_val(new_prot) |= pgprot_val(cpa->mask_set);
1524 : :
1525 : 15750 : cpa_inc_4k_install();
1526 : : /* Hand in lpsize = 0 to enforce the protection mechanism */
1527 : 15750 : new_prot = static_protections(new_prot, address, pfn, 1, 0,
1528 : : CPA_PROTECT);
1529 : :
1530 [ + + ]: 15750 : new_prot = pgprot_clear_protnone_bits(new_prot);
1531 : :
1532 : : /*
1533 : : * We need to keep the pfn from the existing PTE,
1534 : : * after all we're only going to change it's attributes
1535 : : * not the memory it points to
1536 : : */
1537 [ + - ]: 15750 : new_pte = pfn_pte(pfn, new_prot);
1538 : 15750 : cpa->pfn = pfn;
1539 : : /*
1540 : : * Do we really change anything ?
1541 : : */
1542 [ + + ]: 15750 : if (pte_val(old_pte) != pte_val(new_pte)) {
1543 : 10734 : set_pte_atomic(kpte, new_pte);
1544 : 10734 : cpa->flags |= CPA_FLUSHTLB;
1545 : : }
1546 : 15750 : cpa->numpages = 1;
1547 : 15750 : return 0;
1548 : : }
1549 : :
1550 : : /*
1551 : : * Check, whether we can keep the large page intact
1552 : : * and just change the pte:
1553 : : */
1554 : 1903 : do_split = should_split_large_page(kpte, address, cpa);
1555 : : /*
1556 : : * When the range fits into the existing large page,
1557 : : * return. cp->numpages and cpa->tlbflush have been updated in
1558 : : * try_large_page:
1559 : : */
1560 [ + + ]: 1903 : if (do_split <= 0)
1561 : 1833 : return do_split;
1562 : :
1563 : : /*
1564 : : * We have to split the large page:
1565 : : */
1566 : 70 : err = split_large_page(cpa, kpte, address);
1567 [ + - ]: 70 : if (!err)
1568 : 70 : goto repeat;
1569 : :
1570 : : return err;
1571 : : }
1572 : :
1573 : : static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias);
1574 : :
1575 : 4740 : static int cpa_process_alias(struct cpa_data *cpa)
1576 : : {
1577 : 4740 : struct cpa_data alias_cpa;
1578 : 4740 : unsigned long laddr = (unsigned long)__va(cpa->pfn << PAGE_SHIFT);
1579 : 4740 : unsigned long vaddr;
1580 : 4740 : int ret;
1581 : :
1582 [ + - ]: 4740 : if (!pfn_range_is_mapped(cpa->pfn, cpa->pfn + 1))
1583 : : return 0;
1584 : :
1585 : : /*
1586 : : * No need to redo, when the primary call touched the direct
1587 : : * mapping already:
1588 : : */
1589 : 4740 : vaddr = __cpa_addr(cpa, cpa->curpage);
1590 : 4740 : if (!(within(vaddr, PAGE_OFFSET,
1591 [ + + ]: 4740 : PAGE_OFFSET + (max_pfn_mapped << PAGE_SHIFT)))) {
1592 : :
1593 : 4731 : alias_cpa = *cpa;
1594 : 4731 : alias_cpa.vaddr = &laddr;
1595 : 4731 : alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY);
1596 : 4731 : alias_cpa.curpage = 0;
1597 : :
1598 : 4731 : ret = __change_page_attr_set_clr(&alias_cpa, 0);
1599 [ + - ]: 4731 : if (ret)
1600 : : return ret;
1601 : : }
1602 : :
1603 : : #ifdef CONFIG_X86_64
1604 : : /*
1605 : : * If the primary call didn't touch the high mapping already
1606 : : * and the physical address is inside the kernel map, we need
1607 : : * to touch the high mapped kernel as well:
1608 : : */
1609 [ + + ]: 4740 : if (!within(vaddr, (unsigned long)_text, _brk_end) &&
1610 [ - + ]: 411 : __cpa_pfn_in_highmap(cpa->pfn)) {
1611 : 0 : unsigned long temp_cpa_vaddr = (cpa->pfn << PAGE_SHIFT) +
1612 : 0 : __START_KERNEL_map - phys_base;
1613 : 0 : alias_cpa = *cpa;
1614 : 0 : alias_cpa.vaddr = &temp_cpa_vaddr;
1615 : 0 : alias_cpa.flags &= ~(CPA_PAGES_ARRAY | CPA_ARRAY);
1616 : 0 : alias_cpa.curpage = 0;
1617 : :
1618 : : /*
1619 : : * The high mapping range is imprecise, so ignore the
1620 : : * return value.
1621 : : */
1622 : 0 : __change_page_attr_set_clr(&alias_cpa, 0);
1623 : : }
1624 : : #endif
1625 : :
1626 : : return 0;
1627 : : }
1628 : :
1629 : 5181 : static int __change_page_attr_set_clr(struct cpa_data *cpa, int checkalias)
1630 : : {
1631 : 5181 : unsigned long numpages = cpa->numpages;
1632 : 5181 : unsigned long rempages = numpages;
1633 : 5181 : int ret = 0;
1634 : :
1635 [ + + ]: 22764 : while (rempages) {
1636 : : /*
1637 : : * Store the remaining nr of pages for the large page
1638 : : * preservation check.
1639 : : */
1640 : 17583 : cpa->numpages = rempages;
1641 : : /* for array changes, we can't use large page */
1642 [ - + ]: 17583 : if (cpa->flags & (CPA_ARRAY | CPA_PAGES_ARRAY))
1643 : 0 : cpa->numpages = 1;
1644 : :
1645 : 17583 : if (!debug_pagealloc_enabled())
1646 : 17583 : spin_lock(&cpa_lock);
1647 : 17583 : ret = __change_page_attr(cpa, checkalias);
1648 : 17583 : if (!debug_pagealloc_enabled())
1649 : 17583 : spin_unlock(&cpa_lock);
1650 [ - + ]: 17583 : if (ret)
1651 : 0 : goto out;
1652 : :
1653 [ + + ]: 17583 : if (checkalias) {
1654 : 4740 : ret = cpa_process_alias(cpa);
1655 [ - + ]: 4740 : if (ret)
1656 : 0 : goto out;
1657 : : }
1658 : :
1659 : : /*
1660 : : * Adjust the number of pages with the result of the
1661 : : * CPA operation. Either a large page has been
1662 : : * preserved or a single page update happened.
1663 : : */
1664 [ + - - + ]: 17583 : BUG_ON(cpa->numpages > rempages || !cpa->numpages);
1665 : 17583 : rempages -= cpa->numpages;
1666 : 17583 : cpa->curpage += cpa->numpages;
1667 : : }
1668 : :
1669 : 5181 : out:
1670 : : /* Restore the original numpages */
1671 : 5181 : cpa->numpages = numpages;
1672 : 5181 : return ret;
1673 : : }
1674 : :
1675 : 360 : static int change_page_attr_set_clr(unsigned long *addr, int numpages,
1676 : : pgprot_t mask_set, pgprot_t mask_clr,
1677 : : int force_split, int in_flag,
1678 : : struct page **pages)
1679 : : {
1680 : 360 : struct cpa_data cpa;
1681 : 360 : int ret, cache, checkalias;
1682 : :
1683 : 360 : memset(&cpa, 0, sizeof(cpa));
1684 : :
1685 : : /*
1686 : : * Check, if we are requested to set a not supported
1687 : : * feature. Clearing non-supported features is OK.
1688 : : */
1689 [ - + ]: 360 : mask_set = canon_pgprot(mask_set);
1690 : :
1691 [ + + + + : 360 : if (!pgprot_val(mask_set) && !pgprot_val(mask_clr) && !force_split)
+ - ]
1692 : : return 0;
1693 : :
1694 : : /* Ensure we are PAGE_SIZE aligned */
1695 [ - + ]: 360 : if (in_flag & CPA_ARRAY) {
1696 : : int i;
1697 [ # # ]: 0 : for (i = 0; i < numpages; i++) {
1698 [ # # ]: 0 : if (addr[i] & ~PAGE_MASK) {
1699 : 0 : addr[i] &= PAGE_MASK;
1700 : 0 : WARN_ON_ONCE(1);
1701 : : }
1702 : : }
1703 [ + - ]: 360 : } else if (!(in_flag & CPA_PAGES_ARRAY)) {
1704 : : /*
1705 : : * in_flag of CPA_PAGES_ARRAY implies it is aligned.
1706 : : * No need to check in that case
1707 : : */
1708 [ - + ]: 360 : if (*addr & ~PAGE_MASK) {
1709 : 0 : *addr &= PAGE_MASK;
1710 : : /*
1711 : : * People should not be passing in unaligned addresses:
1712 : : */
1713 : 0 : WARN_ON_ONCE(1);
1714 : : }
1715 : : }
1716 : :
1717 : : /* Must avoid aliasing mappings in the highmem code */
1718 : 360 : kmap_flush_unused();
1719 : :
1720 : 360 : vm_unmap_aliases();
1721 : :
1722 : 360 : cpa.vaddr = addr;
1723 : 360 : cpa.pages = pages;
1724 : 360 : cpa.numpages = numpages;
1725 : 360 : cpa.mask_set = mask_set;
1726 : 360 : cpa.mask_clr = mask_clr;
1727 : 360 : cpa.flags = 0;
1728 : 360 : cpa.curpage = 0;
1729 : 360 : cpa.force_split = force_split;
1730 : :
1731 [ - + ]: 360 : if (in_flag & (CPA_ARRAY | CPA_PAGES_ARRAY))
1732 : 0 : cpa.flags |= in_flag;
1733 : :
1734 : : /* No alias checking for _NX bit modifications */
1735 : 360 : checkalias = (pgprot_val(mask_set) | pgprot_val(mask_clr)) != _PAGE_NX;
1736 : : /* Has caller explicitly disabled alias checking? */
1737 [ - + ]: 360 : if (in_flag & CPA_NO_CHECK_ALIAS)
1738 : 0 : checkalias = 0;
1739 : :
1740 : 360 : ret = __change_page_attr_set_clr(&cpa, checkalias);
1741 : :
1742 : : /*
1743 : : * Check whether we really changed something:
1744 : : */
1745 [ + + ]: 360 : if (!(cpa.flags & CPA_FLUSHTLB))
1746 : 123 : goto out;
1747 : :
1748 : : /*
1749 : : * No need to flush, when we did not set any of the caching
1750 : : * attributes:
1751 : : */
1752 [ - + ]: 237 : cache = !!pgprot2cachemode(mask_set);
1753 : :
1754 : : /*
1755 : : * On error; flush everything to be sure.
1756 : : */
1757 [ - + ]: 237 : if (ret) {
1758 : 0 : cpa_flush_all(cache);
1759 : 0 : goto out;
1760 : : }
1761 : :
1762 : 237 : cpa_flush(&cpa, cache);
1763 : : out:
1764 : : return ret;
1765 : : }
1766 : :
1767 : 75 : static inline int change_page_attr_set(unsigned long *addr, int numpages,
1768 : : pgprot_t mask, int array)
1769 : : {
1770 : 0 : return change_page_attr_set_clr(addr, numpages, mask, __pgprot(0), 0,
1771 : : (array ? CPA_ARRAY : 0), NULL);
1772 : : }
1773 : :
1774 : 282 : static inline int change_page_attr_clear(unsigned long *addr, int numpages,
1775 : : pgprot_t mask, int array)
1776 : : {
1777 : 282 : return change_page_attr_set_clr(addr, numpages, __pgprot(0), mask, 0,
1778 : : (array ? CPA_ARRAY : 0), NULL);
1779 : : }
1780 : :
1781 : 0 : static inline int cpa_set_pages_array(struct page **pages, int numpages,
1782 : : pgprot_t mask)
1783 : : {
1784 : 0 : return change_page_attr_set_clr(NULL, numpages, mask, __pgprot(0), 0,
1785 : : CPA_PAGES_ARRAY, pages);
1786 : : }
1787 : :
1788 : 0 : static inline int cpa_clear_pages_array(struct page **pages, int numpages,
1789 : : pgprot_t mask)
1790 : : {
1791 : 0 : return change_page_attr_set_clr(NULL, numpages, __pgprot(0), mask, 0,
1792 : : CPA_PAGES_ARRAY, pages);
1793 : : }
1794 : :
1795 : 0 : int _set_memory_uc(unsigned long addr, int numpages)
1796 : : {
1797 : : /*
1798 : : * for now UC MINUS. see comments in ioremap()
1799 : : * If you really need strong UC use ioremap_uc(), but note
1800 : : * that you cannot override IO areas with set_memory_*() as
1801 : : * these helpers cannot work with IO memory.
1802 : : */
1803 : 0 : return change_page_attr_set(&addr, numpages,
1804 : : cachemode2pgprot(_PAGE_CACHE_MODE_UC_MINUS),
1805 : : 0);
1806 : : }
1807 : :
1808 : 0 : int set_memory_uc(unsigned long addr, int numpages)
1809 : : {
1810 : 0 : int ret;
1811 : :
1812 : : /*
1813 : : * for now UC MINUS. see comments in ioremap()
1814 : : */
1815 [ # # ]: 0 : ret = memtype_reserve(__pa(addr), __pa(addr) + numpages * PAGE_SIZE,
1816 : : _PAGE_CACHE_MODE_UC_MINUS, NULL);
1817 [ # # ]: 0 : if (ret)
1818 : 0 : goto out_err;
1819 : :
1820 : 0 : ret = _set_memory_uc(addr, numpages);
1821 [ # # ]: 0 : if (ret)
1822 : 0 : goto out_free;
1823 : :
1824 : : return 0;
1825 : :
1826 : : out_free:
1827 [ # # ]: 0 : memtype_free(__pa(addr), __pa(addr) + numpages * PAGE_SIZE);
1828 : : out_err:
1829 : : return ret;
1830 : : }
1831 : : EXPORT_SYMBOL(set_memory_uc);
1832 : :
1833 : 0 : int _set_memory_wc(unsigned long addr, int numpages)
1834 : : {
1835 : 0 : int ret;
1836 : :
1837 : 0 : ret = change_page_attr_set(&addr, numpages,
1838 : : cachemode2pgprot(_PAGE_CACHE_MODE_UC_MINUS),
1839 : : 0);
1840 [ # # ]: 0 : if (!ret) {
1841 : 0 : ret = change_page_attr_set_clr(&addr, numpages,
1842 : : cachemode2pgprot(_PAGE_CACHE_MODE_WC),
1843 : 0 : __pgprot(_PAGE_CACHE_MASK),
1844 : : 0, 0, NULL);
1845 : : }
1846 : 0 : return ret;
1847 : : }
1848 : :
1849 : 0 : int set_memory_wc(unsigned long addr, int numpages)
1850 : : {
1851 : 0 : int ret;
1852 : :
1853 [ # # ]: 0 : ret = memtype_reserve(__pa(addr), __pa(addr) + numpages * PAGE_SIZE,
1854 : : _PAGE_CACHE_MODE_WC, NULL);
1855 [ # # ]: 0 : if (ret)
1856 : : return ret;
1857 : :
1858 : 0 : ret = _set_memory_wc(addr, numpages);
1859 [ # # ]: 0 : if (ret)
1860 [ # # ]: 0 : memtype_free(__pa(addr), __pa(addr) + numpages * PAGE_SIZE);
1861 : :
1862 : : return ret;
1863 : : }
1864 : : EXPORT_SYMBOL(set_memory_wc);
1865 : :
1866 : 0 : int _set_memory_wt(unsigned long addr, int numpages)
1867 : : {
1868 : 0 : return change_page_attr_set(&addr, numpages,
1869 : : cachemode2pgprot(_PAGE_CACHE_MODE_WT), 0);
1870 : : }
1871 : :
1872 : 0 : int _set_memory_wb(unsigned long addr, int numpages)
1873 : : {
1874 : : /* WB cache mode is hard wired to all cache attribute bits being 0 */
1875 : 0 : return change_page_attr_clear(&addr, numpages,
1876 : : __pgprot(_PAGE_CACHE_MASK), 0);
1877 : : }
1878 : :
1879 : 0 : int set_memory_wb(unsigned long addr, int numpages)
1880 : : {
1881 : 0 : int ret;
1882 : :
1883 : 0 : ret = _set_memory_wb(addr, numpages);
1884 [ # # ]: 0 : if (ret)
1885 : : return ret;
1886 : :
1887 [ # # ]: 0 : memtype_free(__pa(addr), __pa(addr) + numpages * PAGE_SIZE);
1888 : 0 : return 0;
1889 : : }
1890 : : EXPORT_SYMBOL(set_memory_wb);
1891 : :
1892 : 21 : int set_memory_x(unsigned long addr, int numpages)
1893 : : {
1894 [ + - ]: 21 : if (!(__supported_pte_mask & _PAGE_NX))
1895 : : return 0;
1896 : :
1897 : 21 : return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_NX), 0);
1898 : : }
1899 : :
1900 : 63 : int set_memory_nx(unsigned long addr, int numpages)
1901 : : {
1902 [ + - ]: 63 : if (!(__supported_pte_mask & _PAGE_NX))
1903 : : return 0;
1904 : :
1905 : 63 : return change_page_attr_set(&addr, numpages, __pgprot(_PAGE_NX), 0);
1906 : : }
1907 : :
1908 : 261 : int set_memory_ro(unsigned long addr, int numpages)
1909 : : {
1910 : 261 : return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_RW), 0);
1911 : : }
1912 : :
1913 : 12 : int set_memory_rw(unsigned long addr, int numpages)
1914 : : {
1915 : 12 : return change_page_attr_set(&addr, numpages, __pgprot(_PAGE_RW), 0);
1916 : : }
1917 : :
1918 : 0 : int set_memory_np(unsigned long addr, int numpages)
1919 : : {
1920 : 0 : return change_page_attr_clear(&addr, numpages, __pgprot(_PAGE_PRESENT), 0);
1921 : : }
1922 : :
1923 : 0 : int set_memory_np_noalias(unsigned long addr, int numpages)
1924 : : {
1925 : 0 : int cpa_flags = CPA_NO_CHECK_ALIAS;
1926 : :
1927 : 0 : return change_page_attr_set_clr(&addr, numpages, __pgprot(0),
1928 : 0 : __pgprot(_PAGE_PRESENT), 0,
1929 : : cpa_flags, NULL);
1930 : : }
1931 : :
1932 : 3 : int set_memory_4k(unsigned long addr, int numpages)
1933 : : {
1934 : 6 : return change_page_attr_set_clr(&addr, numpages, __pgprot(0),
1935 : 3 : __pgprot(0), 1, 0, NULL);
1936 : : }
1937 : :
1938 : 0 : int set_memory_nonglobal(unsigned long addr, int numpages)
1939 : : {
1940 : 0 : return change_page_attr_clear(&addr, numpages,
1941 : : __pgprot(_PAGE_GLOBAL), 0);
1942 : : }
1943 : :
1944 : 0 : int set_memory_global(unsigned long addr, int numpages)
1945 : : {
1946 : 0 : return change_page_attr_set(&addr, numpages,
1947 : : __pgprot(_PAGE_GLOBAL), 0);
1948 : : }
1949 : :
1950 : 0 : static int __set_memory_enc_dec(unsigned long addr, int numpages, bool enc)
1951 : : {
1952 : 0 : struct cpa_data cpa;
1953 : 0 : int ret;
1954 : :
1955 : : /* Nothing to do if memory encryption is not active */
1956 : 0 : if (!mem_encrypt_active())
1957 : 0 : return 0;
1958 : :
1959 : : /* Should not be working on unaligned addresses */
1960 : : if (WARN_ONCE(addr & ~PAGE_MASK, "misaligned address: %#lx\n", addr))
1961 : : addr &= PAGE_MASK;
1962 : :
1963 : : memset(&cpa, 0, sizeof(cpa));
1964 : : cpa.vaddr = &addr;
1965 : : cpa.numpages = numpages;
1966 : : cpa.mask_set = enc ? __pgprot(_PAGE_ENC) : __pgprot(0);
1967 : : cpa.mask_clr = enc ? __pgprot(0) : __pgprot(_PAGE_ENC);
1968 : : cpa.pgd = init_mm.pgd;
1969 : :
1970 : : /* Must avoid aliasing mappings in the highmem code */
1971 : : kmap_flush_unused();
1972 : : vm_unmap_aliases();
1973 : :
1974 : : /*
1975 : : * Before changing the encryption attribute, we need to flush caches.
1976 : : */
1977 : : cpa_flush(&cpa, 1);
1978 : :
1979 : : ret = __change_page_attr_set_clr(&cpa, 1);
1980 : :
1981 : : /*
1982 : : * After changing the encryption attribute, we need to flush TLBs again
1983 : : * in case any speculative TLB caching occurred (but no need to flush
1984 : : * caches again). We could just use cpa_flush_all(), but in case TLB
1985 : : * flushing gets optimized in the cpa_flush() path use the same logic
1986 : : * as above.
1987 : : */
1988 : : cpa_flush(&cpa, 0);
1989 : :
1990 : : return ret;
1991 : : }
1992 : :
1993 : 0 : int set_memory_encrypted(unsigned long addr, int numpages)
1994 : : {
1995 : 0 : return __set_memory_enc_dec(addr, numpages, true);
1996 : : }
1997 : : EXPORT_SYMBOL_GPL(set_memory_encrypted);
1998 : :
1999 : 0 : int set_memory_decrypted(unsigned long addr, int numpages)
2000 : : {
2001 : 0 : return __set_memory_enc_dec(addr, numpages, false);
2002 : : }
2003 : : EXPORT_SYMBOL_GPL(set_memory_decrypted);
2004 : :
2005 : 0 : int set_pages_uc(struct page *page, int numpages)
2006 : : {
2007 : 0 : unsigned long addr = (unsigned long)page_address(page);
2008 : :
2009 : 0 : return set_memory_uc(addr, numpages);
2010 : : }
2011 : : EXPORT_SYMBOL(set_pages_uc);
2012 : :
2013 : 0 : static int _set_pages_array(struct page **pages, int numpages,
2014 : : enum page_cache_mode new_type)
2015 : : {
2016 : 0 : unsigned long start;
2017 : 0 : unsigned long end;
2018 : 0 : enum page_cache_mode set_type;
2019 : 0 : int i;
2020 : 0 : int free_idx;
2021 : 0 : int ret;
2022 : :
2023 [ # # ]: 0 : for (i = 0; i < numpages; i++) {
2024 : 0 : if (PageHighMem(pages[i]))
2025 : : continue;
2026 : 0 : start = page_to_pfn(pages[i]) << PAGE_SHIFT;
2027 : 0 : end = start + PAGE_SIZE;
2028 [ # # ]: 0 : if (memtype_reserve(start, end, new_type, NULL))
2029 : 0 : goto err_out;
2030 : : }
2031 : :
2032 : : /* If WC, set to UC- first and then WC */
2033 : 0 : set_type = (new_type == _PAGE_CACHE_MODE_WC) ?
2034 [ # # ]: 0 : _PAGE_CACHE_MODE_UC_MINUS : new_type;
2035 : :
2036 [ # # ]: 0 : ret = cpa_set_pages_array(pages, numpages,
2037 : : cachemode2pgprot(set_type));
2038 [ # # ]: 0 : if (!ret && new_type == _PAGE_CACHE_MODE_WC)
2039 : 0 : ret = change_page_attr_set_clr(NULL, numpages,
2040 : : cachemode2pgprot(
2041 : : _PAGE_CACHE_MODE_WC),
2042 : 0 : __pgprot(_PAGE_CACHE_MASK),
2043 : : 0, CPA_PAGES_ARRAY, pages);
2044 [ # # ]: 0 : if (ret)
2045 : 0 : goto err_out;
2046 : : return 0; /* Success */
2047 : 0 : err_out:
2048 : 0 : free_idx = i;
2049 [ # # ]: 0 : for (i = 0; i < free_idx; i++) {
2050 : 0 : if (PageHighMem(pages[i]))
2051 : : continue;
2052 : 0 : start = page_to_pfn(pages[i]) << PAGE_SHIFT;
2053 : 0 : end = start + PAGE_SIZE;
2054 : 0 : memtype_free(start, end);
2055 : : }
2056 : : return -EINVAL;
2057 : : }
2058 : :
2059 : 0 : int set_pages_array_uc(struct page **pages, int numpages)
2060 : : {
2061 : 0 : return _set_pages_array(pages, numpages, _PAGE_CACHE_MODE_UC_MINUS);
2062 : : }
2063 : : EXPORT_SYMBOL(set_pages_array_uc);
2064 : :
2065 : 0 : int set_pages_array_wc(struct page **pages, int numpages)
2066 : : {
2067 : 0 : return _set_pages_array(pages, numpages, _PAGE_CACHE_MODE_WC);
2068 : : }
2069 : : EXPORT_SYMBOL(set_pages_array_wc);
2070 : :
2071 : 0 : int set_pages_array_wt(struct page **pages, int numpages)
2072 : : {
2073 : 0 : return _set_pages_array(pages, numpages, _PAGE_CACHE_MODE_WT);
2074 : : }
2075 : : EXPORT_SYMBOL_GPL(set_pages_array_wt);
2076 : :
2077 : 0 : int set_pages_wb(struct page *page, int numpages)
2078 : : {
2079 : 0 : unsigned long addr = (unsigned long)page_address(page);
2080 : :
2081 : 0 : return set_memory_wb(addr, numpages);
2082 : : }
2083 : : EXPORT_SYMBOL(set_pages_wb);
2084 : :
2085 : 0 : int set_pages_array_wb(struct page **pages, int numpages)
2086 : : {
2087 : 0 : int retval;
2088 : 0 : unsigned long start;
2089 : 0 : unsigned long end;
2090 : 0 : int i;
2091 : :
2092 : : /* WB cache mode is hard wired to all cache attribute bits being 0 */
2093 : 0 : retval = cpa_clear_pages_array(pages, numpages,
2094 : : __pgprot(_PAGE_CACHE_MASK));
2095 [ # # ]: 0 : if (retval)
2096 : : return retval;
2097 : :
2098 [ # # ]: 0 : for (i = 0; i < numpages; i++) {
2099 : 0 : if (PageHighMem(pages[i]))
2100 : : continue;
2101 : 0 : start = page_to_pfn(pages[i]) << PAGE_SHIFT;
2102 : 0 : end = start + PAGE_SIZE;
2103 : 0 : memtype_free(start, end);
2104 : : }
2105 : :
2106 : : return 0;
2107 : : }
2108 : : EXPORT_SYMBOL(set_pages_array_wb);
2109 : :
2110 : 0 : int set_pages_ro(struct page *page, int numpages)
2111 : : {
2112 : 0 : unsigned long addr = (unsigned long)page_address(page);
2113 : :
2114 : 0 : return set_memory_ro(addr, numpages);
2115 : : }
2116 : :
2117 : 0 : int set_pages_rw(struct page *page, int numpages)
2118 : : {
2119 : 0 : unsigned long addr = (unsigned long)page_address(page);
2120 : :
2121 : 0 : return set_memory_rw(addr, numpages);
2122 : : }
2123 : :
2124 : 45 : static int __set_pages_p(struct page *page, int numpages)
2125 : : {
2126 : 45 : unsigned long tempaddr = (unsigned long) page_address(page);
2127 : 45 : struct cpa_data cpa = { .vaddr = &tempaddr,
2128 : : .pgd = NULL,
2129 : : .numpages = numpages,
2130 : : .mask_set = __pgprot(_PAGE_PRESENT | _PAGE_RW),
2131 : : .mask_clr = __pgprot(0),
2132 : : .flags = 0};
2133 : :
2134 : : /*
2135 : : * No alias checking needed for setting present flag. otherwise,
2136 : : * we may need to break large pages for 64-bit kernel text
2137 : : * mappings (this adds to complexity if we want to do this from
2138 : : * atomic context especially). Let's keep it simple!
2139 : : */
2140 : 45 : return __change_page_attr_set_clr(&cpa, 0);
2141 : : }
2142 : :
2143 : 45 : static int __set_pages_np(struct page *page, int numpages)
2144 : : {
2145 : 45 : unsigned long tempaddr = (unsigned long) page_address(page);
2146 : 45 : struct cpa_data cpa = { .vaddr = &tempaddr,
2147 : : .pgd = NULL,
2148 : : .numpages = numpages,
2149 : : .mask_set = __pgprot(0),
2150 : : .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW),
2151 : : .flags = 0};
2152 : :
2153 : : /*
2154 : : * No alias checking needed for setting not present flag. otherwise,
2155 : : * we may need to break large pages for 64-bit kernel text
2156 : : * mappings (this adds to complexity if we want to do this from
2157 : : * atomic context especially). Let's keep it simple!
2158 : : */
2159 : 45 : return __change_page_attr_set_clr(&cpa, 0);
2160 : : }
2161 : :
2162 : 45 : int set_direct_map_invalid_noflush(struct page *page)
2163 : : {
2164 : 45 : return __set_pages_np(page, 1);
2165 : : }
2166 : :
2167 : 45 : int set_direct_map_default_noflush(struct page *page)
2168 : : {
2169 : 45 : return __set_pages_p(page, 1);
2170 : : }
2171 : :
2172 : 0 : void __kernel_map_pages(struct page *page, int numpages, int enable)
2173 : : {
2174 [ # # ]: 0 : if (PageHighMem(page))
2175 : : return;
2176 : 0 : if (!enable) {
2177 : : debug_check_no_locks_freed(page_address(page),
2178 : : numpages * PAGE_SIZE);
2179 : : }
2180 : :
2181 : : /*
2182 : : * The return value is ignored as the calls cannot fail.
2183 : : * Large pages for identity mappings are not used at boot time
2184 : : * and hence no memory allocations during large page split.
2185 : : */
2186 [ # # ]: 0 : if (enable)
2187 : 0 : __set_pages_p(page, numpages);
2188 : : else
2189 : 0 : __set_pages_np(page, numpages);
2190 : :
2191 : : /*
2192 : : * We should perform an IPI and flush all tlbs,
2193 : : * but that can deadlock->flush only current cpu.
2194 : : * Preemption needs to be disabled around __flush_tlb_all() due to
2195 : : * CR3 reload in __native_flush_tlb().
2196 : : */
2197 : 0 : preempt_disable();
2198 : 0 : __flush_tlb_all();
2199 : 0 : preempt_enable();
2200 : :
2201 : 0 : arch_flush_lazy_mmu_mode();
2202 : : }
2203 : :
2204 : : #ifdef CONFIG_HIBERNATION
2205 : 0 : bool kernel_page_present(struct page *page)
2206 : : {
2207 : 0 : unsigned int level;
2208 : 0 : pte_t *pte;
2209 : :
2210 : 0 : if (PageHighMem(page))
2211 : : return false;
2212 : :
2213 : 0 : pte = lookup_address((unsigned long)page_address(page), &level);
2214 : 0 : return (pte_val(*pte) & _PAGE_PRESENT);
2215 : : }
2216 : : #endif /* CONFIG_HIBERNATION */
2217 : :
2218 : 0 : int __init kernel_map_pages_in_pgd(pgd_t *pgd, u64 pfn, unsigned long address,
2219 : : unsigned numpages, unsigned long page_flags)
2220 : : {
2221 : 0 : int retval = -EINVAL;
2222 : :
2223 : 0 : struct cpa_data cpa = {
2224 : : .vaddr = &address,
2225 : : .pfn = pfn,
2226 : : .pgd = pgd,
2227 : : .numpages = numpages,
2228 : : .mask_set = __pgprot(0),
2229 : 0 : .mask_clr = __pgprot(~page_flags & (_PAGE_NX|_PAGE_RW)),
2230 : : .flags = 0,
2231 : : };
2232 : :
2233 [ # # # # ]: 0 : WARN_ONCE(num_online_cpus() > 1, "Don't call after initializing SMP");
2234 : :
2235 [ # # ]: 0 : if (!(__supported_pte_mask & _PAGE_NX))
2236 : 0 : goto out;
2237 : :
2238 : 0 : if (!(page_flags & _PAGE_ENC))
2239 : 0 : cpa.mask_clr = pgprot_encrypted(cpa.mask_clr);
2240 : :
2241 : 0 : cpa.mask_set = __pgprot(_PAGE_PRESENT | page_flags);
2242 : :
2243 : 0 : retval = __change_page_attr_set_clr(&cpa, 0);
2244 : 0 : __flush_tlb_all();
2245 : :
2246 : 0 : out:
2247 : 0 : return retval;
2248 : : }
2249 : :
2250 : : /*
2251 : : * __flush_tlb_all() flushes mappings only on current CPU and hence this
2252 : : * function shouldn't be used in an SMP environment. Presently, it's used only
2253 : : * during boot (way before smp_init()) by EFI subsystem and hence is ok.
2254 : : */
2255 : 0 : int __init kernel_unmap_pages_in_pgd(pgd_t *pgd, unsigned long address,
2256 : : unsigned long numpages)
2257 : : {
2258 : 0 : int retval;
2259 : :
2260 : : /*
2261 : : * The typical sequence for unmapping is to find a pte through
2262 : : * lookup_address_in_pgd() (ideally, it should never return NULL because
2263 : : * the address is already mapped) and change it's protections. As pfn is
2264 : : * the *target* of a mapping, it's not useful while unmapping.
2265 : : */
2266 : 0 : struct cpa_data cpa = {
2267 : : .vaddr = &address,
2268 : : .pfn = 0,
2269 : : .pgd = pgd,
2270 : : .numpages = numpages,
2271 : : .mask_set = __pgprot(0),
2272 : : .mask_clr = __pgprot(_PAGE_PRESENT | _PAGE_RW),
2273 : : .flags = 0,
2274 : : };
2275 : :
2276 [ # # # # ]: 0 : WARN_ONCE(num_online_cpus() > 1, "Don't call after initializing SMP");
2277 : :
2278 : 0 : retval = __change_page_attr_set_clr(&cpa, 0);
2279 : 0 : __flush_tlb_all();
2280 : :
2281 : 0 : return retval;
2282 : : }
2283 : :
2284 : : /*
2285 : : * The testcases use internal knowledge of the implementation that shouldn't
2286 : : * be exposed to the rest of the kernel. Include these directly here.
2287 : : */
2288 : : #ifdef CONFIG_CPA_DEBUG
2289 : : #include "cpa-test.c"
2290 : : #endif
|
