Merge branch 'x86/for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip...
[linux-2.6] / 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/mm.h>
11 #include <linux/kernel.h>
12 #include <linux/gfp.h>
13 #include <linux/fs.h>
14 #include <linux/bootmem.h>
15 #include <linux/debugfs.h>
16 #include <linux/seq_file.h>
17
18 #include <asm/msr.h>
19 #include <asm/tlbflush.h>
20 #include <asm/processor.h>
21 #include <asm/page.h>
22 #include <asm/pgtable.h>
23 #include <asm/pat.h>
24 #include <asm/e820.h>
25 #include <asm/cacheflush.h>
26 #include <asm/fcntl.h>
27 #include <asm/mtrr.h>
28 #include <asm/io.h>
29
30 #ifdef CONFIG_X86_PAT
31 int __read_mostly pat_enabled = 1;
32
33 void __cpuinit pat_disable(char *reason)
34 {
35         pat_enabled = 0;
36         printk(KERN_INFO "%s\n", reason);
37 }
38
39 static int __init nopat(char *str)
40 {
41         pat_disable("PAT support disabled.");
42         return 0;
43 }
44 early_param("nopat", nopat);
45 #endif
46
47
48 static int debug_enable;
49 static int __init pat_debug_setup(char *str)
50 {
51         debug_enable = 1;
52         return 0;
53 }
54 __setup("debugpat", pat_debug_setup);
55
56 #define dprintk(fmt, arg...) \
57         do { if (debug_enable) printk(KERN_INFO fmt, ##arg); } while (0)
58
59
60 static u64 __read_mostly boot_pat_state;
61
62 enum {
63         PAT_UC = 0,             /* uncached */
64         PAT_WC = 1,             /* Write combining */
65         PAT_WT = 4,             /* Write Through */
66         PAT_WP = 5,             /* Write Protected */
67         PAT_WB = 6,             /* Write Back (default) */
68         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
69 };
70
71 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
72
73 void pat_init(void)
74 {
75         u64 pat;
76
77         if (!pat_enabled)
78                 return;
79
80         /* Paranoia check. */
81         if (!cpu_has_pat && boot_pat_state) {
82                 /*
83                  * If this happens we are on a secondary CPU, but
84                  * switched to PAT on the boot CPU. We have no way to
85                  * undo PAT.
86                  */
87                 printk(KERN_ERR "PAT enabled, "
88                        "but not supported by secondary CPU\n");
89                 BUG();
90         }
91
92         /* Set PWT to Write-Combining. All other bits stay the same */
93         /*
94          * PTE encoding used in Linux:
95          *      PAT
96          *      |PCD
97          *      ||PWT
98          *      |||
99          *      000 WB          _PAGE_CACHE_WB
100          *      001 WC          _PAGE_CACHE_WC
101          *      010 UC-         _PAGE_CACHE_UC_MINUS
102          *      011 UC          _PAGE_CACHE_UC
103          * PAT bit unused
104          */
105         pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
106               PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
107
108         /* Boot CPU check */
109         if (!boot_pat_state)
110                 rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
111
112         wrmsrl(MSR_IA32_CR_PAT, pat);
113         printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
114                smp_processor_id(), boot_pat_state, pat);
115 }
116
117 #undef PAT
118
119 static char *cattr_name(unsigned long flags)
120 {
121         switch (flags & _PAGE_CACHE_MASK) {
122         case _PAGE_CACHE_UC:            return "uncached";
123         case _PAGE_CACHE_UC_MINUS:      return "uncached-minus";
124         case _PAGE_CACHE_WB:            return "write-back";
125         case _PAGE_CACHE_WC:            return "write-combining";
126         default:                        return "broken";
127         }
128 }
129
130 /*
131  * The global memtype list keeps track of memory type for specific
132  * physical memory areas. Conflicting memory types in different
133  * mappings can cause CPU cache corruption. To avoid this we keep track.
134  *
135  * The list is sorted based on starting address and can contain multiple
136  * entries for each address (this allows reference counting for overlapping
137  * areas). All the aliases have the same cache attributes of course.
138  * Zero attributes are represented as holes.
139  *
140  * Currently the data structure is a list because the number of mappings
141  * are expected to be relatively small. If this should be a problem
142  * it could be changed to a rbtree or similar.
143  *
144  * memtype_lock protects the whole list.
145  */
146
147 struct memtype {
148         u64 start;
149         u64 end;
150         unsigned long type;
151         struct list_head nd;
152 };
153
154 static LIST_HEAD(memtype_list);
155 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype list */
156
157 /*
158  * Does intersection of PAT memory type and MTRR memory type and returns
159  * the resulting memory type as PAT understands it.
160  * (Type in pat and mtrr will not have same value)
161  * The intersection is based on "Effective Memory Type" tables in IA-32
162  * SDM vol 3a
163  */
164 static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
165 {
166         /*
167          * Look for MTRR hint to get the effective type in case where PAT
168          * request is for WB.
169          */
170         if (req_type == _PAGE_CACHE_WB) {
171                 u8 mtrr_type;
172
173                 mtrr_type = mtrr_type_lookup(start, end);
174                 if (mtrr_type == MTRR_TYPE_UNCACHABLE)
175                         return _PAGE_CACHE_UC;
176                 if (mtrr_type == MTRR_TYPE_WRCOMB)
177                         return _PAGE_CACHE_WC;
178         }
179
180         return req_type;
181 }
182
183 static int chk_conflict(struct memtype *new, struct memtype *entry,
184                         unsigned long *type)
185 {
186         if (new->type != entry->type) {
187                 if (type) {
188                         new->type = entry->type;
189                         *type = entry->type;
190                 } else
191                         goto conflict;
192         }
193
194          /* check overlaps with more than one entry in the list */
195         list_for_each_entry_continue(entry, &memtype_list, nd) {
196                 if (new->end <= entry->start)
197                         break;
198                 else if (new->type != entry->type)
199                         goto conflict;
200         }
201         return 0;
202
203  conflict:
204         printk(KERN_INFO "%s:%d conflicting memory types "
205                "%Lx-%Lx %s<->%s\n", current->comm, current->pid, new->start,
206                new->end, cattr_name(new->type), cattr_name(entry->type));
207         return -EBUSY;
208 }
209
210 /*
211  * req_type typically has one of the:
212  * - _PAGE_CACHE_WB
213  * - _PAGE_CACHE_WC
214  * - _PAGE_CACHE_UC_MINUS
215  * - _PAGE_CACHE_UC
216  *
217  * req_type will have a special case value '-1', when requester want to inherit
218  * the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.
219  *
220  * If new_type is NULL, function will return an error if it cannot reserve the
221  * region with req_type. If new_type is non-NULL, function will return
222  * available type in new_type in case of no error. In case of any error
223  * it will return a negative return value.
224  */
225 int reserve_memtype(u64 start, u64 end, unsigned long req_type,
226                         unsigned long *new_type)
227 {
228         struct memtype *new, *entry;
229         unsigned long actual_type;
230         struct list_head *where;
231         int err = 0;
232
233         BUG_ON(start >= end); /* end is exclusive */
234
235         if (!pat_enabled) {
236                 /* This is identical to page table setting without PAT */
237                 if (new_type) {
238                         if (req_type == -1)
239                                 *new_type = _PAGE_CACHE_WB;
240                         else
241                                 *new_type = req_type & _PAGE_CACHE_MASK;
242                 }
243                 return 0;
244         }
245
246         /* Low ISA region is always mapped WB in page table. No need to track */
247         if (is_ISA_range(start, end - 1)) {
248                 if (new_type)
249                         *new_type = _PAGE_CACHE_WB;
250                 return 0;
251         }
252
253         if (req_type == -1) {
254                 /*
255                  * Call mtrr_lookup to get the type hint. This is an
256                  * optimization for /dev/mem mmap'ers into WB memory (BIOS
257                  * tools and ACPI tools). Use WB request for WB memory and use
258                  * UC_MINUS otherwise.
259                  */
260                 u8 mtrr_type = mtrr_type_lookup(start, end);
261
262                 if (mtrr_type == MTRR_TYPE_WRBACK)
263                         actual_type = _PAGE_CACHE_WB;
264                 else
265                         actual_type = _PAGE_CACHE_UC_MINUS;
266         } else
267                 actual_type = pat_x_mtrr_type(start, end,
268                                               req_type & _PAGE_CACHE_MASK);
269
270         new  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
271         if (!new)
272                 return -ENOMEM;
273
274         new->start = start;
275         new->end = end;
276         new->type = actual_type;
277
278         if (new_type)
279                 *new_type = actual_type;
280
281         spin_lock(&memtype_lock);
282
283         /* Search for existing mapping that overlaps the current range */
284         where = NULL;
285         list_for_each_entry(entry, &memtype_list, nd) {
286                 if (end <= entry->start) {
287                         where = entry->nd.prev;
288                         break;
289                 } else if (start <= entry->start) { /* end > entry->start */
290                         err = chk_conflict(new, entry, new_type);
291                         if (!err) {
292                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
293                                         entry->start, entry->end);
294                                 where = entry->nd.prev;
295                         }
296                         break;
297                 } else if (start < entry->end) { /* start > entry->start */
298                         err = chk_conflict(new, entry, new_type);
299                         if (!err) {
300                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
301                                         entry->start, entry->end);
302                                 where = &entry->nd;
303                         }
304                         break;
305                 }
306         }
307
308         if (err) {
309                 printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
310                        "track %s, req %s\n",
311                        start, end, cattr_name(new->type), cattr_name(req_type));
312                 kfree(new);
313                 spin_unlock(&memtype_lock);
314                 return err;
315         }
316
317         if (where)
318                 list_add(&new->nd, where);
319         else
320                 list_add_tail(&new->nd, &memtype_list);
321
322         spin_unlock(&memtype_lock);
323
324         dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
325                 start, end, cattr_name(new->type), cattr_name(req_type),
326                 new_type ? cattr_name(*new_type) : "-");
327
328         return err;
329 }
330
331 int free_memtype(u64 start, u64 end)
332 {
333         struct memtype *entry;
334         int err = -EINVAL;
335
336         if (!pat_enabled)
337                 return 0;
338
339         /* Low ISA region is always mapped WB. No need to track */
340         if (is_ISA_range(start, end - 1))
341                 return 0;
342
343         spin_lock(&memtype_lock);
344         list_for_each_entry(entry, &memtype_list, nd) {
345                 if (entry->start == start && entry->end == end) {
346                         list_del(&entry->nd);
347                         kfree(entry);
348                         err = 0;
349                         break;
350                 }
351         }
352         spin_unlock(&memtype_lock);
353
354         if (err) {
355                 printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
356                         current->comm, current->pid, start, end);
357         }
358
359         dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
360         return err;
361 }
362
363
364 /*
365  * /dev/mem mmap interface. The memtype used for mapping varies:
366  * - Use UC for mappings with O_SYNC flag
367  * - Without O_SYNC flag, if there is any conflict in reserve_memtype,
368  *   inherit the memtype from existing mapping.
369  * - Else use UC_MINUS memtype (for backward compatibility with existing
370  *   X drivers.
371  */
372 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
373                                 unsigned long size, pgprot_t vma_prot)
374 {
375         return vma_prot;
376 }
377
378 #ifdef CONFIG_STRICT_DEVMEM
379 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
380 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
381 {
382         return 1;
383 }
384 #else
385 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
386 {
387         u64 from = ((u64)pfn) << PAGE_SHIFT;
388         u64 to = from + size;
389         u64 cursor = from;
390
391         while (cursor < to) {
392                 if (!devmem_is_allowed(pfn)) {
393                         printk(KERN_INFO
394                 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
395                                 current->comm, from, to);
396                         return 0;
397                 }
398                 cursor += PAGE_SIZE;
399                 pfn++;
400         }
401         return 1;
402 }
403 #endif /* CONFIG_STRICT_DEVMEM */
404
405 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
406                                 unsigned long size, pgprot_t *vma_prot)
407 {
408         u64 offset = ((u64) pfn) << PAGE_SHIFT;
409         unsigned long flags = _PAGE_CACHE_UC_MINUS;
410         int retval;
411
412         if (!range_is_allowed(pfn, size))
413                 return 0;
414
415         if (file->f_flags & O_SYNC) {
416                 flags = _PAGE_CACHE_UC;
417         }
418
419 #ifdef CONFIG_X86_32
420         /*
421          * On the PPro and successors, the MTRRs are used to set
422          * memory types for physical addresses outside main memory,
423          * so blindly setting UC or PWT on those pages is wrong.
424          * For Pentiums and earlier, the surround logic should disable
425          * caching for the high addresses through the KEN pin, but
426          * we maintain the tradition of paranoia in this code.
427          */
428         if (!pat_enabled &&
429             !(boot_cpu_has(X86_FEATURE_MTRR) ||
430               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
431               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
432               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
433             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
434                 flags = _PAGE_CACHE_UC;
435         }
436 #endif
437
438         /*
439          * With O_SYNC, we can only take UC mapping. Fail if we cannot.
440          * Without O_SYNC, we want to get
441          * - WB for WB-able memory and no other conflicting mappings
442          * - UC_MINUS for non-WB-able memory with no other conflicting mappings
443          * - Inherit from confliting mappings otherwise
444          */
445         if (flags != _PAGE_CACHE_UC_MINUS) {
446                 retval = reserve_memtype(offset, offset + size, flags, NULL);
447         } else {
448                 retval = reserve_memtype(offset, offset + size, -1, &flags);
449         }
450
451         if (retval < 0)
452                 return 0;
453
454         if (((pfn < max_low_pfn_mapped) ||
455              (pfn >= (1UL<<(32 - PAGE_SHIFT)) && pfn < max_pfn_mapped)) &&
456             ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
457                 free_memtype(offset, offset + size);
458                 printk(KERN_INFO
459                 "%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
460                         current->comm, current->pid,
461                         cattr_name(flags),
462                         offset, (unsigned long long)(offset + size));
463                 return 0;
464         }
465
466         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
467                              flags);
468         return 1;
469 }
470
471 void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
472 {
473         u64 addr = (u64)pfn << PAGE_SHIFT;
474         unsigned long flags;
475         unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
476
477         reserve_memtype(addr, addr + size, want_flags, &flags);
478         if (flags != want_flags) {
479                 printk(KERN_INFO
480                 "%s:%d /dev/mem expected mapping type %s for %Lx-%Lx, got %s\n",
481                         current->comm, current->pid,
482                         cattr_name(want_flags),
483                         addr, (unsigned long long)(addr + size),
484                         cattr_name(flags));
485         }
486 }
487
488 void unmap_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
489 {
490         u64 addr = (u64)pfn << PAGE_SHIFT;
491
492         free_memtype(addr, addr + size);
493 }
494
495 #if defined(CONFIG_DEBUG_FS)
496
497 /* get Nth element of the linked list */
498 static struct memtype *memtype_get_idx(loff_t pos)
499 {
500         struct memtype *list_node, *print_entry;
501         int i = 1;
502
503         print_entry  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
504         if (!print_entry)
505                 return NULL;
506
507         spin_lock(&memtype_lock);
508         list_for_each_entry(list_node, &memtype_list, nd) {
509                 if (pos == i) {
510                         *print_entry = *list_node;
511                         spin_unlock(&memtype_lock);
512                         return print_entry;
513                 }
514                 ++i;
515         }
516         spin_unlock(&memtype_lock);
517         kfree(print_entry);
518         return NULL;
519 }
520
521 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
522 {
523         if (*pos == 0) {
524                 ++*pos;
525                 seq_printf(seq, "PAT memtype list:\n");
526         }
527
528         return memtype_get_idx(*pos);
529 }
530
531 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
532 {
533         ++*pos;
534         return memtype_get_idx(*pos);
535 }
536
537 static void memtype_seq_stop(struct seq_file *seq, void *v)
538 {
539 }
540
541 static int memtype_seq_show(struct seq_file *seq, void *v)
542 {
543         struct memtype *print_entry = (struct memtype *)v;
544
545         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
546                         print_entry->start, print_entry->end);
547         kfree(print_entry);
548         return 0;
549 }
550
551 static struct seq_operations memtype_seq_ops = {
552         .start = memtype_seq_start,
553         .next  = memtype_seq_next,
554         .stop  = memtype_seq_stop,
555         .show  = memtype_seq_show,
556 };
557
558 static int memtype_seq_open(struct inode *inode, struct file *file)
559 {
560         return seq_open(file, &memtype_seq_ops);
561 }
562
563 static const struct file_operations memtype_fops = {
564         .open    = memtype_seq_open,
565         .read    = seq_read,
566         .llseek  = seq_lseek,
567         .release = seq_release,
568 };
569
570 static int __init pat_memtype_list_init(void)
571 {
572         debugfs_create_file("pat_memtype_list", S_IRUSR, arch_debugfs_dir,
573                                 NULL, &memtype_fops);
574         return 0;
575 }
576
577 late_initcall(pat_memtype_list_init);
578
579 #endif /* CONFIG_DEBUG_FS */