2 * Handle caching attributes in page tables (PAT)
4 * Authors: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
5 * Suresh B Siddha <suresh.b.siddha@intel.com>
7 * Loosely based on earlier PAT patchset from Eric Biederman and Andi Kleen.
10 #include <linux/seq_file.h>
11 #include <linux/bootmem.h>
12 #include <linux/debugfs.h>
13 #include <linux/kernel.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
18 #include <linux/rbtree.h>
20 #include <asm/cacheflush.h>
21 #include <asm/processor.h>
22 #include <asm/tlbflush.h>
23 #include <asm/x86_init.h>
24 #include <asm/pgtable.h>
25 #include <asm/fcntl.h>
33 #include "pat_internal.h"
34 #include "mm_internal.h"
37 int __read_mostly pat_enabled
= 1;
39 static inline void pat_disable(const char *reason
)
42 printk(KERN_INFO
"%s\n", reason
);
45 static int __init
nopat(char *str
)
47 pat_disable("PAT support disabled.");
50 early_param("nopat", nopat
);
52 static inline void pat_disable(const char *reason
)
61 static int __init
pat_debug_setup(char *str
)
66 __setup("debugpat", pat_debug_setup
);
68 static u64 __read_mostly boot_pat_state
;
71 PAT_UC
= 0, /* uncached */
72 PAT_WC
= 1, /* Write combining */
73 PAT_WT
= 4, /* Write Through */
74 PAT_WP
= 5, /* Write Protected */
75 PAT_WB
= 6, /* Write Back (default) */
76 PAT_UC_MINUS
= 7, /* UC, but can be overriden by MTRR */
79 #define CM(c) (_PAGE_CACHE_MODE_ ## c)
81 static enum page_cache_mode
pat_get_cache_mode(unsigned pat_val
, char *msg
)
83 enum page_cache_mode cache
;
87 case PAT_UC
: cache
= CM(UC
); cache_mode
= "UC "; break;
88 case PAT_WC
: cache
= CM(WC
); cache_mode
= "WC "; break;
89 case PAT_WT
: cache
= CM(WT
); cache_mode
= "WT "; break;
90 case PAT_WP
: cache
= CM(WP
); cache_mode
= "WP "; break;
91 case PAT_WB
: cache
= CM(WB
); cache_mode
= "WB "; break;
92 case PAT_UC_MINUS
: cache
= CM(UC_MINUS
); cache_mode
= "UC- "; break;
93 default: cache
= CM(WB
); cache_mode
= "WB "; break;
96 memcpy(msg
, cache_mode
, 4);
104 * Update the cache mode to pgprot translation tables according to PAT
106 * Using lower indices is preferred, so we start with highest index.
108 void pat_init_cache_modes(void)
111 enum page_cache_mode cache
;
115 rdmsrl(MSR_IA32_CR_PAT
, pat
);
117 for (i
= 7; i
>= 0; i
--) {
118 cache
= pat_get_cache_mode((pat
>> (i
* 8)) & 7,
120 update_cache_mode_entry(i
, cache
);
122 pr_info("PAT configuration [0-7]: %s\n", pat_msg
);
125 #define PAT(x, y) ((u64)PAT_ ## y << ((x)*8))
130 bool boot_cpu
= !boot_pat_state
;
136 if (!boot_pat_state
) {
137 pat_disable("PAT not supported by CPU.");
141 * If this happens we are on a secondary CPU, but
142 * switched to PAT on the boot CPU. We have no way to
145 printk(KERN_ERR
"PAT enabled, "
146 "but not supported by secondary CPU\n");
151 /* Set PWT to Write-Combining. All other bits stay the same */
153 * PTE encoding used in Linux:
158 * 000 WB _PAGE_CACHE_WB
159 * 001 WC _PAGE_CACHE_WC
160 * 010 UC- _PAGE_CACHE_UC_MINUS
161 * 011 UC _PAGE_CACHE_UC
164 pat
= PAT(0, WB
) | PAT(1, WC
) | PAT(2, UC_MINUS
) | PAT(3, UC
) |
165 PAT(4, WB
) | PAT(5, WC
) | PAT(6, UC_MINUS
) | PAT(7, UC
);
169 rdmsrl(MSR_IA32_CR_PAT
, boot_pat_state
);
171 wrmsrl(MSR_IA32_CR_PAT
, pat
);
174 pat_init_cache_modes();
179 static DEFINE_SPINLOCK(memtype_lock
); /* protects memtype accesses */
182 * Does intersection of PAT memory type and MTRR memory type and returns
183 * the resulting memory type as PAT understands it.
184 * (Type in pat and mtrr will not have same value)
185 * The intersection is based on "Effective Memory Type" tables in IA-32
188 static unsigned long pat_x_mtrr_type(u64 start
, u64 end
,
189 enum page_cache_mode req_type
)
192 * Look for MTRR hint to get the effective type in case where PAT
195 if (req_type
== _PAGE_CACHE_MODE_WB
) {
198 mtrr_type
= mtrr_type_lookup(start
, end
);
199 if (mtrr_type
!= MTRR_TYPE_WRBACK
)
200 return _PAGE_CACHE_MODE_UC_MINUS
;
202 return _PAGE_CACHE_MODE_WB
;
208 struct pagerange_state
{
209 unsigned long cur_pfn
;
215 pagerange_is_ram_callback(unsigned long initial_pfn
, unsigned long total_nr_pages
, void *arg
)
217 struct pagerange_state
*state
= arg
;
219 state
->not_ram
|= initial_pfn
> state
->cur_pfn
;
220 state
->ram
|= total_nr_pages
> 0;
221 state
->cur_pfn
= initial_pfn
+ total_nr_pages
;
223 return state
->ram
&& state
->not_ram
;
226 static int pat_pagerange_is_ram(resource_size_t start
, resource_size_t end
)
229 unsigned long start_pfn
= start
>> PAGE_SHIFT
;
230 unsigned long end_pfn
= (end
+ PAGE_SIZE
- 1) >> PAGE_SHIFT
;
231 struct pagerange_state state
= {start_pfn
, 0, 0};
234 * For legacy reasons, physical address range in the legacy ISA
235 * region is tracked as non-RAM. This will allow users of
236 * /dev/mem to map portions of legacy ISA region, even when
237 * some of those portions are listed(or not even listed) with
238 * different e820 types(RAM/reserved/..)
240 if (start_pfn
< ISA_END_ADDRESS
>> PAGE_SHIFT
)
241 start_pfn
= ISA_END_ADDRESS
>> PAGE_SHIFT
;
243 if (start_pfn
< end_pfn
) {
244 ret
= walk_system_ram_range(start_pfn
, end_pfn
- start_pfn
,
245 &state
, pagerange_is_ram_callback
);
248 return (ret
> 0) ? -1 : (state
.ram
? 1 : 0);
252 * For RAM pages, we use page flags to mark the pages with appropriate type.
253 * Here we do two pass:
254 * - Find the memtype of all the pages in the range, look for any conflicts
255 * - In case of no conflicts, set the new memtype for pages in the range
257 static int reserve_ram_pages_type(u64 start
, u64 end
,
258 enum page_cache_mode req_type
,
259 enum page_cache_mode
*new_type
)
264 if (req_type
== _PAGE_CACHE_MODE_UC
) {
265 /* We do not support strong UC */
267 req_type
= _PAGE_CACHE_MODE_UC_MINUS
;
270 for (pfn
= (start
>> PAGE_SHIFT
); pfn
< (end
>> PAGE_SHIFT
); ++pfn
) {
271 enum page_cache_mode type
;
273 page
= pfn_to_page(pfn
);
274 type
= get_page_memtype(page
);
276 pr_info("reserve_ram_pages_type failed [mem %#010Lx-%#010Lx], track 0x%x, req 0x%x\n",
277 start
, end
- 1, type
, req_type
);
286 *new_type
= req_type
;
288 for (pfn
= (start
>> PAGE_SHIFT
); pfn
< (end
>> PAGE_SHIFT
); ++pfn
) {
289 page
= pfn_to_page(pfn
);
290 set_page_memtype(page
, req_type
);
295 static int free_ram_pages_type(u64 start
, u64 end
)
300 for (pfn
= (start
>> PAGE_SHIFT
); pfn
< (end
>> PAGE_SHIFT
); ++pfn
) {
301 page
= pfn_to_page(pfn
);
302 set_page_memtype(page
, -1);
308 * req_type typically has one of the:
309 * - _PAGE_CACHE_MODE_WB
310 * - _PAGE_CACHE_MODE_WC
311 * - _PAGE_CACHE_MODE_UC_MINUS
312 * - _PAGE_CACHE_MODE_UC
314 * If new_type is NULL, function will return an error if it cannot reserve the
315 * region with req_type. If new_type is non-NULL, function will return
316 * available type in new_type in case of no error. In case of any error
317 * it will return a negative return value.
319 int reserve_memtype(u64 start
, u64 end
, enum page_cache_mode req_type
,
320 enum page_cache_mode
*new_type
)
323 enum page_cache_mode actual_type
;
327 BUG_ON(start
>= end
); /* end is exclusive */
330 /* This is identical to page table setting without PAT */
332 if (req_type
== _PAGE_CACHE_MODE_WC
)
333 *new_type
= _PAGE_CACHE_MODE_UC_MINUS
;
335 *new_type
= req_type
;
340 /* Low ISA region is always mapped WB in page table. No need to track */
341 if (x86_platform
.is_untracked_pat_range(start
, end
)) {
343 *new_type
= _PAGE_CACHE_MODE_WB
;
348 * Call mtrr_lookup to get the type hint. This is an
349 * optimization for /dev/mem mmap'ers into WB memory (BIOS
350 * tools and ACPI tools). Use WB request for WB memory and use
351 * UC_MINUS otherwise.
353 actual_type
= pat_x_mtrr_type(start
, end
, req_type
);
356 *new_type
= actual_type
;
358 is_range_ram
= pat_pagerange_is_ram(start
, end
);
359 if (is_range_ram
== 1) {
361 err
= reserve_ram_pages_type(start
, end
, req_type
, new_type
);
364 } else if (is_range_ram
< 0) {
368 new = kzalloc(sizeof(struct memtype
), GFP_KERNEL
);
374 new->type
= actual_type
;
376 spin_lock(&memtype_lock
);
378 err
= rbt_memtype_check_insert(new, new_type
);
380 printk(KERN_INFO
"reserve_memtype failed [mem %#010Lx-%#010Lx], track %s, req %s\n",
382 cattr_name(new->type
), cattr_name(req_type
));
384 spin_unlock(&memtype_lock
);
389 spin_unlock(&memtype_lock
);
391 dprintk("reserve_memtype added [mem %#010Lx-%#010Lx], track %s, req %s, ret %s\n",
392 start
, end
- 1, cattr_name(new->type
), cattr_name(req_type
),
393 new_type
? cattr_name(*new_type
) : "-");
398 int free_memtype(u64 start
, u64 end
)
402 struct memtype
*entry
;
407 /* Low ISA region is always mapped WB. No need to track */
408 if (x86_platform
.is_untracked_pat_range(start
, end
))
411 is_range_ram
= pat_pagerange_is_ram(start
, end
);
412 if (is_range_ram
== 1) {
414 err
= free_ram_pages_type(start
, end
);
417 } else if (is_range_ram
< 0) {
421 spin_lock(&memtype_lock
);
422 entry
= rbt_memtype_erase(start
, end
);
423 spin_unlock(&memtype_lock
);
426 printk(KERN_INFO
"%s:%d freeing invalid memtype [mem %#010Lx-%#010Lx]\n",
427 current
->comm
, current
->pid
, start
, end
- 1);
433 dprintk("free_memtype request [mem %#010Lx-%#010Lx]\n", start
, end
- 1);
440 * lookup_memtype - Looksup the memory type for a physical address
441 * @paddr: physical address of which memory type needs to be looked up
443 * Only to be called when PAT is enabled
445 * Returns _PAGE_CACHE_MODE_WB, _PAGE_CACHE_MODE_WC, _PAGE_CACHE_MODE_UC_MINUS
446 * or _PAGE_CACHE_MODE_UC
448 static enum page_cache_mode
lookup_memtype(u64 paddr
)
450 enum page_cache_mode rettype
= _PAGE_CACHE_MODE_WB
;
451 struct memtype
*entry
;
453 if (x86_platform
.is_untracked_pat_range(paddr
, paddr
+ PAGE_SIZE
))
456 if (pat_pagerange_is_ram(paddr
, paddr
+ PAGE_SIZE
)) {
458 page
= pfn_to_page(paddr
>> PAGE_SHIFT
);
459 rettype
= get_page_memtype(page
);
461 * -1 from get_page_memtype() implies RAM page is in its
462 * default state and not reserved, and hence of type WB
465 rettype
= _PAGE_CACHE_MODE_WB
;
470 spin_lock(&memtype_lock
);
472 entry
= rbt_memtype_lookup(paddr
);
474 rettype
= entry
->type
;
476 rettype
= _PAGE_CACHE_MODE_UC_MINUS
;
478 spin_unlock(&memtype_lock
);
483 * io_reserve_memtype - Request a memory type mapping for a region of memory
484 * @start: start (physical address) of the region
485 * @end: end (physical address) of the region
486 * @type: A pointer to memtype, with requested type. On success, requested
487 * or any other compatible type that was available for the region is returned
489 * On success, returns 0
490 * On failure, returns non-zero
492 int io_reserve_memtype(resource_size_t start
, resource_size_t end
,
493 enum page_cache_mode
*type
)
495 resource_size_t size
= end
- start
;
496 enum page_cache_mode req_type
= *type
;
497 enum page_cache_mode new_type
;
500 WARN_ON_ONCE(iomem_map_sanity_check(start
, size
));
502 ret
= reserve_memtype(start
, end
, req_type
, &new_type
);
506 if (!is_new_memtype_allowed(start
, size
, req_type
, new_type
))
509 if (kernel_map_sync_memtype(start
, size
, new_type
) < 0)
516 free_memtype(start
, end
);
523 * io_free_memtype - Release a memory type mapping for a region of memory
524 * @start: start (physical address) of the region
525 * @end: end (physical address) of the region
527 void io_free_memtype(resource_size_t start
, resource_size_t end
)
529 free_memtype(start
, end
);
532 pgprot_t
phys_mem_access_prot(struct file
*file
, unsigned long pfn
,
533 unsigned long size
, pgprot_t vma_prot
)
538 #ifdef CONFIG_STRICT_DEVMEM
539 /* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
540 static inline int range_is_allowed(unsigned long pfn
, unsigned long size
)
545 /* This check is needed to avoid cache aliasing when PAT is enabled */
546 static inline int range_is_allowed(unsigned long pfn
, unsigned long size
)
548 u64 from
= ((u64
)pfn
) << PAGE_SHIFT
;
549 u64 to
= from
+ size
;
555 while (cursor
< to
) {
556 if (!devmem_is_allowed(pfn
)) {
557 printk(KERN_INFO
"Program %s tried to access /dev/mem between [mem %#010Lx-%#010Lx]\n",
558 current
->comm
, from
, to
- 1);
566 #endif /* CONFIG_STRICT_DEVMEM */
568 int phys_mem_access_prot_allowed(struct file
*file
, unsigned long pfn
,
569 unsigned long size
, pgprot_t
*vma_prot
)
571 enum page_cache_mode pcm
= _PAGE_CACHE_MODE_WB
;
573 if (!range_is_allowed(pfn
, size
))
576 if (file
->f_flags
& O_DSYNC
)
577 pcm
= _PAGE_CACHE_MODE_UC_MINUS
;
581 * On the PPro and successors, the MTRRs are used to set
582 * memory types for physical addresses outside main memory,
583 * so blindly setting UC or PWT on those pages is wrong.
584 * For Pentiums and earlier, the surround logic should disable
585 * caching for the high addresses through the KEN pin, but
586 * we maintain the tradition of paranoia in this code.
589 !(boot_cpu_has(X86_FEATURE_MTRR
) ||
590 boot_cpu_has(X86_FEATURE_K6_MTRR
) ||
591 boot_cpu_has(X86_FEATURE_CYRIX_ARR
) ||
592 boot_cpu_has(X86_FEATURE_CENTAUR_MCR
)) &&
593 (pfn
<< PAGE_SHIFT
) >= __pa(high_memory
)) {
594 pcm
= _PAGE_CACHE_MODE_UC
;
598 *vma_prot
= __pgprot((pgprot_val(*vma_prot
) & ~_PAGE_CACHE_MASK
) |
599 cachemode2protval(pcm
));
604 * Change the memory type for the physial address range in kernel identity
605 * mapping space if that range is a part of identity map.
607 int kernel_map_sync_memtype(u64 base
, unsigned long size
,
608 enum page_cache_mode pcm
)
612 if (base
> __pa(high_memory
-1))
616 * some areas in the middle of the kernel identity range
617 * are not mapped, like the PCI space.
619 if (!page_is_ram(base
>> PAGE_SHIFT
))
622 id_sz
= (__pa(high_memory
-1) <= base
+ size
) ?
623 __pa(high_memory
) - base
:
626 if (ioremap_change_attr((unsigned long)__va(base
), id_sz
, pcm
) < 0) {
627 printk(KERN_INFO
"%s:%d ioremap_change_attr failed %s "
628 "for [mem %#010Lx-%#010Lx]\n",
629 current
->comm
, current
->pid
,
631 base
, (unsigned long long)(base
+ size
-1));
638 * Internal interface to reserve a range of physical memory with prot.
639 * Reserved non RAM regions only and after successful reserve_memtype,
640 * this func also keeps identity mapping (if any) in sync with this new prot.
642 static int reserve_pfn_range(u64 paddr
, unsigned long size
, pgprot_t
*vma_prot
,
647 enum page_cache_mode want_pcm
= pgprot2cachemode(*vma_prot
);
648 enum page_cache_mode pcm
= want_pcm
;
650 is_ram
= pat_pagerange_is_ram(paddr
, paddr
+ size
);
653 * reserve_pfn_range() for RAM pages. We do not refcount to keep
654 * track of number of mappings of RAM pages. We can assert that
655 * the type requested matches the type of first page in the range.
661 pcm
= lookup_memtype(paddr
);
662 if (want_pcm
!= pcm
) {
663 printk(KERN_WARNING
"%s:%d map pfn RAM range req %s for [mem %#010Lx-%#010Lx], got %s\n",
664 current
->comm
, current
->pid
,
665 cattr_name(want_pcm
),
666 (unsigned long long)paddr
,
667 (unsigned long long)(paddr
+ size
- 1),
669 *vma_prot
= __pgprot((pgprot_val(*vma_prot
) &
670 (~_PAGE_CACHE_MASK
)) |
671 cachemode2protval(pcm
));
676 ret
= reserve_memtype(paddr
, paddr
+ size
, want_pcm
, &pcm
);
680 if (pcm
!= want_pcm
) {
682 !is_new_memtype_allowed(paddr
, size
, want_pcm
, pcm
)) {
683 free_memtype(paddr
, paddr
+ size
);
684 printk(KERN_ERR
"%s:%d map pfn expected mapping type %s"
685 " for [mem %#010Lx-%#010Lx], got %s\n",
686 current
->comm
, current
->pid
,
687 cattr_name(want_pcm
),
688 (unsigned long long)paddr
,
689 (unsigned long long)(paddr
+ size
- 1),
694 * We allow returning different type than the one requested in
697 *vma_prot
= __pgprot((pgprot_val(*vma_prot
) &
698 (~_PAGE_CACHE_MASK
)) |
699 cachemode2protval(pcm
));
702 if (kernel_map_sync_memtype(paddr
, size
, pcm
) < 0) {
703 free_memtype(paddr
, paddr
+ size
);
710 * Internal interface to free a range of physical memory.
711 * Frees non RAM regions only.
713 static void free_pfn_range(u64 paddr
, unsigned long size
)
717 is_ram
= pat_pagerange_is_ram(paddr
, paddr
+ size
);
719 free_memtype(paddr
, paddr
+ size
);
723 * track_pfn_copy is called when vma that is covering the pfnmap gets
724 * copied through copy_page_range().
726 * If the vma has a linear pfn mapping for the entire range, we get the prot
727 * from pte and reserve the entire vma range with single reserve_pfn_range call.
729 int track_pfn_copy(struct vm_area_struct
*vma
)
731 resource_size_t paddr
;
733 unsigned long vma_size
= vma
->vm_end
- vma
->vm_start
;
736 if (vma
->vm_flags
& VM_PAT
) {
738 * reserve the whole chunk covered by vma. We need the
739 * starting address and protection from pte.
741 if (follow_phys(vma
, vma
->vm_start
, 0, &prot
, &paddr
)) {
745 pgprot
= __pgprot(prot
);
746 return reserve_pfn_range(paddr
, vma_size
, &pgprot
, 1);
753 * prot is passed in as a parameter for the new mapping. If the vma has a
754 * linear pfn mapping for the entire range reserve the entire vma range with
755 * single reserve_pfn_range call.
757 int track_pfn_remap(struct vm_area_struct
*vma
, pgprot_t
*prot
,
758 unsigned long pfn
, unsigned long addr
, unsigned long size
)
760 resource_size_t paddr
= (resource_size_t
)pfn
<< PAGE_SHIFT
;
761 enum page_cache_mode pcm
;
763 /* reserve the whole chunk starting from paddr */
764 if (addr
== vma
->vm_start
&& size
== (vma
->vm_end
- vma
->vm_start
)) {
767 ret
= reserve_pfn_range(paddr
, size
, prot
, 0);
769 vma
->vm_flags
|= VM_PAT
;
777 * For anything smaller than the vma size we set prot based on the
780 pcm
= lookup_memtype(paddr
);
782 /* Check memtype for the remaining pages */
783 while (size
> PAGE_SIZE
) {
786 if (pcm
!= lookup_memtype(paddr
))
790 *prot
= __pgprot((pgprot_val(vma
->vm_page_prot
) & (~_PAGE_CACHE_MASK
)) |
791 cachemode2protval(pcm
));
796 int track_pfn_insert(struct vm_area_struct
*vma
, pgprot_t
*prot
,
799 enum page_cache_mode pcm
;
804 /* Set prot based on lookup */
805 pcm
= lookup_memtype((resource_size_t
)pfn
<< PAGE_SHIFT
);
806 *prot
= __pgprot((pgprot_val(vma
->vm_page_prot
) & (~_PAGE_CACHE_MASK
)) |
807 cachemode2protval(pcm
));
813 * untrack_pfn is called while unmapping a pfnmap for a region.
814 * untrack can be called for a specific region indicated by pfn and size or
815 * can be for the entire vma (in which case pfn, size are zero).
817 void untrack_pfn(struct vm_area_struct
*vma
, unsigned long pfn
,
820 resource_size_t paddr
;
823 if (!(vma
->vm_flags
& VM_PAT
))
826 /* free the chunk starting from pfn or the whole chunk */
827 paddr
= (resource_size_t
)pfn
<< PAGE_SHIFT
;
828 if (!paddr
&& !size
) {
829 if (follow_phys(vma
, vma
->vm_start
, 0, &prot
, &paddr
)) {
834 size
= vma
->vm_end
- vma
->vm_start
;
836 free_pfn_range(paddr
, size
);
837 vma
->vm_flags
&= ~VM_PAT
;
840 pgprot_t
pgprot_writecombine(pgprot_t prot
)
843 return __pgprot(pgprot_val(prot
) |
844 cachemode2protval(_PAGE_CACHE_MODE_WC
));
846 return pgprot_noncached(prot
);
848 EXPORT_SYMBOL_GPL(pgprot_writecombine
);
850 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
852 static struct memtype
*memtype_get_idx(loff_t pos
)
854 struct memtype
*print_entry
;
857 print_entry
= kzalloc(sizeof(struct memtype
), GFP_KERNEL
);
861 spin_lock(&memtype_lock
);
862 ret
= rbt_memtype_copy_nth_element(print_entry
, pos
);
863 spin_unlock(&memtype_lock
);
873 static void *memtype_seq_start(struct seq_file
*seq
, loff_t
*pos
)
877 seq_printf(seq
, "PAT memtype list:\n");
880 return memtype_get_idx(*pos
);
883 static void *memtype_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
886 return memtype_get_idx(*pos
);
889 static void memtype_seq_stop(struct seq_file
*seq
, void *v
)
893 static int memtype_seq_show(struct seq_file
*seq
, void *v
)
895 struct memtype
*print_entry
= (struct memtype
*)v
;
897 seq_printf(seq
, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry
->type
),
898 print_entry
->start
, print_entry
->end
);
904 static const struct seq_operations memtype_seq_ops
= {
905 .start
= memtype_seq_start
,
906 .next
= memtype_seq_next
,
907 .stop
= memtype_seq_stop
,
908 .show
= memtype_seq_show
,
911 static int memtype_seq_open(struct inode
*inode
, struct file
*file
)
913 return seq_open(file
, &memtype_seq_ops
);
916 static const struct file_operations memtype_fops
= {
917 .open
= memtype_seq_open
,
920 .release
= seq_release
,
923 static int __init
pat_memtype_list_init(void)
926 debugfs_create_file("pat_memtype_list", S_IRUSR
,
927 arch_debugfs_dir
, NULL
, &memtype_fops
);
932 late_initcall(pat_memtype_list_init
);
934 #endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */