blob: f6ff57b7efa514e0a7e1ec47ac8472ea868c13fa [file] [log] [blame]
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -07001/*
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
Ingo Molnarad2cde12008-09-30 13:20:45 +020010#include <linux/seq_file.h>
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -070011#include <linux/bootmem.h>
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -070012#include <linux/debugfs.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020013#include <linux/kernel.h>
Ingo Molnar92b9af92009-02-28 14:09:27 +010014#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090015#include <linux/slab.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020016#include <linux/mm.h>
17#include <linux/fs.h>
Venkatesh Pallipadi335ef892009-07-10 09:57:36 -070018#include <linux/rbtree.h>
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070019
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070020#include <asm/cacheflush.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020021#include <asm/processor.h>
22#include <asm/tlbflush.h>
Jack Steinerfd12a0d2009-11-19 14:23:41 -060023#include <asm/x86_init.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020024#include <asm/pgtable.h>
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070025#include <asm/fcntl.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020026#include <asm/e820.h>
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070027#include <asm/mtrr.h>
Ingo Molnarad2cde12008-09-30 13:20:45 +020028#include <asm/page.h>
29#include <asm/msr.h>
30#include <asm/pat.h>
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -070031#include <asm/io.h>
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070032
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -080033#include "pat_internal.h"
34
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020035#ifdef CONFIG_X86_PAT
Andreas Herrmann499f8f82008-06-10 16:06:21 +020036int __read_mostly pat_enabled = 1;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070037
Marcin Slusarz1ee4bd92009-04-10 22:47:17 +020038static inline void pat_disable(const char *reason)
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020039{
Andreas Herrmann499f8f82008-06-10 16:06:21 +020040 pat_enabled = 0;
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020041 printk(KERN_INFO "%s\n", reason);
42}
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070043
Andrew Mortonbe524fb2008-05-29 00:01:28 -070044static int __init nopat(char *str)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070045{
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020046 pat_disable("PAT support disabled.");
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070047 return 0;
48}
49early_param("nopat", nopat);
H. Peter Anvin75a04812009-01-22 16:17:05 -080050#else
51static inline void pat_disable(const char *reason)
52{
53 (void)reason;
54}
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020055#endif
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070056
Venki Pallipadi77b52b42008-05-05 19:09:10 -070057
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -080058int pat_debug_enable;
Ingo Molnarad2cde12008-09-30 13:20:45 +020059
Venki Pallipadi77b52b42008-05-05 19:09:10 -070060static int __init pat_debug_setup(char *str)
61{
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -080062 pat_debug_enable = 1;
Venki Pallipadi77b52b42008-05-05 19:09:10 -070063 return 0;
64}
65__setup("debugpat", pat_debug_setup);
66
Thomas Gleixner8d4a4302008-05-08 09:18:43 +020067static u64 __read_mostly boot_pat_state;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070068
69enum {
70 PAT_UC = 0, /* uncached */
71 PAT_WC = 1, /* Write combining */
72 PAT_WT = 4, /* Write Through */
73 PAT_WP = 5, /* Write Protected */
74 PAT_WB = 6, /* Write Back (default) */
75 PAT_UC_MINUS = 7, /* UC, but can be overriden by MTRR */
76};
77
Andreas Herrmanncd7a4e92008-06-10 16:05:39 +020078#define PAT(x, y) ((u64)PAT_ ## y << ((x)*8))
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070079
80void pat_init(void)
81{
82 u64 pat;
Roland Dreiere23a8b62009-09-23 15:35:35 -070083 bool boot_cpu = !boot_pat_state;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070084
Andreas Herrmann499f8f82008-06-10 16:06:21 +020085 if (!pat_enabled)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -070086 return;
87
H. Peter Anvin75a04812009-01-22 16:17:05 -080088 if (!cpu_has_pat) {
89 if (!boot_pat_state) {
90 pat_disable("PAT not supported by CPU.");
91 return;
92 } else {
93 /*
94 * If this happens we are on a secondary CPU, but
95 * switched to PAT on the boot CPU. We have no way to
96 * undo PAT.
97 */
98 printk(KERN_ERR "PAT enabled, "
99 "but not supported by secondary CPU\n");
100 BUG();
101 }
Thomas Gleixner8d4a4302008-05-08 09:18:43 +0200102 }
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700103
104 /* Set PWT to Write-Combining. All other bits stay the same */
105 /*
106 * PTE encoding used in Linux:
107 * PAT
108 * |PCD
109 * ||PWT
110 * |||
111 * 000 WB _PAGE_CACHE_WB
112 * 001 WC _PAGE_CACHE_WC
113 * 010 UC- _PAGE_CACHE_UC_MINUS
114 * 011 UC _PAGE_CACHE_UC
115 * PAT bit unused
116 */
Andreas Herrmanncd7a4e92008-06-10 16:05:39 +0200117 pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
118 PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700119
120 /* Boot CPU check */
Thomas Gleixner8d4a4302008-05-08 09:18:43 +0200121 if (!boot_pat_state)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700122 rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700123
124 wrmsrl(MSR_IA32_CR_PAT, pat);
Roland Dreiere23a8b62009-09-23 15:35:35 -0700125
126 if (boot_cpu)
127 printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
128 smp_processor_id(), boot_pat_state, pat);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700129}
130
131#undef PAT
132
Pallipadi, Venkatesh9e41a492010-02-10 15:26:07 -0800133static DEFINE_SPINLOCK(memtype_lock); /* protects memtype accesses */
Venkatesh Pallipadi335ef892009-07-10 09:57:36 -0700134
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700135/*
136 * Does intersection of PAT memory type and MTRR memory type and returns
137 * the resulting memory type as PAT understands it.
138 * (Type in pat and mtrr will not have same value)
139 * The intersection is based on "Effective Memory Type" tables in IA-32
140 * SDM vol 3a
141 */
Hugh Dickins6cf514f2008-06-16 18:42:43 +0100142static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700143{
Venki Pallipadic26421d2008-05-29 12:01:44 -0700144 /*
145 * Look for MTRR hint to get the effective type in case where PAT
146 * request is for WB.
147 */
Andreas Herrmanndd0c7c42008-06-18 15:38:57 +0200148 if (req_type == _PAGE_CACHE_WB) {
149 u8 mtrr_type;
150
151 mtrr_type = mtrr_type_lookup(start, end);
Suresh Siddhab6ff32d2009-04-09 14:26:51 -0700152 if (mtrr_type != MTRR_TYPE_WRBACK)
153 return _PAGE_CACHE_UC_MINUS;
154
155 return _PAGE_CACHE_WB;
Andreas Herrmanndd0c7c42008-06-18 15:38:57 +0200156 }
157
158 return req_type;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700159}
160
Yasuaki Ishimatsu3709c852010-07-22 14:57:35 +0900161static int pat_pagerange_is_ram(resource_size_t start, resource_size_t end)
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800162{
163 int ram_page = 0, not_rampage = 0;
164 unsigned long page_nr;
165
166 for (page_nr = (start >> PAGE_SHIFT); page_nr < (end >> PAGE_SHIFT);
167 ++page_nr) {
168 /*
169 * For legacy reasons, physical address range in the legacy ISA
170 * region is tracked as non-RAM. This will allow users of
171 * /dev/mem to map portions of legacy ISA region, even when
172 * some of those portions are listed(or not even listed) with
173 * different e820 types(RAM/reserved/..)
174 */
175 if (page_nr >= (ISA_END_ADDRESS >> PAGE_SHIFT) &&
176 page_is_ram(page_nr))
177 ram_page = 1;
178 else
179 not_rampage = 1;
180
181 if (ram_page == not_rampage)
182 return -1;
183 }
184
185 return ram_page;
186}
187
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700188/*
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700189 * For RAM pages, we use page flags to mark the pages with appropriate type.
190 * Here we do two pass:
191 * - Find the memtype of all the pages in the range, look for any conflicts
192 * - In case of no conflicts, set the new memtype for pages in the range
Suresh Siddha9542ada2008-09-24 08:53:33 -0700193 */
194static int reserve_ram_pages_type(u64 start, u64 end, unsigned long req_type,
Ingo Molnarad2cde12008-09-30 13:20:45 +0200195 unsigned long *new_type)
Suresh Siddha9542ada2008-09-24 08:53:33 -0700196{
197 struct page *page;
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700198 u64 pfn;
199
200 if (req_type == _PAGE_CACHE_UC) {
201 /* We do not support strong UC */
202 WARN_ON_ONCE(1);
203 req_type = _PAGE_CACHE_UC_MINUS;
204 }
205
206 for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
207 unsigned long type;
208
209 page = pfn_to_page(pfn);
210 type = get_page_memtype(page);
211 if (type != -1) {
212 printk(KERN_INFO "reserve_ram_pages_type failed "
213 "0x%Lx-0x%Lx, track 0x%lx, req 0x%lx\n",
214 start, end, type, req_type);
215 if (new_type)
216 *new_type = type;
217
218 return -EBUSY;
219 }
220 }
221
222 if (new_type)
223 *new_type = req_type;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700224
225 for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
226 page = pfn_to_page(pfn);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700227 set_page_memtype(page, req_type);
Suresh Siddha9542ada2008-09-24 08:53:33 -0700228 }
229 return 0;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700230}
231
232static int free_ram_pages_type(u64 start, u64 end)
233{
234 struct page *page;
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700235 u64 pfn;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700236
237 for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
238 page = pfn_to_page(pfn);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700239 set_page_memtype(page, -1);
Suresh Siddha9542ada2008-09-24 08:53:33 -0700240 }
241 return 0;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700242}
243
244/*
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700245 * req_type typically has one of the:
246 * - _PAGE_CACHE_WB
247 * - _PAGE_CACHE_WC
248 * - _PAGE_CACHE_UC_MINUS
249 * - _PAGE_CACHE_UC
250 *
Andreas Herrmannac979912008-06-20 22:01:49 +0200251 * If new_type is NULL, function will return an error if it cannot reserve the
252 * region with req_type. If new_type is non-NULL, function will return
253 * available type in new_type in case of no error. In case of any error
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700254 * it will return a negative return value.
255 */
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700256int reserve_memtype(u64 start, u64 end, unsigned long req_type,
Ingo Molnarad2cde12008-09-30 13:20:45 +0200257 unsigned long *new_type)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700258{
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -0800259 struct memtype *new;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700260 unsigned long actual_type;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700261 int is_range_ram;
Ingo Molnarad2cde12008-09-30 13:20:45 +0200262 int err = 0;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700263
Ingo Molnarad2cde12008-09-30 13:20:45 +0200264 BUG_ON(start >= end); /* end is exclusive */
Andreas Herrmann69e26be2008-06-20 22:03:06 +0200265
Andreas Herrmann499f8f82008-06-10 16:06:21 +0200266 if (!pat_enabled) {
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700267 /* This is identical to page table setting without PAT */
Andreas Herrmannac979912008-06-20 22:01:49 +0200268 if (new_type) {
Xiaotian Feng83ea05e2009-11-10 17:23:07 +0800269 if (req_type == _PAGE_CACHE_WC)
Venkatesh Pallipadi5fc51742009-07-10 09:57:32 -0700270 *new_type = _PAGE_CACHE_UC_MINUS;
Andreas Herrmannac979912008-06-20 22:01:49 +0200271 else
272 *new_type = req_type & _PAGE_CACHE_MASK;
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700273 }
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700274 return 0;
275 }
276
277 /* Low ISA region is always mapped WB in page table. No need to track */
H. Peter Anvin8a271382009-11-23 14:49:20 -0800278 if (x86_platform.is_untracked_pat_range(start, end)) {
Andreas Herrmannac979912008-06-20 22:01:49 +0200279 if (new_type)
280 *new_type = _PAGE_CACHE_WB;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700281 return 0;
282 }
283
Suresh Siddhab6ff32d2009-04-09 14:26:51 -0700284 /*
285 * Call mtrr_lookup to get the type hint. This is an
286 * optimization for /dev/mem mmap'ers into WB memory (BIOS
287 * tools and ACPI tools). Use WB request for WB memory and use
288 * UC_MINUS otherwise.
289 */
290 actual_type = pat_x_mtrr_type(start, end, req_type & _PAGE_CACHE_MASK);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700291
Suresh Siddha95971342009-01-13 10:21:30 -0800292 if (new_type)
293 *new_type = actual_type;
294
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800295 is_range_ram = pat_pagerange_is_ram(start, end);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700296 if (is_range_ram == 1) {
297
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700298 err = reserve_ram_pages_type(start, end, req_type, new_type);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700299
300 return err;
301 } else if (is_range_ram < 0) {
Suresh Siddha9542ada2008-09-24 08:53:33 -0700302 return -EINVAL;
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700303 }
Suresh Siddha9542ada2008-09-24 08:53:33 -0700304
Venkatesh Pallipadi6a4f3b52010-06-10 17:45:01 -0700305 new = kzalloc(sizeof(struct memtype), GFP_KERNEL);
Andreas Herrmannac979912008-06-20 22:01:49 +0200306 if (!new)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700307 return -ENOMEM;
308
Ingo Molnarad2cde12008-09-30 13:20:45 +0200309 new->start = start;
310 new->end = end;
311 new->type = actual_type;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700312
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700313 spin_lock(&memtype_lock);
314
Pallipadi, Venkatesh9e41a492010-02-10 15:26:07 -0800315 err = rbt_memtype_check_insert(new, new_type);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700316 if (err) {
Andreas Herrmann3e9c83b2008-06-20 22:04:02 +0200317 printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
318 "track %s, req %s\n",
319 start, end, cattr_name(new->type), cattr_name(req_type));
Andreas Herrmannac979912008-06-20 22:01:49 +0200320 kfree(new);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700321 spin_unlock(&memtype_lock);
Ingo Molnarad2cde12008-09-30 13:20:45 +0200322
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700323 return err;
324 }
325
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700326 spin_unlock(&memtype_lock);
Andreas Herrmann3e9c83b2008-06-20 22:04:02 +0200327
328 dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
329 start, end, cattr_name(new->type), cattr_name(req_type),
330 new_type ? cattr_name(*new_type) : "-");
331
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700332 return err;
333}
334
335int free_memtype(u64 start, u64 end)
336{
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700337 int err = -EINVAL;
Suresh Siddha9542ada2008-09-24 08:53:33 -0700338 int is_range_ram;
Xiaotian Feng20413f22010-05-26 09:51:10 +0800339 struct memtype *entry;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700340
Andreas Herrmann69e26be2008-06-20 22:03:06 +0200341 if (!pat_enabled)
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700342 return 0;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700343
344 /* Low ISA region is always mapped WB. No need to track */
H. Peter Anvin8a271382009-11-23 14:49:20 -0800345 if (x86_platform.is_untracked_pat_range(start, end))
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700346 return 0;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700347
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800348 is_range_ram = pat_pagerange_is_ram(start, end);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700349 if (is_range_ram == 1) {
350
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700351 err = free_ram_pages_type(start, end);
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700352
353 return err;
354 } else if (is_range_ram < 0) {
Suresh Siddha9542ada2008-09-24 08:53:33 -0700355 return -EINVAL;
Venkatesh Pallipadif5841742009-07-10 09:57:38 -0700356 }
Suresh Siddha9542ada2008-09-24 08:53:33 -0700357
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700358 spin_lock(&memtype_lock);
Xiaotian Feng20413f22010-05-26 09:51:10 +0800359 entry = rbt_memtype_erase(start, end);
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700360 spin_unlock(&memtype_lock);
361
Xiaotian Feng20413f22010-05-26 09:51:10 +0800362 if (!entry) {
Ingo Molnar28eb559b2008-04-03 10:14:33 +0200363 printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700364 current->comm, current->pid, start, end);
Xiaotian Feng20413f22010-05-26 09:51:10 +0800365 return -EINVAL;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700366 }
venkatesh.pallipadi@intel.com6997ab42008-03-18 17:00:25 -0700367
Xiaotian Feng20413f22010-05-26 09:51:10 +0800368 kfree(entry);
369
Venki Pallipadi77b52b42008-05-05 19:09:10 -0700370 dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
Ingo Molnarad2cde12008-09-30 13:20:45 +0200371
Xiaotian Feng20413f22010-05-26 09:51:10 +0800372 return 0;
venkatesh.pallipadi@intel.com2e5d9c82008-03-18 17:00:14 -0700373}
374
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700375
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700376/**
Venkatesh Pallipadi637b86e2009-07-10 09:57:39 -0700377 * lookup_memtype - Looksup the memory type for a physical address
378 * @paddr: physical address of which memory type needs to be looked up
379 *
380 * Only to be called when PAT is enabled
381 *
382 * Returns _PAGE_CACHE_WB, _PAGE_CACHE_WC, _PAGE_CACHE_UC_MINUS or
383 * _PAGE_CACHE_UC
384 */
385static unsigned long lookup_memtype(u64 paddr)
386{
387 int rettype = _PAGE_CACHE_WB;
388 struct memtype *entry;
389
H. Peter Anvin8a271382009-11-23 14:49:20 -0800390 if (x86_platform.is_untracked_pat_range(paddr, paddr + PAGE_SIZE))
Venkatesh Pallipadi637b86e2009-07-10 09:57:39 -0700391 return rettype;
392
393 if (pat_pagerange_is_ram(paddr, paddr + PAGE_SIZE)) {
394 struct page *page;
Venkatesh Pallipadi637b86e2009-07-10 09:57:39 -0700395 page = pfn_to_page(paddr >> PAGE_SHIFT);
396 rettype = get_page_memtype(page);
Venkatesh Pallipadi637b86e2009-07-10 09:57:39 -0700397 /*
398 * -1 from get_page_memtype() implies RAM page is in its
399 * default state and not reserved, and hence of type WB
400 */
401 if (rettype == -1)
402 rettype = _PAGE_CACHE_WB;
403
404 return rettype;
405 }
406
407 spin_lock(&memtype_lock);
408
Pallipadi, Venkatesh9e41a492010-02-10 15:26:07 -0800409 entry = rbt_memtype_lookup(paddr);
Venkatesh Pallipadi637b86e2009-07-10 09:57:39 -0700410 if (entry != NULL)
411 rettype = entry->type;
412 else
413 rettype = _PAGE_CACHE_UC_MINUS;
414
415 spin_unlock(&memtype_lock);
416 return rettype;
417}
418
419/**
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700420 * io_reserve_memtype - Request a memory type mapping for a region of memory
421 * @start: start (physical address) of the region
422 * @end: end (physical address) of the region
423 * @type: A pointer to memtype, with requested type. On success, requested
424 * or any other compatible type that was available for the region is returned
425 *
426 * On success, returns 0
427 * On failure, returns non-zero
428 */
429int io_reserve_memtype(resource_size_t start, resource_size_t end,
430 unsigned long *type)
431{
H. Peter Anvinb8551922009-08-26 17:17:51 -0700432 resource_size_t size = end - start;
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700433 unsigned long req_type = *type;
434 unsigned long new_type;
435 int ret;
436
H. Peter Anvinb8551922009-08-26 17:17:51 -0700437 WARN_ON_ONCE(iomem_map_sanity_check(start, size));
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700438
439 ret = reserve_memtype(start, end, req_type, &new_type);
440 if (ret)
441 goto out_err;
442
H. Peter Anvinb8551922009-08-26 17:17:51 -0700443 if (!is_new_memtype_allowed(start, size, req_type, new_type))
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700444 goto out_free;
445
H. Peter Anvinb8551922009-08-26 17:17:51 -0700446 if (kernel_map_sync_memtype(start, size, new_type) < 0)
Venkatesh Pallipadi9fd126b2009-07-10 09:57:34 -0700447 goto out_free;
448
449 *type = new_type;
450 return 0;
451
452out_free:
453 free_memtype(start, end);
454 ret = -EBUSY;
455out_err:
456 return ret;
457}
458
459/**
460 * io_free_memtype - Release a memory type mapping for a region of memory
461 * @start: start (physical address) of the region
462 * @end: end (physical address) of the region
463 */
464void io_free_memtype(resource_size_t start, resource_size_t end)
465{
466 free_memtype(start, end);
467}
468
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700469pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
470 unsigned long size, pgprot_t vma_prot)
471{
472 return vma_prot;
473}
474
Ingo Molnard0926332008-07-18 00:26:59 +0200475#ifdef CONFIG_STRICT_DEVMEM
476/* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
Venki Pallipadi0124cec2008-04-26 11:32:12 -0700477static inline int range_is_allowed(unsigned long pfn, unsigned long size)
478{
479 return 1;
480}
481#else
Ravikiran G Thirumalai9e41bff2008-10-30 13:59:21 -0700482/* This check is needed to avoid cache aliasing when PAT is enabled */
Venki Pallipadi0124cec2008-04-26 11:32:12 -0700483static inline int range_is_allowed(unsigned long pfn, unsigned long size)
484{
485 u64 from = ((u64)pfn) << PAGE_SHIFT;
486 u64 to = from + size;
487 u64 cursor = from;
488
Ravikiran G Thirumalai9e41bff2008-10-30 13:59:21 -0700489 if (!pat_enabled)
490 return 1;
491
Venki Pallipadi0124cec2008-04-26 11:32:12 -0700492 while (cursor < to) {
493 if (!devmem_is_allowed(pfn)) {
494 printk(KERN_INFO
495 "Program %s tried to access /dev/mem between %Lx->%Lx.\n",
496 current->comm, from, to);
497 return 0;
498 }
499 cursor += PAGE_SIZE;
500 pfn++;
501 }
502 return 1;
503}
Ingo Molnard0926332008-07-18 00:26:59 +0200504#endif /* CONFIG_STRICT_DEVMEM */
Venki Pallipadi0124cec2008-04-26 11:32:12 -0700505
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700506int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
507 unsigned long size, pgprot_t *vma_prot)
508{
Suresh Siddha0c3c8a12009-04-09 14:26:52 -0700509 unsigned long flags = _PAGE_CACHE_WB;
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700510
Venki Pallipadi0124cec2008-04-26 11:32:12 -0700511 if (!range_is_allowed(pfn, size))
512 return 0;
513
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +0100514 if (file->f_flags & O_DSYNC)
venkatesh.pallipadi@intel.com28df82e2008-08-20 16:45:52 -0700515 flags = _PAGE_CACHE_UC_MINUS;
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700516
517#ifdef CONFIG_X86_32
518 /*
519 * On the PPro and successors, the MTRRs are used to set
520 * memory types for physical addresses outside main memory,
521 * so blindly setting UC or PWT on those pages is wrong.
522 * For Pentiums and earlier, the surround logic should disable
523 * caching for the high addresses through the KEN pin, but
524 * we maintain the tradition of paranoia in this code.
525 */
Andreas Herrmann499f8f82008-06-10 16:06:21 +0200526 if (!pat_enabled &&
Andreas Herrmanncd7a4e92008-06-10 16:05:39 +0200527 !(boot_cpu_has(X86_FEATURE_MTRR) ||
528 boot_cpu_has(X86_FEATURE_K6_MTRR) ||
529 boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
530 boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
531 (pfn << PAGE_SHIFT) >= __pa(high_memory)) {
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700532 flags = _PAGE_CACHE_UC;
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700533 }
534#endif
535
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700536 *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
537 flags);
venkatesh.pallipadi@intel.comf0970c12008-03-18 17:00:20 -0700538 return 1;
539}
venkatesh.pallipadi@intel.come7f260a2008-03-18 17:00:21 -0700540
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800541/*
Venkatesh Pallipadi7880f742009-02-24 17:35:13 -0800542 * Change the memory type for the physial address range in kernel identity
543 * mapping space if that range is a part of identity map.
544 */
545int kernel_map_sync_memtype(u64 base, unsigned long size, unsigned long flags)
546{
547 unsigned long id_sz;
548
Venkatesh Pallipadi5fc51742009-07-10 09:57:32 -0700549 if (base >= __pa(high_memory))
Venkatesh Pallipadi7880f742009-02-24 17:35:13 -0800550 return 0;
551
552 id_sz = (__pa(high_memory) < base + size) ?
553 __pa(high_memory) - base :
554 size;
555
556 if (ioremap_change_attr((unsigned long)__va(base), id_sz, flags) < 0) {
557 printk(KERN_INFO
558 "%s:%d ioremap_change_attr failed %s "
559 "for %Lx-%Lx\n",
560 current->comm, current->pid,
561 cattr_name(flags),
562 base, (unsigned long long)(base + size));
563 return -EINVAL;
564 }
565 return 0;
566}
567
568/*
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800569 * Internal interface to reserve a range of physical memory with prot.
570 * Reserved non RAM regions only and after successful reserve_memtype,
571 * this func also keeps identity mapping (if any) in sync with this new prot.
572 */
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800573static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t *vma_prot,
574 int strict_prot)
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800575{
576 int is_ram = 0;
Venkatesh Pallipadi7880f742009-02-24 17:35:13 -0800577 int ret;
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800578 unsigned long want_flags = (pgprot_val(*vma_prot) & _PAGE_CACHE_MASK);
Suresh Siddha0c3c8a12009-04-09 14:26:52 -0700579 unsigned long flags = want_flags;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800580
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800581 is_ram = pat_pagerange_is_ram(paddr, paddr + size);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800582
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800583 /*
Venkatesh Pallipadid886c732009-07-10 09:57:41 -0700584 * reserve_pfn_range() for RAM pages. We do not refcount to keep
585 * track of number of mappings of RAM pages. We can assert that
586 * the type requested matches the type of first page in the range.
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800587 */
Venkatesh Pallipadid886c732009-07-10 09:57:41 -0700588 if (is_ram) {
589 if (!pat_enabled)
590 return 0;
591
592 flags = lookup_memtype(paddr);
593 if (want_flags != flags) {
594 printk(KERN_WARNING
595 "%s:%d map pfn RAM range req %s for %Lx-%Lx, got %s\n",
596 current->comm, current->pid,
597 cattr_name(want_flags),
598 (unsigned long long)paddr,
599 (unsigned long long)(paddr + size),
600 cattr_name(flags));
601 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
602 (~_PAGE_CACHE_MASK)) |
603 flags);
604 }
Pallipadi, Venkatesh4bb9c5c2009-03-12 17:45:27 -0700605 return 0;
Venkatesh Pallipadid886c732009-07-10 09:57:41 -0700606 }
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800607
608 ret = reserve_memtype(paddr, paddr + size, want_flags, &flags);
609 if (ret)
610 return ret;
611
612 if (flags != want_flags) {
Suresh Siddha1adcaaf2009-08-17 13:23:50 -0700613 if (strict_prot ||
614 !is_new_memtype_allowed(paddr, size, want_flags, flags)) {
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800615 free_memtype(paddr, paddr + size);
616 printk(KERN_ERR "%s:%d map pfn expected mapping type %s"
617 " for %Lx-%Lx, got %s\n",
618 current->comm, current->pid,
619 cattr_name(want_flags),
620 (unsigned long long)paddr,
621 (unsigned long long)(paddr + size),
622 cattr_name(flags));
623 return -EINVAL;
624 }
625 /*
626 * We allow returning different type than the one requested in
627 * non strict case.
628 */
629 *vma_prot = __pgprot((pgprot_val(*vma_prot) &
630 (~_PAGE_CACHE_MASK)) |
631 flags);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800632 }
633
Venkatesh Pallipadi7880f742009-02-24 17:35:13 -0800634 if (kernel_map_sync_memtype(paddr, size, flags) < 0) {
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800635 free_memtype(paddr, paddr + size);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800636 return -EINVAL;
637 }
638 return 0;
639}
640
641/*
642 * Internal interface to free a range of physical memory.
643 * Frees non RAM regions only.
644 */
645static void free_pfn_range(u64 paddr, unsigned long size)
646{
647 int is_ram;
648
Suresh Siddhabe03d9e2009-02-11 11:20:23 -0800649 is_ram = pat_pagerange_is_ram(paddr, paddr + size);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800650 if (is_ram == 0)
651 free_memtype(paddr, paddr + size);
652}
653
654/*
655 * track_pfn_vma_copy is called when vma that is covering the pfnmap gets
656 * copied through copy_page_range().
657 *
658 * If the vma has a linear pfn mapping for the entire range, we get the prot
659 * from pte and reserve the entire vma range with single reserve_pfn_range call.
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800660 */
661int track_pfn_vma_copy(struct vm_area_struct *vma)
662{
H. Peter Anvinc1c15b62008-12-23 10:10:40 -0800663 resource_size_t paddr;
venkatesh.pallipadi@intel.com982d7892008-12-19 13:47:28 -0800664 unsigned long prot;
Pallipadi, Venkatesh4b065042009-04-08 15:37:16 -0700665 unsigned long vma_size = vma->vm_end - vma->vm_start;
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800666 pgprot_t pgprot;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800667
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800668 if (is_linear_pfn_mapping(vma)) {
669 /*
venkatesh.pallipadi@intel.com982d7892008-12-19 13:47:28 -0800670 * reserve the whole chunk covered by vma. We need the
671 * starting address and protection from pte.
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800672 */
Pallipadi, Venkatesh4b065042009-04-08 15:37:16 -0700673 if (follow_phys(vma, vma->vm_start, 0, &prot, &paddr)) {
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800674 WARN_ON_ONCE(1);
venkatesh.pallipadi@intel.com982d7892008-12-19 13:47:28 -0800675 return -EINVAL;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800676 }
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800677 pgprot = __pgprot(prot);
678 return reserve_pfn_range(paddr, vma_size, &pgprot, 1);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800679 }
680
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800681 return 0;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800682}
683
684/*
685 * track_pfn_vma_new is called when a _new_ pfn mapping is being established
686 * for physical range indicated by pfn and size.
687 *
688 * prot is passed in as a parameter for the new mapping. If the vma has a
689 * linear pfn mapping for the entire range reserve the entire vma range with
690 * single reserve_pfn_range call.
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800691 */
venkatesh.pallipadi@intel.come4b866e2009-01-09 16:13:11 -0800692int track_pfn_vma_new(struct vm_area_struct *vma, pgprot_t *prot,
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800693 unsigned long pfn, unsigned long size)
694{
Venkatesh Pallipadi10876372009-07-10 09:57:40 -0700695 unsigned long flags;
H. Peter Anvinc1c15b62008-12-23 10:10:40 -0800696 resource_size_t paddr;
Pallipadi, Venkatesh4b065042009-04-08 15:37:16 -0700697 unsigned long vma_size = vma->vm_end - vma->vm_start;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800698
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800699 if (is_linear_pfn_mapping(vma)) {
700 /* reserve the whole chunk starting from vm_pgoff */
H. Peter Anvinc1c15b62008-12-23 10:10:40 -0800701 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
venkatesh.pallipadi@intel.comcdecff62009-01-09 16:13:12 -0800702 return reserve_pfn_range(paddr, vma_size, prot, 0);
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800703 }
704
Venkatesh Pallipadi10876372009-07-10 09:57:40 -0700705 if (!pat_enabled)
706 return 0;
707
708 /* for vm_insert_pfn and friends, we set prot based on lookup */
709 flags = lookup_memtype(pfn << PAGE_SHIFT);
710 *prot = __pgprot((pgprot_val(vma->vm_page_prot) & (~_PAGE_CACHE_MASK)) |
711 flags);
712
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800713 return 0;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800714}
715
716/*
717 * untrack_pfn_vma is called while unmapping a pfnmap for a region.
718 * untrack can be called for a specific region indicated by pfn and size or
719 * can be for the entire vma (in which case size can be zero).
720 */
721void untrack_pfn_vma(struct vm_area_struct *vma, unsigned long pfn,
722 unsigned long size)
723{
H. Peter Anvinc1c15b62008-12-23 10:10:40 -0800724 resource_size_t paddr;
Pallipadi, Venkatesh4b065042009-04-08 15:37:16 -0700725 unsigned long vma_size = vma->vm_end - vma->vm_start;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800726
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800727 if (is_linear_pfn_mapping(vma)) {
728 /* free the whole chunk starting from vm_pgoff */
H. Peter Anvinc1c15b62008-12-23 10:10:40 -0800729 paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800730 free_pfn_range(paddr, vma_size);
731 return;
732 }
venkatesh.pallipadi@intel.com58993292008-12-18 11:41:30 -0800733}
734
venkatesh.pallipadi@intel.com2520bd32008-12-18 11:41:32 -0800735pgprot_t pgprot_writecombine(pgprot_t prot)
736{
737 if (pat_enabled)
738 return __pgprot(pgprot_val(prot) | _PAGE_CACHE_WC);
739 else
740 return pgprot_noncached(prot);
741}
Ingo Molnar92b9af92009-02-28 14:09:27 +0100742EXPORT_SYMBOL_GPL(pgprot_writecombine);
venkatesh.pallipadi@intel.com2520bd32008-12-18 11:41:32 -0800743
Andreas Herrmann012f09e2008-08-06 16:23:08 +0200744#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700745
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700746static struct memtype *memtype_get_idx(loff_t pos)
747{
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -0800748 struct memtype *print_entry;
749 int ret;
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700750
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -0800751 print_entry = kzalloc(sizeof(struct memtype), GFP_KERNEL);
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700752 if (!print_entry)
753 return NULL;
754
755 spin_lock(&memtype_lock);
Pallipadi, Venkatesh9e41a492010-02-10 15:26:07 -0800756 ret = rbt_memtype_copy_nth_element(print_entry, pos);
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700757 spin_unlock(&memtype_lock);
Ingo Molnarad2cde12008-09-30 13:20:45 +0200758
venkatesh.pallipadi@intel.combe5a0c12010-02-10 11:57:06 -0800759 if (!ret) {
760 return print_entry;
761 } else {
762 kfree(print_entry);
763 return NULL;
764 }
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700765}
766
767static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
768{
769 if (*pos == 0) {
770 ++*pos;
771 seq_printf(seq, "PAT memtype list:\n");
772 }
773
774 return memtype_get_idx(*pos);
775}
776
777static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
778{
779 ++*pos;
780 return memtype_get_idx(*pos);
781}
782
783static void memtype_seq_stop(struct seq_file *seq, void *v)
784{
785}
786
787static int memtype_seq_show(struct seq_file *seq, void *v)
788{
789 struct memtype *print_entry = (struct memtype *)v;
790
791 seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
792 print_entry->start, print_entry->end);
793 kfree(print_entry);
Ingo Molnarad2cde12008-09-30 13:20:45 +0200794
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700795 return 0;
796}
797
Tobias Klauserd535e432009-09-04 15:53:09 +0200798static const struct seq_operations memtype_seq_ops = {
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700799 .start = memtype_seq_start,
800 .next = memtype_seq_next,
801 .stop = memtype_seq_stop,
802 .show = memtype_seq_show,
803};
804
805static int memtype_seq_open(struct inode *inode, struct file *file)
806{
807 return seq_open(file, &memtype_seq_ops);
808}
809
810static const struct file_operations memtype_fops = {
811 .open = memtype_seq_open,
812 .read = seq_read,
813 .llseek = seq_lseek,
814 .release = seq_release,
815};
816
817static int __init pat_memtype_list_init(void)
818{
Xiaotian Fengdd4377b2009-11-26 19:53:48 +0800819 if (pat_enabled) {
820 debugfs_create_file("pat_memtype_list", S_IRUSR,
821 arch_debugfs_dir, NULL, &memtype_fops);
822 }
venkatesh.pallipadi@intel.comfec09622008-07-18 16:08:14 -0700823 return 0;
824}
825
826late_initcall(pat_memtype_list_init);
827
Andreas Herrmann012f09e2008-08-06 16:23:08 +0200828#endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */