Merge branch 'x86/mm' into x86/core
[linux-2.6.git] / 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/gfp.h>
15 #include <linux/mm.h>
16 #include <linux/fs.h>
17
18 #include <asm/cacheflush.h>
19 #include <asm/processor.h>
20 #include <asm/tlbflush.h>
21 #include <asm/pgtable.h>
22 #include <asm/fcntl.h>
23 #include <asm/e820.h>
24 #include <asm/mtrr.h>
25 #include <asm/page.h>
26 #include <asm/msr.h>
27 #include <asm/pat.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(const 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 #else
46 static inline void pat_disable(const char *reason)
47 {
48         (void)reason;
49 }
50 #endif
51
52
53 static int debug_enable;
54
55 static int __init pat_debug_setup(char *str)
56 {
57         debug_enable = 1;
58         return 0;
59 }
60 __setup("debugpat", pat_debug_setup);
61
62 #define dprintk(fmt, arg...) \
63         do { if (debug_enable) printk(KERN_INFO fmt, ##arg); } while (0)
64
65
66 static u64 __read_mostly boot_pat_state;
67
68 enum {
69         PAT_UC = 0,             /* uncached */
70         PAT_WC = 1,             /* Write combining */
71         PAT_WT = 4,             /* Write Through */
72         PAT_WP = 5,             /* Write Protected */
73         PAT_WB = 6,             /* Write Back (default) */
74         PAT_UC_MINUS = 7,       /* UC, but can be overriden by MTRR */
75 };
76
77 #define PAT(x, y)       ((u64)PAT_ ## y << ((x)*8))
78
79 void pat_init(void)
80 {
81         u64 pat;
82
83         if (!pat_enabled)
84                 return;
85
86         if (!cpu_has_pat) {
87                 if (!boot_pat_state) {
88                         pat_disable("PAT not supported by CPU.");
89                         return;
90                 } else {
91                         /*
92                          * If this happens we are on a secondary CPU, but
93                          * switched to PAT on the boot CPU. We have no way to
94                          * undo PAT.
95                          */
96                         printk(KERN_ERR "PAT enabled, "
97                                "but not supported by secondary CPU\n");
98                         BUG();
99                 }
100         }
101
102         /* Set PWT to Write-Combining. All other bits stay the same */
103         /*
104          * PTE encoding used in Linux:
105          *      PAT
106          *      |PCD
107          *      ||PWT
108          *      |||
109          *      000 WB          _PAGE_CACHE_WB
110          *      001 WC          _PAGE_CACHE_WC
111          *      010 UC-         _PAGE_CACHE_UC_MINUS
112          *      011 UC          _PAGE_CACHE_UC
113          * PAT bit unused
114          */
115         pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
116               PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
117
118         /* Boot CPU check */
119         if (!boot_pat_state)
120                 rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
121
122         wrmsrl(MSR_IA32_CR_PAT, pat);
123         printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
124                smp_processor_id(), boot_pat_state, pat);
125 }
126
127 #undef PAT
128
129 static char *cattr_name(unsigned long flags)
130 {
131         switch (flags & _PAGE_CACHE_MASK) {
132         case _PAGE_CACHE_UC:            return "uncached";
133         case _PAGE_CACHE_UC_MINUS:      return "uncached-minus";
134         case _PAGE_CACHE_WB:            return "write-back";
135         case _PAGE_CACHE_WC:            return "write-combining";
136         default:                        return "broken";
137         }
138 }
139
140 /*
141  * The global memtype list keeps track of memory type for specific
142  * physical memory areas. Conflicting memory types in different
143  * mappings can cause CPU cache corruption. To avoid this we keep track.
144  *
145  * The list is sorted based on starting address and can contain multiple
146  * entries for each address (this allows reference counting for overlapping
147  * areas). All the aliases have the same cache attributes of course.
148  * Zero attributes are represented as holes.
149  *
150  * Currently the data structure is a list because the number of mappings
151  * are expected to be relatively small. If this should be a problem
152  * it could be changed to a rbtree or similar.
153  *
154  * memtype_lock protects the whole list.
155  */
156
157 struct memtype {
158         u64                     start;
159         u64                     end;
160         unsigned long           type;
161         struct list_head        nd;
162 };
163
164 static LIST_HEAD(memtype_list);
165 static DEFINE_SPINLOCK(memtype_lock);   /* protects memtype list */
166
167 /*
168  * Does intersection of PAT memory type and MTRR memory type and returns
169  * the resulting memory type as PAT understands it.
170  * (Type in pat and mtrr will not have same value)
171  * The intersection is based on "Effective Memory Type" tables in IA-32
172  * SDM vol 3a
173  */
174 static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
175 {
176         /*
177          * Look for MTRR hint to get the effective type in case where PAT
178          * request is for WB.
179          */
180         if (req_type == _PAGE_CACHE_WB) {
181                 u8 mtrr_type;
182
183                 mtrr_type = mtrr_type_lookup(start, end);
184                 if (mtrr_type == MTRR_TYPE_UNCACHABLE)
185                         return _PAGE_CACHE_UC;
186                 if (mtrr_type == MTRR_TYPE_WRCOMB)
187                         return _PAGE_CACHE_WC;
188         }
189
190         return req_type;
191 }
192
193 static int
194 chk_conflict(struct memtype *new, struct memtype *entry, unsigned long *type)
195 {
196         if (new->type != entry->type) {
197                 if (type) {
198                         new->type = entry->type;
199                         *type = entry->type;
200                 } else
201                         goto conflict;
202         }
203
204          /* check overlaps with more than one entry in the list */
205         list_for_each_entry_continue(entry, &memtype_list, nd) {
206                 if (new->end <= entry->start)
207                         break;
208                 else if (new->type != entry->type)
209                         goto conflict;
210         }
211         return 0;
212
213  conflict:
214         printk(KERN_INFO "%s:%d conflicting memory types "
215                "%Lx-%Lx %s<->%s\n", current->comm, current->pid, new->start,
216                new->end, cattr_name(new->type), cattr_name(entry->type));
217         return -EBUSY;
218 }
219
220 static struct memtype *cached_entry;
221 static u64 cached_start;
222
223 /*
224  * For RAM pages, mark the pages as non WB memory type using
225  * PageNonWB (PG_arch_1). We allow only one set_memory_uc() or
226  * set_memory_wc() on a RAM page at a time before marking it as WB again.
227  * This is ok, because only one driver will be owning the page and
228  * doing set_memory_*() calls.
229  *
230  * For now, we use PageNonWB to track that the RAM page is being mapped
231  * as non WB. In future, we will have to use one more flag
232  * (or some other mechanism in page_struct) to distinguish between
233  * UC and WC mapping.
234  */
235 static int reserve_ram_pages_type(u64 start, u64 end, unsigned long req_type,
236                                   unsigned long *new_type)
237 {
238         struct page *page;
239         u64 pfn, end_pfn;
240
241         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
242                 page = pfn_to_page(pfn);
243                 if (page_mapped(page) || PageNonWB(page))
244                         goto out;
245
246                 SetPageNonWB(page);
247         }
248         return 0;
249
250 out:
251         end_pfn = pfn;
252         for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
253                 page = pfn_to_page(pfn);
254                 ClearPageNonWB(page);
255         }
256
257         return -EINVAL;
258 }
259
260 static int free_ram_pages_type(u64 start, u64 end)
261 {
262         struct page *page;
263         u64 pfn, end_pfn;
264
265         for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
266                 page = pfn_to_page(pfn);
267                 if (page_mapped(page) || !PageNonWB(page))
268                         goto out;
269
270                 ClearPageNonWB(page);
271         }
272         return 0;
273
274 out:
275         end_pfn = pfn;
276         for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
277                 page = pfn_to_page(pfn);
278                 SetPageNonWB(page);
279         }
280         return -EINVAL;
281 }
282
283 /*
284  * req_type typically has one of the:
285  * - _PAGE_CACHE_WB
286  * - _PAGE_CACHE_WC
287  * - _PAGE_CACHE_UC_MINUS
288  * - _PAGE_CACHE_UC
289  *
290  * req_type will have a special case value '-1', when requester want to inherit
291  * the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.
292  *
293  * If new_type is NULL, function will return an error if it cannot reserve the
294  * region with req_type. If new_type is non-NULL, function will return
295  * available type in new_type in case of no error. In case of any error
296  * it will return a negative return value.
297  */
298 int reserve_memtype(u64 start, u64 end, unsigned long req_type,
299                     unsigned long *new_type)
300 {
301         struct memtype *new, *entry;
302         unsigned long actual_type;
303         struct list_head *where;
304         int is_range_ram;
305         int err = 0;
306
307         BUG_ON(start >= end); /* end is exclusive */
308
309         if (!pat_enabled) {
310                 /* This is identical to page table setting without PAT */
311                 if (new_type) {
312                         if (req_type == -1)
313                                 *new_type = _PAGE_CACHE_WB;
314                         else
315                                 *new_type = req_type & _PAGE_CACHE_MASK;
316                 }
317                 return 0;
318         }
319
320         /* Low ISA region is always mapped WB in page table. No need to track */
321         if (is_ISA_range(start, end - 1)) {
322                 if (new_type)
323                         *new_type = _PAGE_CACHE_WB;
324                 return 0;
325         }
326
327         if (req_type == -1) {
328                 /*
329                  * Call mtrr_lookup to get the type hint. This is an
330                  * optimization for /dev/mem mmap'ers into WB memory (BIOS
331                  * tools and ACPI tools). Use WB request for WB memory and use
332                  * UC_MINUS otherwise.
333                  */
334                 u8 mtrr_type = mtrr_type_lookup(start, end);
335
336                 if (mtrr_type == MTRR_TYPE_WRBACK)
337                         actual_type = _PAGE_CACHE_WB;
338                 else
339                         actual_type = _PAGE_CACHE_UC_MINUS;
340         } else {
341                 actual_type = pat_x_mtrr_type(start, end,
342                                               req_type & _PAGE_CACHE_MASK);
343         }
344
345         if (new_type)
346                 *new_type = actual_type;
347
348         /*
349          * For legacy reasons, some parts of the physical address range in the
350          * legacy 1MB region is treated as non-RAM (even when listed as RAM in
351          * the e820 tables).  So we will track the memory attributes of this
352          * legacy 1MB region using the linear memtype_list always.
353          */
354         if (end >= ISA_END_ADDRESS) {
355                 is_range_ram = pagerange_is_ram(start, end);
356                 if (is_range_ram == 1)
357                         return reserve_ram_pages_type(start, end, req_type,
358                                                       new_type);
359                 else if (is_range_ram < 0)
360                         return -EINVAL;
361         }
362
363         new  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
364         if (!new)
365                 return -ENOMEM;
366
367         new->start      = start;
368         new->end        = end;
369         new->type       = actual_type;
370
371         spin_lock(&memtype_lock);
372
373         if (cached_entry && start >= cached_start)
374                 entry = cached_entry;
375         else
376                 entry = list_entry(&memtype_list, struct memtype, nd);
377
378         /* Search for existing mapping that overlaps the current range */
379         where = NULL;
380         list_for_each_entry_continue(entry, &memtype_list, nd) {
381                 if (end <= entry->start) {
382                         where = entry->nd.prev;
383                         cached_entry = list_entry(where, struct memtype, nd);
384                         break;
385                 } else if (start <= entry->start) { /* end > entry->start */
386                         err = chk_conflict(new, entry, new_type);
387                         if (!err) {
388                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
389                                         entry->start, entry->end);
390                                 where = entry->nd.prev;
391                                 cached_entry = list_entry(where,
392                                                         struct memtype, nd);
393                         }
394                         break;
395                 } else if (start < entry->end) { /* start > entry->start */
396                         err = chk_conflict(new, entry, new_type);
397                         if (!err) {
398                                 dprintk("Overlap at 0x%Lx-0x%Lx\n",
399                                         entry->start, entry->end);
400                                 cached_entry = list_entry(entry->nd.prev,
401                                                         struct memtype, nd);
402
403                                 /*
404                                  * Move to right position in the linked
405                                  * list to add this new entry
406                                  */
407                                 list_for_each_entry_continue(entry,
408                                                         &memtype_list, nd) {
409                                         if (start <= entry->start) {
410                                                 where = entry->nd.prev;
411                                                 break;
412                                         }
413                                 }
414                         }
415                         break;
416                 }
417         }
418
419         if (err) {
420                 printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
421                        "track %s, req %s\n",
422                        start, end, cattr_name(new->type), cattr_name(req_type));
423                 kfree(new);
424                 spin_unlock(&memtype_lock);
425
426                 return err;
427         }
428
429         cached_start = start;
430
431         if (where)
432                 list_add(&new->nd, where);
433         else
434                 list_add_tail(&new->nd, &memtype_list);
435
436         spin_unlock(&memtype_lock);
437
438         dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
439                 start, end, cattr_name(new->type), cattr_name(req_type),
440                 new_type ? cattr_name(*new_type) : "-");
441
442         return err;
443 }
444
445 int free_memtype(u64 start, u64 end)
446 {
447         struct memtype *entry;
448         int err = -EINVAL;
449         int is_range_ram;
450
451         if (!pat_enabled)
452                 return 0;
453
454         /* Low ISA region is always mapped WB. No need to track */
455         if (is_ISA_range(start, end - 1))
456                 return 0;
457
458         /*
459          * For legacy reasons, some parts of the physical address range in the
460          * legacy 1MB region is treated as non-RAM (even when listed as RAM in
461          * the e820 tables).  So we will track the memory attributes of this
462          * legacy 1MB region using the linear memtype_list always.
463          */
464         if (end >= ISA_END_ADDRESS) {
465                 is_range_ram = pagerange_is_ram(start, end);
466                 if (is_range_ram == 1)
467                         return free_ram_pages_type(start, end);
468                 else if (is_range_ram < 0)
469                         return -EINVAL;
470         }
471
472         spin_lock(&memtype_lock);
473         list_for_each_entry(entry, &memtype_list, nd) {
474                 if (entry->start == start && entry->end == end) {
475                         if (cached_entry == entry || cached_start == start)
476                                 cached_entry = NULL;
477
478                         list_del(&entry->nd);
479                         kfree(entry);
480                         err = 0;
481                         break;
482                 }
483         }
484         spin_unlock(&memtype_lock);
485
486         if (err) {
487                 printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
488                         current->comm, current->pid, start, end);
489         }
490
491         dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
492
493         return err;
494 }
495
496
497 pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
498                                 unsigned long size, pgprot_t vma_prot)
499 {
500         return vma_prot;
501 }
502
503 #ifdef CONFIG_STRICT_DEVMEM
504 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
505 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
506 {
507         return 1;
508 }
509 #else
510 /* This check is needed to avoid cache aliasing when PAT is enabled */
511 static inline int range_is_allowed(unsigned long pfn, unsigned long size)
512 {
513         u64 from = ((u64)pfn) << PAGE_SHIFT;
514         u64 to = from + size;
515         u64 cursor = from;
516
517         if (!pat_enabled)
518                 return 1;
519
520         while (cursor < to) {
521                 if (!devmem_is_allowed(pfn)) {
522                         printk(KERN_INFO
523                 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
524                                 current->comm, from, to);
525                         return 0;
526                 }
527                 cursor += PAGE_SIZE;
528                 pfn++;
529         }
530         return 1;
531 }
532 #endif /* CONFIG_STRICT_DEVMEM */
533
534 int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
535                                 unsigned long size, pgprot_t *vma_prot)
536 {
537         u64 offset = ((u64) pfn) << PAGE_SHIFT;
538         unsigned long flags = -1;
539         int retval;
540
541         if (!range_is_allowed(pfn, size))
542                 return 0;
543
544         if (file->f_flags & O_SYNC) {
545                 flags = _PAGE_CACHE_UC_MINUS;
546         }
547
548 #ifdef CONFIG_X86_32
549         /*
550          * On the PPro and successors, the MTRRs are used to set
551          * memory types for physical addresses outside main memory,
552          * so blindly setting UC or PWT on those pages is wrong.
553          * For Pentiums and earlier, the surround logic should disable
554          * caching for the high addresses through the KEN pin, but
555          * we maintain the tradition of paranoia in this code.
556          */
557         if (!pat_enabled &&
558             !(boot_cpu_has(X86_FEATURE_MTRR) ||
559               boot_cpu_has(X86_FEATURE_K6_MTRR) ||
560               boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
561               boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
562             (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
563                 flags = _PAGE_CACHE_UC;
564         }
565 #endif
566
567         /*
568          * With O_SYNC, we can only take UC_MINUS mapping. Fail if we cannot.
569          *
570          * Without O_SYNC, we want to get
571          * - WB for WB-able memory and no other conflicting mappings
572          * - UC_MINUS for non-WB-able memory with no other conflicting mappings
573          * - Inherit from confliting mappings otherwise
574          */
575         if (flags != -1) {
576                 retval = reserve_memtype(offset, offset + size, flags, NULL);
577         } else {
578                 retval = reserve_memtype(offset, offset + size, -1, &flags);
579         }
580
581         if (retval < 0)
582                 return 0;
583
584         if (((pfn < max_low_pfn_mapped) ||
585              (pfn >= (1UL<<(32 - PAGE_SHIFT)) && pfn < max_pfn_mapped)) &&
586             ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
587                 free_memtype(offset, offset + size);
588                 printk(KERN_INFO
589                 "%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
590                         current->comm, current->pid,
591                         cattr_name(flags),
592                         offset, (unsigned long long)(offset + size));
593                 return 0;
594         }
595
596         *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
597                              flags);
598         return 1;
599 }
600
601 void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
602 {
603         unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
604         u64 addr = (u64)pfn << PAGE_SHIFT;
605         unsigned long flags;
606
607         reserve_memtype(addr, addr + size, want_flags, &flags);
608         if (flags != want_flags) {
609                 printk(KERN_INFO
610                 "%s:%d /dev/mem expected mapping type %s for %Lx-%Lx, got %s\n",
611                         current->comm, current->pid,
612                         cattr_name(want_flags),
613                         addr, (unsigned long long)(addr + size),
614                         cattr_name(flags));
615         }
616 }
617
618 void unmap_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
619 {
620         u64 addr = (u64)pfn << PAGE_SHIFT;
621
622         free_memtype(addr, addr + size);
623 }
624
625 /*
626  * Internal interface to reserve a range of physical memory with prot.
627  * Reserved non RAM regions only and after successful reserve_memtype,
628  * this func also keeps identity mapping (if any) in sync with this new prot.
629  */
630 static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot,
631                                 int strict_prot)
632 {
633         int is_ram = 0;
634         int id_sz, ret;
635         unsigned long flags;
636         unsigned long want_flags = (pgprot_val(*vma_prot) & _PAGE_CACHE_MASK);
637
638         is_ram = pagerange_is_ram(paddr, paddr + size);
639
640         if (is_ram != 0) {
641                 /*
642                  * For mapping RAM pages, drivers need to call
643                  * set_memory_[uc|wc|wb] directly, for reserve and free, before
644                  * setting up the PTE.
645                  */
646                 WARN_ON_ONCE(1);
647                 return 0;
648         }
649
650         ret = reserve_memtype(paddr, paddr + size, want_flags, &flags);
651         if (ret)
652                 return ret;
653
654         if (flags != want_flags) {
655                 if (strict_prot || !is_new_memtype_allowed(want_flags, flags)) {
656                         free_memtype(paddr, paddr + size);
657                         printk(KERN_ERR "%s:%d map pfn expected mapping type %s"
658                                 " for %Lx-%Lx, got %s\n",
659                                 current->comm, current->pid,
660                                 cattr_name(want_flags),
661                                 (unsigned long long)paddr,
662                                 (unsigned long long)(paddr + size),
663                                 cattr_name(flags));
664                         return -EINVAL;
665                 }
666                 /*
667                  * We allow returning different type than the one requested in
668                  * non strict case.
669                  */
670                 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
671                                       (~_PAGE_CACHE_MASK)) |
672                                      flags);
673         }
674
675         /* Need to keep identity mapping in sync */
676         if (paddr >= __pa(high_memory))
677                 return 0;
678
679         id_sz = (__pa(high_memory) < paddr + size) ?
680                                 __pa(high_memory) - paddr :
681                                 size;
682
683         if (ioremap_change_attr((unsigned long)__va(paddr), id_sz, flags) < 0) {
684                 free_memtype(paddr, paddr + size);
685                 printk(KERN_ERR
686                         "%s:%d reserve_pfn_range ioremap_change_attr failed %s "
687                         "for %Lx-%Lx\n",
688                         current->comm, current->pid,
689                         cattr_name(flags),
690                         (unsigned long long)paddr,
691                         (unsigned long long)(paddr + size));
692                 return -EINVAL;
693         }
694         return 0;
695 }
696
697 /*
698  * Internal interface to free a range of physical memory.
699  * Frees non RAM regions only.
700  */
701 static void free_pfn_range(u64 paddr, unsigned long size)
702 {
703         int is_ram;
704
705         is_ram = pagerange_is_ram(paddr, paddr + size);
706         if (is_ram == 0)
707                 free_memtype(paddr, paddr + size);
708 }
709
710 /*
711  * track_pfn_vma_copy is called when vma that is covering the pfnmap gets
712  * copied through copy_page_range().
713  *
714  * If the vma has a linear pfn mapping for the entire range, we get the prot
715  * from pte and reserve the entire vma range with single reserve_pfn_range call.
716  * Otherwise, we reserve the entire vma range, my ging through the PTEs page
717  * by page to get physical address and protection.
718  */
719 int track_pfn_vma_copy(struct vm_area_struct *vma)
720 {
721         int retval = 0;
722         unsigned long i, j;
723         resource_size_t paddr;
724         unsigned long prot;
725         unsigned long vma_start = vma->vm_start;
726         unsigned long vma_end = vma->vm_end;
727         unsigned long vma_size = vma_end - vma_start;
728         pgprot_t pgprot;
729
730         if (!pat_enabled)
731                 return 0;
732
733         if (is_linear_pfn_mapping(vma)) {
734                 /*
735                  * reserve the whole chunk covered by vma. We need the
736                  * starting address and protection from pte.
737                  */
738                 if (follow_phys(vma, vma_start, 0, &prot, &paddr)) {
739                         WARN_ON_ONCE(1);
740                         return -EINVAL;
741                 }
742                 pgprot = __pgprot(prot);
743                 return reserve_pfn_range(paddr, vma_size, &pgprot, 1);
744         }
745
746         /* reserve entire vma page by page, using pfn and prot from pte */
747         for (i = 0; i < vma_size; i += PAGE_SIZE) {
748                 if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
749                         continue;
750
751                 pgprot = __pgprot(prot);
752                 retval = reserve_pfn_range(paddr, PAGE_SIZE, &pgprot, 1);
753                 if (retval)
754                         goto cleanup_ret;
755         }
756         return 0;
757
758 cleanup_ret:
759         /* Reserve error: Cleanup partial reservation and return error */
760         for (j = 0; j < i; j += PAGE_SIZE) {
761                 if (follow_phys(vma, vma_start + j, 0, &prot, &paddr))
762                         continue;
763
764                 free_pfn_range(paddr, PAGE_SIZE);
765         }
766
767         return retval;
768 }
769
770 /*
771  * track_pfn_vma_new is called when a _new_ pfn mapping is being established
772  * for physical range indicated by pfn and size.
773  *
774  * prot is passed in as a parameter for the new mapping. If the vma has a
775  * linear pfn mapping for the entire range reserve the entire vma range with
776  * single reserve_pfn_range call.
777  * Otherwise, we look t the pfn and size and reserve only the specified range
778  * page by page.
779  *
780  * Note that this function can be called with caller trying to map only a
781  * subrange/page inside the vma.
782  */
783 int track_pfn_vma_new(struct vm_area_struct *vma, pgprot_t *prot,
784                         unsigned long pfn, unsigned long size)
785 {
786         int retval = 0;
787         unsigned long i, j;
788         resource_size_t base_paddr;
789         resource_size_t paddr;
790         unsigned long vma_start = vma->vm_start;
791         unsigned long vma_end = vma->vm_end;
792         unsigned long vma_size = vma_end - vma_start;
793
794         if (!pat_enabled)
795                 return 0;
796
797         if (is_linear_pfn_mapping(vma)) {
798                 /* reserve the whole chunk starting from vm_pgoff */
799                 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
800                 return reserve_pfn_range(paddr, vma_size, prot, 0);
801         }
802
803         /* reserve page by page using pfn and size */
804         base_paddr = (resource_size_t)pfn << PAGE_SHIFT;
805         for (i = 0; i < size; i += PAGE_SIZE) {
806                 paddr = base_paddr + i;
807                 retval = reserve_pfn_range(paddr, PAGE_SIZE, prot, 0);
808                 if (retval)
809                         goto cleanup_ret;
810         }
811         return 0;
812
813 cleanup_ret:
814         /* Reserve error: Cleanup partial reservation and return error */
815         for (j = 0; j < i; j += PAGE_SIZE) {
816                 paddr = base_paddr + j;
817                 free_pfn_range(paddr, PAGE_SIZE);
818         }
819
820         return retval;
821 }
822
823 /*
824  * untrack_pfn_vma is called while unmapping a pfnmap for a region.
825  * untrack can be called for a specific region indicated by pfn and size or
826  * can be for the entire vma (in which case size can be zero).
827  */
828 void untrack_pfn_vma(struct vm_area_struct *vma, unsigned long pfn,
829                         unsigned long size)
830 {
831         unsigned long i;
832         resource_size_t paddr;
833         unsigned long prot;
834         unsigned long vma_start = vma->vm_start;
835         unsigned long vma_end = vma->vm_end;
836         unsigned long vma_size = vma_end - vma_start;
837
838         if (!pat_enabled)
839                 return;
840
841         if (is_linear_pfn_mapping(vma)) {
842                 /* free the whole chunk starting from vm_pgoff */
843                 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
844                 free_pfn_range(paddr, vma_size);
845                 return;
846         }
847
848         if (size != 0 && size != vma_size) {
849                 /* free page by page, using pfn and size */
850                 paddr = (resource_size_t)pfn << PAGE_SHIFT;
851                 for (i = 0; i < size; i += PAGE_SIZE) {
852                         paddr = paddr + i;
853                         free_pfn_range(paddr, PAGE_SIZE);
854                 }
855         } else {
856                 /* free entire vma, page by page, using the pfn from pte */
857                 for (i = 0; i < vma_size; i += PAGE_SIZE) {
858                         if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
859                                 continue;
860
861                         free_pfn_range(paddr, PAGE_SIZE);
862                 }
863         }
864 }
865
866 pgprot_t pgprot_writecombine(pgprot_t prot)
867 {
868         if (pat_enabled)
869                 return __pgprot(pgprot_val(prot) | _PAGE_CACHE_WC);
870         else
871                 return pgprot_noncached(prot);
872 }
873
874 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
875
876 /* get Nth element of the linked list */
877 static struct memtype *memtype_get_idx(loff_t pos)
878 {
879         struct memtype *list_node, *print_entry;
880         int i = 1;
881
882         print_entry  = kmalloc(sizeof(struct memtype), GFP_KERNEL);
883         if (!print_entry)
884                 return NULL;
885
886         spin_lock(&memtype_lock);
887         list_for_each_entry(list_node, &memtype_list, nd) {
888                 if (pos == i) {
889                         *print_entry = *list_node;
890                         spin_unlock(&memtype_lock);
891                         return print_entry;
892                 }
893                 ++i;
894         }
895         spin_unlock(&memtype_lock);
896         kfree(print_entry);
897
898         return NULL;
899 }
900
901 static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
902 {
903         if (*pos == 0) {
904                 ++*pos;
905                 seq_printf(seq, "PAT memtype list:\n");
906         }
907
908         return memtype_get_idx(*pos);
909 }
910
911 static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
912 {
913         ++*pos;
914         return memtype_get_idx(*pos);
915 }
916
917 static void memtype_seq_stop(struct seq_file *seq, void *v)
918 {
919 }
920
921 static int memtype_seq_show(struct seq_file *seq, void *v)
922 {
923         struct memtype *print_entry = (struct memtype *)v;
924
925         seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
926                         print_entry->start, print_entry->end);
927         kfree(print_entry);
928
929         return 0;
930 }
931
932 static struct seq_operations memtype_seq_ops = {
933         .start = memtype_seq_start,
934         .next  = memtype_seq_next,
935         .stop  = memtype_seq_stop,
936         .show  = memtype_seq_show,
937 };
938
939 static int memtype_seq_open(struct inode *inode, struct file *file)
940 {
941         return seq_open(file, &memtype_seq_ops);
942 }
943
944 static const struct file_operations memtype_fops = {
945         .open    = memtype_seq_open,
946         .read    = seq_read,
947         .llseek  = seq_lseek,
948         .release = seq_release,
949 };
950
951 static int __init pat_memtype_list_init(void)
952 {
953         debugfs_create_file("pat_memtype_list", S_IRUSR, arch_debugfs_dir,
954                                 NULL, &memtype_fops);
955         return 0;
956 }
957
958 late_initcall(pat_memtype_list_init);
959
960 #endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */