188e3e07eeeba7c0eb6555c138a16e97c3e5d787
[kvmfornfv.git] / kernel / arch / x86 / mm / pat.c
1 /*
2  * Handle caching attributes in page tables (PAT)
3  *
4  * Authors: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
5  *          Suresh B Siddha <suresh.b.siddha@intel.com>
6  *
7  * Loosely based on earlier PAT patchset from Eric Biederman and Andi Kleen.
8  */
9
10 #include <linux/seq_file.h>
11 #include <linux/bootmem.h>
12 #include <linux/debugfs.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/mm.h>
17 #include <linux/fs.h>
18 #include <linux/rbtree.h>
19
20 #include <asm/cacheflush.h>
21 #include <asm/processor.h>
22 #include <asm/tlbflush.h>
23 #include <asm/x86_init.h>
24 #include <asm/pgtable.h>
25 #include <asm/fcntl.h>
26 #include <asm/e820.h>
27 #include <asm/mtrr.h>
28 #include <asm/page.h>
29 #include <asm/msr.h>
30 #include <asm/pat.h>
31 #include <asm/io.h>
32
33 #include "pat_internal.h"
34 #include "mm_internal.h"
35
36 #undef pr_fmt
37 #define pr_fmt(fmt) "" fmt
38
39 static bool boot_cpu_done;
40
41 static int __read_mostly __pat_enabled = IS_ENABLED(CONFIG_X86_PAT);
42
43 static inline void pat_disable(const char *reason)
44 {
45         __pat_enabled = 0;
46         pr_info("x86/PAT: %s\n", reason);
47 }
48
49 static int __init nopat(char *str)
50 {
51         pat_disable("PAT support disabled.");
52         return 0;
53 }
54 early_param("nopat", nopat);
55
56 bool pat_enabled(void)
57 {
58         return !!__pat_enabled;
59 }
60 EXPORT_SYMBOL_GPL(pat_enabled);
61
62 int pat_debug_enable;
63
64 static int __init pat_debug_setup(char *str)
65 {
66         pat_debug_enable = 1;
67         return 0;
68 }
69 __setup("debugpat", pat_debug_setup);
70
71 #ifdef CONFIG_X86_PAT
72 /*
73  * X86 PAT uses page flags arch_1 and uncached together to keep track of
74  * memory type of pages that have backing page struct.
75  *
76  * X86 PAT supports 4 different memory types:
77  *  - _PAGE_CACHE_MODE_WB
78  *  - _PAGE_CACHE_MODE_WC
79  *  - _PAGE_CACHE_MODE_UC_MINUS
80  *  - _PAGE_CACHE_MODE_WT
81  *
82  * _PAGE_CACHE_MODE_WB is the default type.
83  */
84
85 #define _PGMT_WB                0
86 #define _PGMT_WC                (1UL << PG_arch_1)
87 #define _PGMT_UC_MINUS          (1UL << PG_uncached)
88 #define _PGMT_WT                (1UL << PG_uncached | 1UL << PG_arch_1)
89 #define _PGMT_MASK              (1UL << PG_uncached | 1UL << PG_arch_1)
90 #define _PGMT_CLEAR_MASK        (~_PGMT_MASK)
91
92 static inline enum page_cache_mode get_page_memtype(struct page *pg)
93 {
94         unsigned long pg_flags = pg->flags & _PGMT_MASK;
95
96         if (pg_flags == _PGMT_WB)
97                 return _PAGE_CACHE_MODE_WB;
98         else if (pg_flags == _PGMT_WC)
99                 return _PAGE_CACHE_MODE_WC;
100         else if (pg_flags == _PGMT_UC_MINUS)
101                 return _PAGE_CACHE_MODE_UC_MINUS;
102         else
103                 return _PAGE_CACHE_MODE_WT;
104 }
105
106 static inline void set_page_memtype(struct page *pg,
107                                     enum page_cache_mode memtype)
108 {
109         unsigned long memtype_flags;
110         unsigned long old_flags;
111         unsigned long new_flags;
112
113         switch (memtype) {
114         case _PAGE_CACHE_MODE_WC:
115                 memtype_flags = _PGMT_WC;
116                 break;
117         case _PAGE_CACHE_MODE_UC_MINUS:
118                 memtype_flags = _PGMT_UC_MINUS;
119                 break;
120         case _PAGE_CACHE_MODE_WT:
121                 memtype_flags = _PGMT_WT;
122                 break;
123         case _PAGE_CACHE_MODE_WB:
124         default:
125                 memtype_flags = _PGMT_WB;
126                 break;
127         }
128
129         do {
130                 old_flags = pg->flags;
131                 new_flags = (old_flags & _PGMT_CLEAR_MASK) | memtype_flags;
132         } while (cmpxchg(&pg->flags, old_flags, new_flags) != old_flags);
133 }
134 #else
135 static inline enum page_cache_mode get_page_memtype(struct page *pg)
136 {
137         return -1;
138 }
139 static inline void set_page_memtype(struct page *pg,
140                                     enum page_cache_mode memtype)
141 {
142 }
143 #endif
144
145 enum {
146         PAT_UC = 0,             /* uncached */
147         PAT_WC = 1,             /* Write combining */
148         PAT_WT = 4,             /* Write Through */
149         PAT_WP = 5,             /* Write Protected */
150         PAT_WB = 6,             /* Write Back (default) */
151         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
152 };
153
154 #define CM(c) (_PAGE_CACHE_MODE_ ## c)
155
156 static enum page_cache_mode pat_get_cache_mode(unsigned pat_val, char *msg)
157 {
158         enum page_cache_mode cache;
159         char *cache_mode;
160
161         switch (pat_val) {
162         case PAT_UC:       cache = CM(UC);       cache_mode = "UC  "; break;
163         case PAT_WC:       cache = CM(WC);       cache_mode = "WC  "; break;
164         case PAT_WT:       cache = CM(WT);       cache_mode = "WT  "; break;
165         case PAT_WP:       cache = CM(WP);       cache_mode = "WP  "; break;
166         case PAT_WB:       cache = CM(WB);       cache_mode = "WB  "; break;
167         case PAT_UC_MINUS: cache = CM(UC_MINUS); cache_mode = "UC- "; break;
168         default:           cache = CM(WB);       cache_mode = "WB  "; break;
169         }
170
171         memcpy(msg, cache_mode, 4);
172
173         return cache;
174 }
175
176 #undef CM
177
178 /*
179  * Update the cache mode to pgprot translation tables according to PAT
180  * configuration.
181  * Using lower indices is preferred, so we start with highest index.
182  */
183 void pat_init_cache_modes(u64 pat)
184 {
185         enum page_cache_mode cache;
186         char pat_msg[33];
187         int i;
188
189         pat_msg[32] = 0;
190         for (i = 7; i >= 0; i--) {
191                 cache = pat_get_cache_mode((pat >> (i * 8)) & 7,
192                                            pat_msg + 4 * i);
193                 update_cache_mode_entry(i, cache);
194         }
195         pr_info("x86/PAT: Configuration [0-7]: %s\n", pat_msg);
196 }
197
198 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
199
200 static void pat_bsp_init(u64 pat)
201 {
202         u64 tmp_pat;
203
204         if (!cpu_has_pat) {
205                 pat_disable("PAT not supported by CPU.");
206                 return;
207         }
208
209         if (!pat_enabled())
210                 goto done;
211
212         rdmsrl(MSR_IA32_CR_PAT, tmp_pat);
213         if (!tmp_pat) {
214                 pat_disable("PAT MSR is 0, disabled.");
215                 return;
216         }
217
218         wrmsrl(MSR_IA32_CR_PAT, pat);
219
220 done:
221         pat_init_cache_modes(pat);
222 }
223
224 static void pat_ap_init(u64 pat)
225 {
226         if (!pat_enabled())
227                 return;
228
229         if (!cpu_has_pat) {
230                 /*
231                  * If this happens we are on a secondary CPU, but switched to
232                  * PAT on the boot CPU. We have no way to undo PAT.
233                  */
234                 panic("x86/PAT: PAT enabled, but not supported by secondary CPU\n");
235         }
236
237         wrmsrl(MSR_IA32_CR_PAT, pat);
238 }
239
240 void pat_init(void)
241 {
242         u64 pat;
243         struct cpuinfo_x86 *c = &boot_cpu_data;
244
245         if (!pat_enabled()) {
246                 /*
247                  * No PAT. Emulate the PAT table that corresponds to the two
248                  * cache bits, PWT (Write Through) and PCD (Cache Disable). This
249                  * setup is the same as the BIOS default setup when the system
250                  * has PAT but the "nopat" boot option has been specified. This
251                  * emulated PAT table is used when MSR_IA32_CR_PAT returns 0.
252                  *
253                  * PTE encoding:
254                  *
255                  *       PCD
256                  *       |PWT  PAT
257                  *       ||    slot
258                  *       00    0    WB : _PAGE_CACHE_MODE_WB
259                  *       01    1    WT : _PAGE_CACHE_MODE_WT
260                  *       10    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
261                  *       11    3    UC : _PAGE_CACHE_MODE_UC
262                  *
263                  * NOTE: When WC or WP is used, it is redirected to UC- per
264                  * the default setup in __cachemode2pte_tbl[].
265                  */
266                 pat = PAT(0, WB) | PAT(1, WT) | PAT(2, UC_MINUS) | PAT(3, UC) |
267                       PAT(4, WB) | PAT(5, WT) | PAT(6, UC_MINUS) | PAT(7, UC);
268
269         } else if ((c->x86_vendor == X86_VENDOR_INTEL) &&
270                    (((c->x86 == 0x6) && (c->x86_model <= 0xd)) ||
271                     ((c->x86 == 0xf) && (c->x86_model <= 0x6)))) {
272                 /*
273                  * PAT support with the lower four entries. Intel Pentium 2,
274                  * 3, M, and 4 are affected by PAT errata, which makes the
275                  * upper four entries unusable. To be on the safe side, we don't
276                  * use those.
277                  *
278                  *  PTE encoding:
279                  *      PAT
280                  *      |PCD
281                  *      ||PWT  PAT
282                  *      |||    slot
283                  *      000    0    WB : _PAGE_CACHE_MODE_WB
284                  *      001    1    WC : _PAGE_CACHE_MODE_WC
285                  *      010    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
286                  *      011    3    UC : _PAGE_CACHE_MODE_UC
287                  * PAT bit unused
288                  *
289                  * NOTE: When WT or WP is used, it is redirected to UC- per
290                  * the default setup in __cachemode2pte_tbl[].
291                  */
292                 pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
293                       PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
294         } else {
295                 /*
296                  * Full PAT support.  We put WT in slot 7 to improve
297                  * robustness in the presence of errata that might cause
298                  * the high PAT bit to be ignored.  This way, a buggy slot 7
299                  * access will hit slot 3, and slot 3 is UC, so at worst
300                  * we lose performance without causing a correctness issue.
301                  * Pentium 4 erratum N46 is an example for such an erratum,
302                  * although we try not to use PAT at all on affected CPUs.
303                  *
304                  *  PTE encoding:
305                  *      PAT
306                  *      |PCD
307                  *      ||PWT  PAT
308                  *      |||    slot
309                  *      000    0    WB : _PAGE_CACHE_MODE_WB
310                  *      001    1    WC : _PAGE_CACHE_MODE_WC
311                  *      010    2    UC-: _PAGE_CACHE_MODE_UC_MINUS
312                  *      011    3    UC : _PAGE_CACHE_MODE_UC
313                  *      100    4    WB : Reserved
314                  *      101    5    WC : Reserved
315                  *      110    6    UC-: Reserved
316                  *      111    7    WT : _PAGE_CACHE_MODE_WT
317                  *
318                  * The reserved slots are unused, but mapped to their
319                  * corresponding types in the presence of PAT errata.
320                  */
321                 pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
322                       PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, WT);
323         }
324
325         if (!boot_cpu_done) {
326                 pat_bsp_init(pat);
327                 boot_cpu_done = true;
328         } else {
329                 pat_ap_init(pat);
330         }
331 }
332
333 #undef PAT
334
335 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype accesses */
336
337 /*
338  * Does intersection of PAT memory type and MTRR memory type and returns
339  * the resulting memory type as PAT understands it.
340  * (Type in pat and mtrr will not have same value)
341  * The intersection is based on "Effective Memory Type" tables in IA-32
342  * SDM vol 3a
343  */
344 static unsigned long pat_x_mtrr_type(u64 start, u64 end,
345                                      enum page_cache_mode req_type)
346 {
347         /*
348          * Look for MTRR hint to get the effective type in case where PAT
349          * request is for WB.
350          */
351         if (req_type == _PAGE_CACHE_MODE_WB) {
352                 u8 mtrr_type, uniform;
353
354                 mtrr_type = mtrr_type_lookup(start, end, &uniform);
355                 if (mtrr_type != MTRR_TYPE_WRBACK)
356                         return _PAGE_CACHE_MODE_UC_MINUS;
357
358                 return _PAGE_CACHE_MODE_WB;
359         }
360
361         return req_type;
362 }
363
364 struct pagerange_state {
365         unsigned long           cur_pfn;
366         int                     ram;
367         int                     not_ram;
368 };
369
370 static int
371 pagerange_is_ram_callback(unsigned long initial_pfn, unsigned long total_nr_pages, void *arg)
372 {
373         struct pagerange_state *state = arg;
374
375         state->not_ram  |= initial_pfn > state->cur_pfn;
376         state->ram      |= total_nr_pages > 0;
377         state->cur_pfn   = initial_pfn + total_nr_pages;
378
379         return state->ram && state->not_ram;
380 }
381
382 static int pat_pagerange_is_ram(resource_size_t start, resource_size_t end)
383 {
384         int ret = 0;
385         unsigned long start_pfn = start >> PAGE_SHIFT;
386         unsigned long end_pfn = (end + PAGE_SIZE - 1) >> PAGE_SHIFT;
387         struct pagerange_state state = {start_pfn, 0, 0};
388
389         /*
390          * For legacy reasons, physical address range in the legacy ISA
391          * region is tracked as non-RAM. This will allow users of
392          * /dev/mem to map portions of legacy ISA region, even when
393          * some of those portions are listed(or not even listed) with
394          * different e820 types(RAM/reserved/..)
395          */
396         if (start_pfn < ISA_END_ADDRESS >> PAGE_SHIFT)
397                 start_pfn = ISA_END_ADDRESS >> PAGE_SHIFT;
398
399         if (start_pfn < end_pfn) {
400                 ret = walk_system_ram_range(start_pfn, end_pfn - start_pfn,
401                                 &state, pagerange_is_ram_callback);
402         }
403
404         return (ret > 0) ? -1 : (state.ram ? 1 : 0);
405 }
406
407 /*
408  * For RAM pages, we use page flags to mark the pages with appropriate type.
409  * The page flags are limited to four types, WB (default), WC, WT and UC-.
410  * WP request fails with -EINVAL, and UC gets redirected to UC-.  Setting
411  * a new memory type is only allowed for a page mapped with the default WB
412  * type.
413  *
414  * Here we do two passes:
415  * - Find the memtype of all the pages in the range, look for any conflicts.
416  * - In case of no conflicts, set the new memtype for pages in the range.
417  */
418 static int reserve_ram_pages_type(u64 start, u64 end,
419                                   enum page_cache_mode req_type,
420                                   enum page_cache_mode *new_type)
421 {
422         struct page *page;
423         u64 pfn;
424
425         if (req_type == _PAGE_CACHE_MODE_WP) {
426                 if (new_type)
427                         *new_type = _PAGE_CACHE_MODE_UC_MINUS;
428                 return -EINVAL;
429         }
430
431         if (req_type == _PAGE_CACHE_MODE_UC) {
432                 /* We do not support strong UC */
433                 WARN_ON_ONCE(1);
434                 req_type = _PAGE_CACHE_MODE_UC_MINUS;
435         }
436
437         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
438                 enum page_cache_mode type;
439
440                 page = pfn_to_page(pfn);
441                 type = get_page_memtype(page);
442                 if (type != _PAGE_CACHE_MODE_WB) {
443                         pr_info("x86/PAT: reserve_ram_pages_type failed [mem %#010Lx-%#010Lx], track 0x%x, req 0x%x\n",
444                                 start, end - 1, type, req_type);
445                         if (new_type)
446                                 *new_type = type;
447
448                         return -EBUSY;
449                 }
450         }
451
452         if (new_type)
453                 *new_type = req_type;
454
455         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
456                 page = pfn_to_page(pfn);
457                 set_page_memtype(page, req_type);
458         }
459         return 0;
460 }
461
462 static int free_ram_pages_type(u64 start, u64 end)
463 {
464         struct page *page;
465         u64 pfn;
466
467         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
468                 page = pfn_to_page(pfn);
469                 set_page_memtype(page, _PAGE_CACHE_MODE_WB);
470         }
471         return 0;
472 }
473
474 /*
475  * req_type typically has one of the:
476  * - _PAGE_CACHE_MODE_WB
477  * - _PAGE_CACHE_MODE_WC
478  * - _PAGE_CACHE_MODE_UC_MINUS
479  * - _PAGE_CACHE_MODE_UC
480  * - _PAGE_CACHE_MODE_WT
481  *
482  * If new_type is NULL, function will return an error if it cannot reserve the
483  * region with req_type. If new_type is non-NULL, function will return
484  * available type in new_type in case of no error. In case of any error
485  * it will return a negative return value.
486  */
487 int reserve_memtype(u64 start, u64 end, enum page_cache_mode req_type,
488                     enum page_cache_mode *new_type)
489 {
490         struct memtype *new;
491         enum page_cache_mode actual_type;
492         int is_range_ram;
493         int err = 0;
494
495         BUG_ON(start >= end); /* end is exclusive */
496
497         if (!pat_enabled()) {
498                 /* This is identical to page table setting without PAT */
499                 if (new_type)
500                         *new_type = req_type;
501                 return 0;
502         }
503
504         /* Low ISA region is always mapped WB in page table. No need to track */
505         if (x86_platform.is_untracked_pat_range(start, end)) {
506                 if (new_type)
507                         *new_type = _PAGE_CACHE_MODE_WB;
508                 return 0;
509         }
510
511         /*
512          * Call mtrr_lookup to get the type hint. This is an
513          * optimization for /dev/mem mmap'ers into WB memory (BIOS
514          * tools and ACPI tools). Use WB request for WB memory and use
515          * UC_MINUS otherwise.
516          */
517         actual_type = pat_x_mtrr_type(start, end, req_type);
518
519         if (new_type)
520                 *new_type = actual_type;
521
522         is_range_ram = pat_pagerange_is_ram(start, end);
523         if (is_range_ram == 1) {
524
525                 err = reserve_ram_pages_type(start, end, req_type, new_type);
526
527                 return err;
528         } else if (is_range_ram < 0) {
529                 return -EINVAL;
530         }
531
532         new  = kzalloc(sizeof(struct memtype), GFP_KERNEL);
533         if (!new)
534                 return -ENOMEM;
535
536         new->start      = start;
537         new->end        = end;
538         new->type       = actual_type;
539
540         spin_lock(&memtype_lock);
541
542         err = rbt_memtype_check_insert(new, new_type);
543         if (err) {
544                 pr_info("x86/PAT: reserve_memtype failed [mem %#010Lx-%#010Lx], track %s, req %s\n",
545                         start, end - 1,
546                         cattr_name(new->type), cattr_name(req_type));
547                 kfree(new);
548                 spin_unlock(&memtype_lock);
549
550                 return err;
551         }
552
553         spin_unlock(&memtype_lock);
554
555         dprintk("reserve_memtype added [mem %#010Lx-%#010Lx], track %s, req %s, ret %s\n",
556                 start, end - 1, cattr_name(new->type), cattr_name(req_type),
557                 new_type ? cattr_name(*new_type) : "-");
558
559         return err;
560 }
561
562 int free_memtype(u64 start, u64 end)
563 {
564         int err = -EINVAL;
565         int is_range_ram;
566         struct memtype *entry;
567
568         if (!pat_enabled())
569                 return 0;
570
571         /* Low ISA region is always mapped WB. No need to track */
572         if (x86_platform.is_untracked_pat_range(start, end))
573                 return 0;
574
575         is_range_ram = pat_pagerange_is_ram(start, end);
576         if (is_range_ram == 1) {
577
578                 err = free_ram_pages_type(start, end);
579
580                 return err;
581         } else if (is_range_ram < 0) {
582                 return -EINVAL;
583         }
584
585         spin_lock(&memtype_lock);
586         entry = rbt_memtype_erase(start, end);
587         spin_unlock(&memtype_lock);
588
589         if (!entry) {
590                 pr_info("x86/PAT: %s:%d freeing invalid memtype [mem %#010Lx-%#010Lx]\n",
591                         current->comm, current->pid, start, end - 1);
592                 return -EINVAL;
593         }
594
595         kfree(entry);
596
597         dprintk("free_memtype request [mem %#010Lx-%#010Lx]\n", start, end - 1);
598
599         return 0;
600 }
601
602
603 /**
604  * lookup_memtype - Looksup the memory type for a physical address
605  * @paddr: physical address of which memory type needs to be looked up
606  *
607  * Only to be called when PAT is enabled
608  *
609  * Returns _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC, _PAGE_CACHE_MODE_UC_MINUS
610  * or _PAGE_CACHE_MODE_WT.
611  */
612 static enum page_cache_mode lookup_memtype(u64 paddr)
613 {
614         enum page_cache_mode rettype = _PAGE_CACHE_MODE_WB;
615         struct memtype *entry;
616
617         if (x86_platform.is_untracked_pat_range(paddr, paddr + PAGE_SIZE))
618                 return rettype;
619
620         if (pat_pagerange_is_ram(paddr, paddr + PAGE_SIZE)) {
621                 struct page *page;
622
623                 page = pfn_to_page(paddr >> PAGE_SHIFT);
624                 return get_page_memtype(page);
625         }
626
627         spin_lock(&memtype_lock);
628
629         entry = rbt_memtype_lookup(paddr);
630         if (entry != NULL)
631                 rettype = entry->type;
632         else
633                 rettype = _PAGE_CACHE_MODE_UC_MINUS;
634
635         spin_unlock(&memtype_lock);
636         return rettype;
637 }
638
639 /**
640  * io_reserve_memtype - Request a memory type mapping for a region of memory
641  * @start: start (physical address) of the region
642  * @end: end (physical address) of the region
643  * @type: A pointer to memtype, with requested type. On success, requested
644  * or any other compatible type that was available for the region is returned
645  *
646  * On success, returns 0
647  * On failure, returns non-zero
648  */
649 int io_reserve_memtype(resource_size_t start, resource_size_t end,
650                         enum page_cache_mode *type)
651 {
652         resource_size_t size = end - start;
653         enum page_cache_mode req_type = *type;
654         enum page_cache_mode new_type;
655         int ret;
656
657         WARN_ON_ONCE(iomem_map_sanity_check(start, size));
658
659         ret = reserve_memtype(start, end, req_type, &new_type);
660         if (ret)
661                 goto out_err;
662
663         if (!is_new_memtype_allowed(start, size, req_type, new_type))
664                 goto out_free;
665
666         if (kernel_map_sync_memtype(start, size, new_type) < 0)
667                 goto out_free;
668
669         *type = new_type;
670         return 0;
671
672 out_free:
673         free_memtype(start, end);
674         ret = -EBUSY;
675 out_err:
676         return ret;
677 }
678
679 /**
680  * io_free_memtype - Release a memory type mapping for a region of memory
681  * @start: start (physical address) of the region
682  * @end: end (physical address) of the region
683  */
684 void io_free_memtype(resource_size_t start, resource_size_t end)
685 {
686         free_memtype(start, end);
687 }
688
689 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
690                                 unsigned long size, pgprot_t vma_prot)
691 {
692         return vma_prot;
693 }
694
695 #ifdef CONFIG_STRICT_DEVMEM
696 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM */
697 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
698 {
699         return 1;
700 }
701 #else
702 /* This check is needed to avoid cache aliasing when PAT is enabled */
703 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
704 {
705         u64 from = ((u64)pfn) << PAGE_SHIFT;
706         u64 to = from + size;
707         u64 cursor = from;
708
709         if (!pat_enabled())
710                 return 1;
711
712         while (cursor < to) {
713                 if (!devmem_is_allowed(pfn)) {
714                         pr_info("x86/PAT: Program %s tried to access /dev/mem between [mem %#010Lx-%#010Lx], PAT prevents it\n",
715                                 current->comm, from, to - 1);
716                         return 0;
717                 }
718                 cursor += PAGE_SIZE;
719                 pfn++;
720         }
721         return 1;
722 }
723 #endif /* CONFIG_STRICT_DEVMEM */
724
725 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
726                                 unsigned long size, pgprot_t *vma_prot)
727 {
728         enum page_cache_mode pcm = _PAGE_CACHE_MODE_WB;
729
730         if (!range_is_allowed(pfn, size))
731                 return 0;
732
733         if (file->f_flags & O_DSYNC)
734                 pcm = _PAGE_CACHE_MODE_UC_MINUS;
735
736 #ifdef CONFIG_X86_32
737         /*
738          * On the PPro and successors, the MTRRs are used to set
739          * memory types for physical addresses outside main memory,
740          * so blindly setting UC or PWT on those pages is wrong.
741          * For Pentiums and earlier, the surround logic should disable
742          * caching for the high addresses through the KEN pin, but
743          * we maintain the tradition of paranoia in this code.
744          */
745         if (!pat_enabled() &&
746             !(boot_cpu_has(X86_FEATURE_MTRR) ||
747               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
748               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
749               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
750             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
751                 pcm = _PAGE_CACHE_MODE_UC;
752         }
753 #endif
754
755         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
756                              cachemode2protval(pcm));
757         return 1;
758 }
759
760 /*
761  * Change the memory type for the physial address range in kernel identity
762  * mapping space if that range is a part of identity map.
763  */
764 int kernel_map_sync_memtype(u64 base, unsigned long size,
765                             enum page_cache_mode pcm)
766 {
767         unsigned long id_sz;
768
769         if (base > __pa(high_memory-1))
770                 return 0;
771
772         /*
773          * some areas in the middle of the kernel identity range
774          * are not mapped, like the PCI space.
775          */
776         if (!page_is_ram(base >> PAGE_SHIFT))
777                 return 0;
778
779         id_sz = (__pa(high_memory-1) <= base + size) ?
780                                 __pa(high_memory) - base :
781                                 size;
782
783         if (ioremap_change_attr((unsigned long)__va(base), id_sz, pcm) < 0) {
784                 pr_info("x86/PAT: %s:%d ioremap_change_attr failed %s for [mem %#010Lx-%#010Lx]\n",
785                         current->comm, current->pid,
786                         cattr_name(pcm),
787                         base, (unsigned long long)(base + size-1));
788                 return -EINVAL;
789         }
790         return 0;
791 }
792
793 /*
794  * Internal interface to reserve a range of physical memory with prot.
795  * Reserved non RAM regions only and after successful reserve_memtype,
796  * this func also keeps identity mapping (if any) in sync with this new prot.
797  */
798 static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot,
799                                 int strict_prot)
800 {
801         int is_ram = 0;
802         int ret;
803         enum page_cache_mode want_pcm = pgprot2cachemode(*vma_prot);
804         enum page_cache_mode pcm = want_pcm;
805
806         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
807
808         /*
809          * reserve_pfn_range() for RAM pages. We do not refcount to keep
810          * track of number of mappings of RAM pages. We can assert that
811          * the type requested matches the type of first page in the range.
812          */
813         if (is_ram) {
814                 if (!pat_enabled())
815                         return 0;
816
817                 pcm = lookup_memtype(paddr);
818                 if (want_pcm != pcm) {
819                         pr_warn("x86/PAT: %s:%d map pfn RAM range req %s for [mem %#010Lx-%#010Lx], got %s\n",
820                                 current->comm, current->pid,
821                                 cattr_name(want_pcm),
822                                 (unsigned long long)paddr,
823                                 (unsigned long long)(paddr + size - 1),
824                                 cattr_name(pcm));
825                         *vma_prot = __pgprot((pgprot_val(*vma_prot) &
826                                              (~_PAGE_CACHE_MASK)) |
827                                              cachemode2protval(pcm));
828                 }
829                 return 0;
830         }
831
832         ret = reserve_memtype(paddr, paddr + size, want_pcm, &pcm);
833         if (ret)
834                 return ret;
835
836         if (pcm != want_pcm) {
837                 if (strict_prot ||
838                     !is_new_memtype_allowed(paddr, size, want_pcm, pcm)) {
839                         free_memtype(paddr, paddr + size);
840                         pr_err("x86/PAT: %s:%d map pfn expected mapping type %s for [mem %#010Lx-%#010Lx], got %s\n",
841                                current->comm, current->pid,
842                                cattr_name(want_pcm),
843                                (unsigned long long)paddr,
844                                (unsigned long long)(paddr + size - 1),
845                                cattr_name(pcm));
846                         return -EINVAL;
847                 }
848                 /*
849                  * We allow returning different type than the one requested in
850                  * non strict case.
851                  */
852                 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
853                                       (~_PAGE_CACHE_MASK)) |
854                                      cachemode2protval(pcm));
855         }
856
857         if (kernel_map_sync_memtype(paddr, size, pcm) < 0) {
858                 free_memtype(paddr, paddr + size);
859                 return -EINVAL;
860         }
861         return 0;
862 }
863
864 /*
865  * Internal interface to free a range of physical memory.
866  * Frees non RAM regions only.
867  */
868 static void free_pfn_range(u64 paddr, unsigned long size)
869 {
870         int is_ram;
871
872         is_ram = pat_pagerange_is_ram(paddr, paddr + size);
873         if (is_ram == 0)
874                 free_memtype(paddr, paddr + size);
875 }
876
877 /*
878  * track_pfn_copy is called when vma that is covering the pfnmap gets
879  * copied through copy_page_range().
880  *
881  * If the vma has a linear pfn mapping for the entire range, we get the prot
882  * from pte and reserve the entire vma range with single reserve_pfn_range call.
883  */
884 int track_pfn_copy(struct vm_area_struct *vma)
885 {
886         resource_size_t paddr;
887         unsigned long prot;
888         unsigned long vma_size = vma->vm_end - vma->vm_start;
889         pgprot_t pgprot;
890
891         if (vma->vm_flags & VM_PAT) {
892                 /*
893                  * reserve the whole chunk covered by vma. We need the
894                  * starting address and protection from pte.
895                  */
896                 if (follow_phys(vma, vma->vm_start, 0, &prot, &paddr)) {
897                         WARN_ON_ONCE(1);
898                         return -EINVAL;
899                 }
900                 pgprot = __pgprot(prot);
901                 return reserve_pfn_range(paddr, vma_size, &pgprot, 1);
902         }
903
904         return 0;
905 }
906
907 /*
908  * prot is passed in as a parameter for the new mapping. If the vma has a
909  * linear pfn mapping for the entire range reserve the entire vma range with
910  * single reserve_pfn_range call.
911  */
912 int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
913                     unsigned long pfn, unsigned long addr, unsigned long size)
914 {
915         resource_size_t paddr = (resource_size_t)pfn << PAGE_SHIFT;
916         enum page_cache_mode pcm;
917
918         /* reserve the whole chunk starting from paddr */
919         if (addr == vma->vm_start && size == (vma->vm_end - vma->vm_start)) {
920                 int ret;
921
922                 ret = reserve_pfn_range(paddr, size, prot, 0);
923                 if (!ret)
924                         vma->vm_flags |= VM_PAT;
925                 return ret;
926         }
927
928         if (!pat_enabled())
929                 return 0;
930
931         /*
932          * For anything smaller than the vma size we set prot based on the
933          * lookup.
934          */
935         pcm = lookup_memtype(paddr);
936
937         /* Check memtype for the remaining pages */
938         while (size > PAGE_SIZE) {
939                 size -= PAGE_SIZE;
940                 paddr += PAGE_SIZE;
941                 if (pcm != lookup_memtype(paddr))
942                         return -EINVAL;
943         }
944
945         *prot = __pgprot((pgprot_val(vma->vm_page_prot) & (~_PAGE_CACHE_MASK)) |
946                          cachemode2protval(pcm));
947
948         return 0;
949 }
950
951 int track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
952                      unsigned long pfn)
953 {
954         enum page_cache_mode pcm;
955
956         if (!pat_enabled())
957                 return 0;
958
959         /* Set prot based on lookup */
960         pcm = lookup_memtype((resource_size_t)pfn << PAGE_SHIFT);
961         *prot = __pgprot((pgprot_val(vma->vm_page_prot) & (~_PAGE_CACHE_MASK)) |
962                          cachemode2protval(pcm));
963
964         return 0;
965 }
966
967 /*
968  * untrack_pfn is called while unmapping a pfnmap for a region.
969  * untrack can be called for a specific region indicated by pfn and size or
970  * can be for the entire vma (in which case pfn, size are zero).
971  */
972 void untrack_pfn(struct vm_area_struct *vma, unsigned long pfn,
973                  unsigned long size)
974 {
975         resource_size_t paddr;
976         unsigned long prot;
977
978         if (!(vma->vm_flags & VM_PAT))
979                 return;
980
981         /* free the chunk starting from pfn or the whole chunk */
982         paddr = (resource_size_t)pfn << PAGE_SHIFT;
983         if (!paddr && !size) {
984                 if (follow_phys(vma, vma->vm_start, 0, &prot, &paddr)) {
985                         WARN_ON_ONCE(1);
986                         return;
987                 }
988
989                 size = vma->vm_end - vma->vm_start;
990         }
991         free_pfn_range(paddr, size);
992         vma->vm_flags &= ~VM_PAT;
993 }
994
995 pgprot_t pgprot_writecombine(pgprot_t prot)
996 {
997         return __pgprot(pgprot_val(prot) |
998                                 cachemode2protval(_PAGE_CACHE_MODE_WC));
999 }
1000 EXPORT_SYMBOL_GPL(pgprot_writecombine);
1001
1002 pgprot_t pgprot_writethrough(pgprot_t prot)
1003 {
1004         return __pgprot(pgprot_val(prot) |
1005                                 cachemode2protval(_PAGE_CACHE_MODE_WT));
1006 }
1007 EXPORT_SYMBOL_GPL(pgprot_writethrough);
1008
1009 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
1010
1011 static struct memtype *memtype_get_idx(loff_t pos)
1012 {
1013         struct memtype *print_entry;
1014         int ret;
1015
1016         print_entry  = kzalloc(sizeof(struct memtype), GFP_KERNEL);
1017         if (!print_entry)
1018                 return NULL;
1019
1020         spin_lock(&memtype_lock);
1021         ret = rbt_memtype_copy_nth_element(print_entry, pos);
1022         spin_unlock(&memtype_lock);
1023
1024         if (!ret) {
1025                 return print_entry;
1026         } else {
1027                 kfree(print_entry);
1028                 return NULL;
1029         }
1030 }
1031
1032 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
1033 {
1034         if (*pos == 0) {
1035                 ++*pos;
1036                 seq_puts(seq, "PAT memtype list:\n");
1037         }
1038
1039         return memtype_get_idx(*pos);
1040 }
1041
1042 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1043 {
1044         ++*pos;
1045         return memtype_get_idx(*pos);
1046 }
1047
1048 static void memtype_seq_stop(struct seq_file *seq, void *v)
1049 {
1050 }
1051
1052 static int memtype_seq_show(struct seq_file *seq, void *v)
1053 {
1054         struct memtype *print_entry = (struct memtype *)v;
1055
1056         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
1057                         print_entry->start, print_entry->end);
1058         kfree(print_entry);
1059
1060         return 0;
1061 }
1062
1063 static const struct seq_operations memtype_seq_ops = {
1064         .start = memtype_seq_start,
1065         .next  = memtype_seq_next,
1066         .stop  = memtype_seq_stop,
1067         .show  = memtype_seq_show,
1068 };
1069
1070 static int memtype_seq_open(struct inode *inode, struct file *file)
1071 {
1072         return seq_open(file, &memtype_seq_ops);
1073 }
1074
1075 static const struct file_operations memtype_fops = {
1076         .open    = memtype_seq_open,
1077         .read    = seq_read,
1078         .llseek  = seq_lseek,
1079         .release = seq_release,
1080 };
1081
1082 static int __init pat_memtype_list_init(void)
1083 {
1084         if (pat_enabled()) {
1085                 debugfs_create_file("pat_memtype_list", S_IRUSR,
1086                                     arch_debugfs_dir, NULL, &memtype_fops);
1087         }
1088         return 0;
1089 }
1090
1091 late_initcall(pat_memtype_list_init);
1092
1093 #endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */