2008-03-19 00:00:14 +00:00
|
|
|
/*
|
|
|
|
* Handle caching attributes in page tables (PAT)
|
|
|
|
*
|
|
|
|
* Authors: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
|
|
|
|
* Suresh B Siddha <suresh.b.siddha@intel.com>
|
|
|
|
*
|
|
|
|
* Loosely based on earlier PAT patchset from Eric Biederman and Andi Kleen.
|
|
|
|
*/
|
|
|
|
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/bootmem.h>
|
|
|
|
#include <linux/debugfs.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/gfp.h>
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <linux/mm.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
#include <linux/fs.h>
|
|
|
|
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <asm/cacheflush.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
#include <asm/processor.h>
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <asm/tlbflush.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/fcntl.h>
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <asm/e820.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
#include <asm/mtrr.h>
|
2008-09-30 11:20:45 +00:00
|
|
|
#include <asm/page.h>
|
|
|
|
#include <asm/msr.h>
|
|
|
|
#include <asm/pat.h>
|
2008-03-19 00:00:21 +00:00
|
|
|
#include <asm/io.h>
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-05-08 07:18:43 +00:00
|
|
|
#ifdef CONFIG_X86_PAT
|
2008-06-10 14:06:21 +00:00
|
|
|
int __read_mostly pat_enabled = 1;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-05-14 09:20:32 +00:00
|
|
|
void __cpuinit pat_disable(char *reason)
|
2008-03-19 00:00:14 +00:00
|
|
|
{
|
2008-06-10 14:06:21 +00:00
|
|
|
pat_enabled = 0;
|
2008-05-08 07:18:43 +00:00
|
|
|
printk(KERN_INFO "%s\n", reason);
|
2008-03-19 00:00:14 +00:00
|
|
|
}
|
|
|
|
|
2008-05-29 07:01:28 +00:00
|
|
|
static int __init nopat(char *str)
|
2008-03-19 00:00:14 +00:00
|
|
|
{
|
2008-05-08 07:18:43 +00:00
|
|
|
pat_disable("PAT support disabled.");
|
2008-03-19 00:00:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2008-05-08 07:18:43 +00:00
|
|
|
early_param("nopat", nopat);
|
|
|
|
#endif
|
|
|
|
|
2008-05-06 02:09:10 +00:00
|
|
|
|
|
|
|
static int debug_enable;
|
2008-09-30 11:20:45 +00:00
|
|
|
|
2008-05-06 02:09:10 +00:00
|
|
|
static int __init pat_debug_setup(char *str)
|
|
|
|
{
|
|
|
|
debug_enable = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
__setup("debugpat", pat_debug_setup);
|
|
|
|
|
|
|
|
#define dprintk(fmt, arg...) \
|
|
|
|
do { if (debug_enable) printk(KERN_INFO fmt, ##arg); } while (0)
|
|
|
|
|
|
|
|
|
2008-05-08 07:18:43 +00:00
|
|
|
static u64 __read_mostly boot_pat_state;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
enum {
|
|
|
|
PAT_UC = 0, /* uncached */
|
|
|
|
PAT_WC = 1, /* Write combining */
|
|
|
|
PAT_WT = 4, /* Write Through */
|
|
|
|
PAT_WP = 5, /* Write Protected */
|
|
|
|
PAT_WB = 6, /* Write Back (default) */
|
|
|
|
PAT_UC_MINUS = 7, /* UC, but can be overriden by MTRR */
|
|
|
|
};
|
|
|
|
|
2008-06-10 14:05:39 +00:00
|
|
|
#define PAT(x, y) ((u64)PAT_ ## y << ((x)*8))
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
void pat_init(void)
|
|
|
|
{
|
|
|
|
u64 pat;
|
|
|
|
|
2008-06-10 14:06:21 +00:00
|
|
|
if (!pat_enabled)
|
2008-03-19 00:00:14 +00:00
|
|
|
return;
|
|
|
|
|
2008-05-08 07:18:43 +00:00
|
|
|
/* Paranoia check. */
|
2008-06-10 14:05:18 +00:00
|
|
|
if (!cpu_has_pat && boot_pat_state) {
|
2008-05-08 07:18:43 +00:00
|
|
|
/*
|
2008-06-10 14:05:18 +00:00
|
|
|
* If this happens we are on a secondary CPU, but
|
2008-05-08 07:18:43 +00:00
|
|
|
* switched to PAT on the boot CPU. We have no way to
|
|
|
|
* undo PAT.
|
2008-06-10 14:05:18 +00:00
|
|
|
*/
|
|
|
|
printk(KERN_ERR "PAT enabled, "
|
|
|
|
"but not supported by secondary CPU\n");
|
|
|
|
BUG();
|
2008-05-08 07:18:43 +00:00
|
|
|
}
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
/* Set PWT to Write-Combining. All other bits stay the same */
|
|
|
|
/*
|
|
|
|
* PTE encoding used in Linux:
|
|
|
|
* PAT
|
|
|
|
* |PCD
|
|
|
|
* ||PWT
|
|
|
|
* |||
|
|
|
|
* 000 WB _PAGE_CACHE_WB
|
|
|
|
* 001 WC _PAGE_CACHE_WC
|
|
|
|
* 010 UC- _PAGE_CACHE_UC_MINUS
|
|
|
|
* 011 UC _PAGE_CACHE_UC
|
|
|
|
* PAT bit unused
|
|
|
|
*/
|
2008-06-10 14:05:39 +00:00
|
|
|
pat = PAT(0, WB) | PAT(1, WC) | PAT(2, UC_MINUS) | PAT(3, UC) |
|
|
|
|
PAT(4, WB) | PAT(5, WC) | PAT(6, UC_MINUS) | PAT(7, UC);
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
/* Boot CPU check */
|
2008-05-08 07:18:43 +00:00
|
|
|
if (!boot_pat_state)
|
2008-03-19 00:00:14 +00:00
|
|
|
rdmsrl(MSR_IA32_CR_PAT, boot_pat_state);
|
|
|
|
|
|
|
|
wrmsrl(MSR_IA32_CR_PAT, pat);
|
|
|
|
printk(KERN_INFO "x86 PAT enabled: cpu %d, old 0x%Lx, new 0x%Lx\n",
|
|
|
|
smp_processor_id(), boot_pat_state, pat);
|
|
|
|
}
|
|
|
|
|
|
|
|
#undef PAT
|
|
|
|
|
|
|
|
static char *cattr_name(unsigned long flags)
|
|
|
|
{
|
|
|
|
switch (flags & _PAGE_CACHE_MASK) {
|
2008-06-10 14:05:39 +00:00
|
|
|
case _PAGE_CACHE_UC: return "uncached";
|
|
|
|
case _PAGE_CACHE_UC_MINUS: return "uncached-minus";
|
|
|
|
case _PAGE_CACHE_WB: return "write-back";
|
|
|
|
case _PAGE_CACHE_WC: return "write-combining";
|
|
|
|
default: return "broken";
|
2008-03-19 00:00:14 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The global memtype list keeps track of memory type for specific
|
|
|
|
* physical memory areas. Conflicting memory types in different
|
|
|
|
* mappings can cause CPU cache corruption. To avoid this we keep track.
|
|
|
|
*
|
|
|
|
* The list is sorted based on starting address and can contain multiple
|
|
|
|
* entries for each address (this allows reference counting for overlapping
|
|
|
|
* areas). All the aliases have the same cache attributes of course.
|
|
|
|
* Zero attributes are represented as holes.
|
|
|
|
*
|
|
|
|
* Currently the data structure is a list because the number of mappings
|
|
|
|
* are expected to be relatively small. If this should be a problem
|
|
|
|
* it could be changed to a rbtree or similar.
|
|
|
|
*
|
|
|
|
* memtype_lock protects the whole list.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct memtype {
|
2008-09-30 11:20:45 +00:00
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
unsigned long type;
|
|
|
|
struct list_head nd;
|
2008-03-19 00:00:14 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(memtype_list);
|
2008-09-30 11:20:45 +00:00
|
|
|
static DEFINE_SPINLOCK(memtype_lock); /* protects memtype list */
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Does intersection of PAT memory type and MTRR memory type and returns
|
|
|
|
* the resulting memory type as PAT understands it.
|
|
|
|
* (Type in pat and mtrr will not have same value)
|
|
|
|
* The intersection is based on "Effective Memory Type" tables in IA-32
|
|
|
|
* SDM vol 3a
|
|
|
|
*/
|
2008-06-16 17:42:43 +00:00
|
|
|
static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
|
2008-03-19 00:00:14 +00:00
|
|
|
{
|
x86: fix Xorg crash with xf86MapVidMem error
Clarify the usage of mtrr_lookup() in PAT code, and to make PAT code
resilient to mtrr lookup problems.
Specifically, pat_x_mtrr_type() is restructured to highlight, under what
conditions we look for mtrr hint. pat_x_mtrr_type() uses a default type
when there are any errors in mtrr lookup (still maintaining the pat
consistency). And, reserve_memtype() highlights its usage ot mtrr_lookup
for request type of '-1' and also defaults in a sane way on any mtrr
lookup failure.
pat.c looks at mtrr type of a range to get a hint on what mapping type
to request when user/API: (1) hasn't specified any type (/dev/mem
mapping) and we do not want to take performance hit by always mapping
UC_MINUS. This will be the case for /dev/mem mappings used to map BIOS
area or ACPI region which are WB'able. In this case, as long as MTRR is
not WB, PAT will request UC_MINUS for such mappings.
(2) user/API requests WB mapping while in reality MTRR may have UC or
WC. In this case, PAT can map as WB (without checking MTRR) and still
effective type will be UC or WC. But, a subsequent request to map same
region as UC or WC may fail, as the region will get trackked as WB in
PAT list. Looking at MTRR hint helps us to track based on effective type
rather than what user requested. Again, here mtrr_lookup is only used as
hint and we fallback to WB mapping (as requested by user) as default.
In both cases, after using the mtrr hint, we still go through the
memtype list to make sure there are no inconsistencies among multiple
users.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Tested-by: Rufus & Azrael <rufus-azrael@numericable.fr>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-05-29 19:01:44 +00:00
|
|
|
/*
|
|
|
|
* Look for MTRR hint to get the effective type in case where PAT
|
|
|
|
* request is for WB.
|
|
|
|
*/
|
2008-06-18 13:38:57 +00:00
|
|
|
if (req_type == _PAGE_CACHE_WB) {
|
|
|
|
u8 mtrr_type;
|
|
|
|
|
|
|
|
mtrr_type = mtrr_type_lookup(start, end);
|
|
|
|
if (mtrr_type == MTRR_TYPE_UNCACHABLE)
|
|
|
|
return _PAGE_CACHE_UC;
|
|
|
|
if (mtrr_type == MTRR_TYPE_WRCOMB)
|
|
|
|
return _PAGE_CACHE_WC;
|
|
|
|
}
|
|
|
|
|
|
|
|
return req_type;
|
2008-03-19 00:00:14 +00:00
|
|
|
}
|
|
|
|
|
2008-09-30 11:20:45 +00:00
|
|
|
static int
|
|
|
|
chk_conflict(struct memtype *new, struct memtype *entry, unsigned long *type)
|
2008-06-20 20:07:09 +00:00
|
|
|
{
|
|
|
|
if (new->type != entry->type) {
|
|
|
|
if (type) {
|
|
|
|
new->type = entry->type;
|
|
|
|
*type = entry->type;
|
|
|
|
} else
|
|
|
|
goto conflict;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check overlaps with more than one entry in the list */
|
|
|
|
list_for_each_entry_continue(entry, &memtype_list, nd) {
|
|
|
|
if (new->end <= entry->start)
|
|
|
|
break;
|
|
|
|
else if (new->type != entry->type)
|
|
|
|
goto conflict;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
conflict:
|
|
|
|
printk(KERN_INFO "%s:%d conflicting memory types "
|
|
|
|
"%Lx-%Lx %s<->%s\n", current->comm, current->pid, new->start,
|
|
|
|
new->end, cattr_name(new->type), cattr_name(entry->type));
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
2008-08-19 23:28:01 +00:00
|
|
|
static struct memtype *cached_entry;
|
|
|
|
static u64 cached_start;
|
|
|
|
|
2008-09-24 15:53:33 +00:00
|
|
|
/*
|
|
|
|
* For RAM pages, mark the pages as non WB memory type using
|
|
|
|
* PageNonWB (PG_arch_1). We allow only one set_memory_uc() or
|
|
|
|
* set_memory_wc() on a RAM page at a time before marking it as WB again.
|
|
|
|
* This is ok, because only one driver will be owning the page and
|
|
|
|
* doing set_memory_*() calls.
|
|
|
|
*
|
|
|
|
* For now, we use PageNonWB to track that the RAM page is being mapped
|
|
|
|
* as non WB. In future, we will have to use one more flag
|
|
|
|
* (or some other mechanism in page_struct) to distinguish between
|
|
|
|
* UC and WC mapping.
|
|
|
|
*/
|
|
|
|
static int reserve_ram_pages_type(u64 start, u64 end, unsigned long req_type,
|
2008-09-30 11:20:45 +00:00
|
|
|
unsigned long *new_type)
|
2008-09-24 15:53:33 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
u64 pfn, end_pfn;
|
|
|
|
|
|
|
|
for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
if (page_mapped(page) || PageNonWB(page))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
SetPageNonWB(page);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
end_pfn = pfn;
|
|
|
|
for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
ClearPageNonWB(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int free_ram_pages_type(u64 start, u64 end)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
u64 pfn, end_pfn;
|
|
|
|
|
|
|
|
for (pfn = (start >> PAGE_SHIFT); pfn < (end >> PAGE_SHIFT); ++pfn) {
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
if (page_mapped(page) || !PageNonWB(page))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ClearPageNonWB(page);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
out:
|
|
|
|
end_pfn = pfn;
|
|
|
|
for (pfn = (start >> PAGE_SHIFT); pfn < end_pfn; ++pfn) {
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
SetPageNonWB(page);
|
|
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-03-19 00:00:21 +00:00
|
|
|
/*
|
|
|
|
* req_type typically has one of the:
|
|
|
|
* - _PAGE_CACHE_WB
|
|
|
|
* - _PAGE_CACHE_WC
|
|
|
|
* - _PAGE_CACHE_UC_MINUS
|
|
|
|
* - _PAGE_CACHE_UC
|
|
|
|
*
|
|
|
|
* req_type will have a special case value '-1', when requester want to inherit
|
|
|
|
* the memory type from mtrr (if WB), existing PAT, defaulting to UC_MINUS.
|
|
|
|
*
|
2008-06-20 20:01:49 +00:00
|
|
|
* If new_type is NULL, function will return an error if it cannot reserve the
|
|
|
|
* region with req_type. If new_type is non-NULL, function will return
|
|
|
|
* available type in new_type in case of no error. In case of any error
|
2008-03-19 00:00:21 +00:00
|
|
|
* it will return a negative return value.
|
|
|
|
*/
|
2008-03-19 00:00:14 +00:00
|
|
|
int reserve_memtype(u64 start, u64 end, unsigned long req_type,
|
2008-09-30 11:20:45 +00:00
|
|
|
unsigned long *new_type)
|
2008-03-19 00:00:14 +00:00
|
|
|
{
|
2008-06-20 20:01:49 +00:00
|
|
|
struct memtype *new, *entry;
|
2008-03-19 00:00:14 +00:00
|
|
|
unsigned long actual_type;
|
2008-06-20 20:05:37 +00:00
|
|
|
struct list_head *where;
|
2008-09-24 15:53:33 +00:00
|
|
|
int is_range_ram;
|
2008-09-30 11:20:45 +00:00
|
|
|
int err = 0;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-09-30 11:20:45 +00:00
|
|
|
BUG_ON(start >= end); /* end is exclusive */
|
2008-06-20 20:03:06 +00:00
|
|
|
|
2008-06-10 14:06:21 +00:00
|
|
|
if (!pat_enabled) {
|
2008-03-19 00:00:21 +00:00
|
|
|
/* This is identical to page table setting without PAT */
|
2008-06-20 20:01:49 +00:00
|
|
|
if (new_type) {
|
|
|
|
if (req_type == -1)
|
|
|
|
*new_type = _PAGE_CACHE_WB;
|
|
|
|
else
|
|
|
|
*new_type = req_type & _PAGE_CACHE_MASK;
|
2008-03-19 00:00:21 +00:00
|
|
|
}
|
2008-03-19 00:00:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Low ISA region is always mapped WB in page table. No need to track */
|
2008-06-20 19:58:46 +00:00
|
|
|
if (is_ISA_range(start, end - 1)) {
|
2008-06-20 20:01:49 +00:00
|
|
|
if (new_type)
|
|
|
|
*new_type = _PAGE_CACHE_WB;
|
2008-03-19 00:00:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-19 00:00:21 +00:00
|
|
|
if (req_type == -1) {
|
|
|
|
/*
|
x86: fix Xorg crash with xf86MapVidMem error
Clarify the usage of mtrr_lookup() in PAT code, and to make PAT code
resilient to mtrr lookup problems.
Specifically, pat_x_mtrr_type() is restructured to highlight, under what
conditions we look for mtrr hint. pat_x_mtrr_type() uses a default type
when there are any errors in mtrr lookup (still maintaining the pat
consistency). And, reserve_memtype() highlights its usage ot mtrr_lookup
for request type of '-1' and also defaults in a sane way on any mtrr
lookup failure.
pat.c looks at mtrr type of a range to get a hint on what mapping type
to request when user/API: (1) hasn't specified any type (/dev/mem
mapping) and we do not want to take performance hit by always mapping
UC_MINUS. This will be the case for /dev/mem mappings used to map BIOS
area or ACPI region which are WB'able. In this case, as long as MTRR is
not WB, PAT will request UC_MINUS for such mappings.
(2) user/API requests WB mapping while in reality MTRR may have UC or
WC. In this case, PAT can map as WB (without checking MTRR) and still
effective type will be UC or WC. But, a subsequent request to map same
region as UC or WC may fail, as the region will get trackked as WB in
PAT list. Looking at MTRR hint helps us to track based on effective type
rather than what user requested. Again, here mtrr_lookup is only used as
hint and we fallback to WB mapping (as requested by user) as default.
In both cases, after using the mtrr hint, we still go through the
memtype list to make sure there are no inconsistencies among multiple
users.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Suresh Siddha <suresh.b.siddha@intel.com>
Tested-by: Rufus & Azrael <rufus-azrael@numericable.fr>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2008-05-29 19:01:44 +00:00
|
|
|
* Call mtrr_lookup to get the type hint. This is an
|
|
|
|
* optimization for /dev/mem mmap'ers into WB memory (BIOS
|
|
|
|
* tools and ACPI tools). Use WB request for WB memory and use
|
|
|
|
* UC_MINUS otherwise.
|
2008-03-19 00:00:21 +00:00
|
|
|
*/
|
|
|
|
u8 mtrr_type = mtrr_type_lookup(start, end);
|
|
|
|
|
2008-06-20 20:03:06 +00:00
|
|
|
if (mtrr_type == MTRR_TYPE_WRBACK)
|
2008-03-19 00:00:21 +00:00
|
|
|
actual_type = _PAGE_CACHE_WB;
|
2008-06-20 20:03:06 +00:00
|
|
|
else
|
2008-03-19 00:00:21 +00:00
|
|
|
actual_type = _PAGE_CACHE_UC_MINUS;
|
2008-09-30 11:20:45 +00:00
|
|
|
} else {
|
2008-06-20 20:03:06 +00:00
|
|
|
actual_type = pat_x_mtrr_type(start, end,
|
|
|
|
req_type & _PAGE_CACHE_MASK);
|
2008-09-30 11:20:45 +00:00
|
|
|
}
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-09-24 15:53:33 +00:00
|
|
|
is_range_ram = pagerange_is_ram(start, end);
|
|
|
|
if (is_range_ram == 1)
|
|
|
|
return reserve_ram_pages_type(start, end, req_type, new_type);
|
|
|
|
else if (is_range_ram < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-06-20 20:01:49 +00:00
|
|
|
new = kmalloc(sizeof(struct memtype), GFP_KERNEL);
|
|
|
|
if (!new)
|
2008-03-19 00:00:14 +00:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-09-30 11:20:45 +00:00
|
|
|
new->start = start;
|
|
|
|
new->end = end;
|
|
|
|
new->type = actual_type;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-06-20 20:01:49 +00:00
|
|
|
if (new_type)
|
|
|
|
*new_type = actual_type;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
|
|
|
spin_lock(&memtype_lock);
|
|
|
|
|
2008-08-19 23:28:01 +00:00
|
|
|
if (cached_entry && start >= cached_start)
|
|
|
|
entry = cached_entry;
|
|
|
|
else
|
|
|
|
entry = list_entry(&memtype_list, struct memtype, nd);
|
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
/* Search for existing mapping that overlaps the current range */
|
2008-06-20 20:05:37 +00:00
|
|
|
where = NULL;
|
2008-08-19 23:28:01 +00:00
|
|
|
list_for_each_entry_continue(entry, &memtype_list, nd) {
|
2008-06-20 20:08:37 +00:00
|
|
|
if (end <= entry->start) {
|
2008-06-20 20:05:37 +00:00
|
|
|
where = entry->nd.prev;
|
2008-08-19 23:28:01 +00:00
|
|
|
cached_entry = list_entry(where, struct memtype, nd);
|
2008-03-19 00:00:14 +00:00
|
|
|
break;
|
2008-06-20 20:08:37 +00:00
|
|
|
} else if (start <= entry->start) { /* end > entry->start */
|
2008-06-20 20:07:09 +00:00
|
|
|
err = chk_conflict(new, entry, new_type);
|
2008-06-20 20:08:37 +00:00
|
|
|
if (!err) {
|
|
|
|
dprintk("Overlap at 0x%Lx-0x%Lx\n",
|
|
|
|
entry->start, entry->end);
|
|
|
|
where = entry->nd.prev;
|
2008-08-19 23:28:01 +00:00
|
|
|
cached_entry = list_entry(where,
|
|
|
|
struct memtype, nd);
|
2008-03-19 00:00:14 +00:00
|
|
|
}
|
|
|
|
break;
|
2008-06-20 20:08:37 +00:00
|
|
|
} else if (start < entry->end) { /* start > entry->start */
|
2008-06-20 20:07:09 +00:00
|
|
|
err = chk_conflict(new, entry, new_type);
|
2008-06-20 20:08:37 +00:00
|
|
|
if (!err) {
|
|
|
|
dprintk("Overlap at 0x%Lx-0x%Lx\n",
|
|
|
|
entry->start, entry->end);
|
2008-08-19 23:28:01 +00:00
|
|
|
cached_entry = list_entry(entry->nd.prev,
|
|
|
|
struct memtype, nd);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Move to right position in the linked
|
|
|
|
* list to add this new entry
|
|
|
|
*/
|
|
|
|
list_for_each_entry_continue(entry,
|
|
|
|
&memtype_list, nd) {
|
|
|
|
if (start <= entry->start) {
|
|
|
|
where = entry->nd.prev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-03-19 00:00:14 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
2008-06-20 20:04:02 +00:00
|
|
|
printk(KERN_INFO "reserve_memtype failed 0x%Lx-0x%Lx, "
|
|
|
|
"track %s, req %s\n",
|
|
|
|
start, end, cattr_name(new->type), cattr_name(req_type));
|
2008-06-20 20:01:49 +00:00
|
|
|
kfree(new);
|
2008-03-19 00:00:14 +00:00
|
|
|
spin_unlock(&memtype_lock);
|
2008-09-30 11:20:45 +00:00
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-08-19 23:28:01 +00:00
|
|
|
cached_start = start;
|
|
|
|
|
2008-06-20 20:05:37 +00:00
|
|
|
if (where)
|
|
|
|
list_add(&new->nd, where);
|
|
|
|
else
|
2008-06-20 20:01:49 +00:00
|
|
|
list_add_tail(&new->nd, &memtype_list);
|
2008-03-19 00:00:25 +00:00
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
spin_unlock(&memtype_lock);
|
2008-06-20 20:04:02 +00:00
|
|
|
|
|
|
|
dprintk("reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
|
|
|
|
start, end, cattr_name(new->type), cattr_name(req_type),
|
|
|
|
new_type ? cattr_name(*new_type) : "-");
|
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int free_memtype(u64 start, u64 end)
|
|
|
|
{
|
2008-06-20 20:01:49 +00:00
|
|
|
struct memtype *entry;
|
2008-03-19 00:00:14 +00:00
|
|
|
int err = -EINVAL;
|
2008-09-24 15:53:33 +00:00
|
|
|
int is_range_ram;
|
2008-03-19 00:00:14 +00:00
|
|
|
|
2008-06-20 20:03:06 +00:00
|
|
|
if (!pat_enabled)
|
2008-03-19 00:00:14 +00:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Low ISA region is always mapped WB. No need to track */
|
2008-06-20 19:58:46 +00:00
|
|
|
if (is_ISA_range(start, end - 1))
|
2008-03-19 00:00:14 +00:00
|
|
|
return 0;
|
|
|
|
|
2008-09-24 15:53:33 +00:00
|
|
|
is_range_ram = pagerange_is_ram(start, end);
|
|
|
|
if (is_range_ram == 1)
|
|
|
|
return free_ram_pages_type(start, end);
|
|
|
|
else if (is_range_ram < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
spin_lock(&memtype_lock);
|
2008-06-20 20:01:49 +00:00
|
|
|
list_for_each_entry(entry, &memtype_list, nd) {
|
|
|
|
if (entry->start == start && entry->end == end) {
|
2008-08-19 23:28:01 +00:00
|
|
|
if (cached_entry == entry || cached_start == start)
|
|
|
|
cached_entry = NULL;
|
|
|
|
|
2008-06-20 20:01:49 +00:00
|
|
|
list_del(&entry->nd);
|
|
|
|
kfree(entry);
|
2008-03-19 00:00:14 +00:00
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
|
|
|
|
if (err) {
|
2008-04-03 08:14:33 +00:00
|
|
|
printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
|
2008-03-19 00:00:14 +00:00
|
|
|
current->comm, current->pid, start, end);
|
|
|
|
}
|
2008-03-19 00:00:25 +00:00
|
|
|
|
2008-05-06 02:09:10 +00:00
|
|
|
dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
|
2008-09-30 11:20:45 +00:00
|
|
|
|
2008-03-19 00:00:14 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-03-19 00:00:20 +00:00
|
|
|
|
|
|
|
pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
|
|
|
|
unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
return vma_prot;
|
|
|
|
}
|
|
|
|
|
2008-07-17 22:26:59 +00:00
|
|
|
#ifdef CONFIG_STRICT_DEVMEM
|
|
|
|
/* This check is done in drivers/char/mem.c in case of STRICT_DEVMEM*/
|
2008-04-26 18:32:12 +00:00
|
|
|
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#else
|
2008-10-30 20:59:21 +00:00
|
|
|
/* This check is needed to avoid cache aliasing when PAT is enabled */
|
2008-04-26 18:32:12 +00:00
|
|
|
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
|
|
|
|
{
|
|
|
|
u64 from = ((u64)pfn) << PAGE_SHIFT;
|
|
|
|
u64 to = from + size;
|
|
|
|
u64 cursor = from;
|
|
|
|
|
2008-10-30 20:59:21 +00:00
|
|
|
if (!pat_enabled)
|
|
|
|
return 1;
|
|
|
|
|
2008-04-26 18:32:12 +00:00
|
|
|
while (cursor < to) {
|
|
|
|
if (!devmem_is_allowed(pfn)) {
|
|
|
|
printk(KERN_INFO
|
|
|
|
"Program %s tried to access /dev/mem between %Lx->%Lx.\n",
|
|
|
|
current->comm, from, to);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
cursor += PAGE_SIZE;
|
|
|
|
pfn++;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
2008-07-17 22:26:59 +00:00
|
|
|
#endif /* CONFIG_STRICT_DEVMEM */
|
2008-04-26 18:32:12 +00:00
|
|
|
|
2008-03-19 00:00:20 +00:00
|
|
|
int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
|
|
|
|
unsigned long size, pgprot_t *vma_prot)
|
|
|
|
{
|
2008-03-19 00:00:21 +00:00
|
|
|
u64 offset = ((u64) pfn) << PAGE_SHIFT;
|
2008-08-20 23:45:52 +00:00
|
|
|
unsigned long flags = -1;
|
2008-03-19 00:00:21 +00:00
|
|
|
int retval;
|
2008-03-19 00:00:20 +00:00
|
|
|
|
2008-04-26 18:32:12 +00:00
|
|
|
if (!range_is_allowed(pfn, size))
|
|
|
|
return 0;
|
|
|
|
|
2008-03-19 00:00:20 +00:00
|
|
|
if (file->f_flags & O_SYNC) {
|
2008-08-20 23:45:52 +00:00
|
|
|
flags = _PAGE_CACHE_UC_MINUS;
|
2008-03-19 00:00:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
/*
|
|
|
|
* On the PPro and successors, the MTRRs are used to set
|
|
|
|
* memory types for physical addresses outside main memory,
|
|
|
|
* so blindly setting UC or PWT on those pages is wrong.
|
|
|
|
* For Pentiums and earlier, the surround logic should disable
|
|
|
|
* caching for the high addresses through the KEN pin, but
|
|
|
|
* we maintain the tradition of paranoia in this code.
|
|
|
|
*/
|
2008-06-10 14:06:21 +00:00
|
|
|
if (!pat_enabled &&
|
2008-06-10 14:05:39 +00:00
|
|
|
!(boot_cpu_has(X86_FEATURE_MTRR) ||
|
|
|
|
boot_cpu_has(X86_FEATURE_K6_MTRR) ||
|
|
|
|
boot_cpu_has(X86_FEATURE_CYRIX_ARR) ||
|
|
|
|
boot_cpu_has(X86_FEATURE_CENTAUR_MCR)) &&
|
|
|
|
(pfn << PAGE_SHIFT) >= __pa(high_memory)) {
|
2008-03-19 00:00:21 +00:00
|
|
|
flags = _PAGE_CACHE_UC;
|
2008-03-19 00:00:20 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-19 00:00:21 +00:00
|
|
|
/*
|
2008-08-20 23:45:52 +00:00
|
|
|
* With O_SYNC, we can only take UC_MINUS mapping. Fail if we cannot.
|
|
|
|
*
|
2008-03-19 00:00:21 +00:00
|
|
|
* Without O_SYNC, we want to get
|
|
|
|
* - WB for WB-able memory and no other conflicting mappings
|
|
|
|
* - UC_MINUS for non-WB-able memory with no other conflicting mappings
|
|
|
|
* - Inherit from confliting mappings otherwise
|
|
|
|
*/
|
2008-08-20 23:45:52 +00:00
|
|
|
if (flags != -1) {
|
2008-03-19 00:00:21 +00:00
|
|
|
retval = reserve_memtype(offset, offset + size, flags, NULL);
|
|
|
|
} else {
|
x86: PAT fix
Adrian Bunk noticed the following Coverity report:
> Commit e7f260a276f2c9184fe753732d834b1f6fbe9f17
> (x86: PAT use reserve free memtype in mmap of /dev/mem)
> added the following gem to arch/x86/mm/pat.c:
>
> <-- snip -->
>
> ...
> int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
> unsigned long size, pgprot_t *vma_prot)
> {
> u64 offset = ((u64) pfn) << PAGE_SHIFT;
> unsigned long flags = _PAGE_CACHE_UC_MINUS;
> unsigned long ret_flags;
> ...
> ... (nothing that touches ret_flags)
> ...
> if (flags != _PAGE_CACHE_UC_MINUS) {
> retval = reserve_memtype(offset, offset + size, flags, NULL);
> } else {
> retval = reserve_memtype(offset, offset + size, -1, &ret_flags);
> }
>
> if (retval < 0)
> return 0;
>
> flags = ret_flags;
>
> if (pfn <= max_pfn_mapped &&
> ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
> free_memtype(offset, offset + size);
> printk(KERN_INFO
> "%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
> current->comm, current->pid,
> cattr_name(flags),
> offset, offset + size);
> return 0;
> }
>
> *vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
> flags);
> return 1;
> }
>
> <-- snip -->
>
> If (flags != _PAGE_CACHE_UC_MINUS) we pass garbage from the stack to
> ioremap_change_attr() and/or __pgprot().
>
> Spotted by the Coverity checker.
the fix simplifies the code as we get rid of the 'ret_flags'
complication.
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-03-21 14:42:28 +00:00
|
|
|
retval = reserve_memtype(offset, offset + size, -1, &flags);
|
2008-03-19 00:00:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (retval < 0)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-12 21:31:28 +00:00
|
|
|
if (((pfn < max_low_pfn_mapped) ||
|
|
|
|
(pfn >= (1UL<<(32 - PAGE_SHIFT)) && pfn < max_pfn_mapped)) &&
|
2008-06-10 14:05:39 +00:00
|
|
|
ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
|
2008-03-19 00:00:21 +00:00
|
|
|
free_memtype(offset, offset + size);
|
2008-04-03 08:14:33 +00:00
|
|
|
printk(KERN_INFO
|
2008-03-19 00:00:21 +00:00
|
|
|
"%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
cattr_name(flags),
|
2008-05-12 09:22:26 +00:00
|
|
|
offset, (unsigned long long)(offset + size));
|
2008-03-19 00:00:21 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
*vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
|
|
|
|
flags);
|
2008-03-19 00:00:20 +00:00
|
|
|
return 1;
|
|
|
|
}
|
2008-03-19 00:00:21 +00:00
|
|
|
|
|
|
|
void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
2008-09-30 11:20:45 +00:00
|
|
|
unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
|
2008-03-19 00:00:21 +00:00
|
|
|
u64 addr = (u64)pfn << PAGE_SHIFT;
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
reserve_memtype(addr, addr + size, want_flags, &flags);
|
|
|
|
if (flags != want_flags) {
|
2008-04-03 08:14:33 +00:00
|
|
|
printk(KERN_INFO
|
2008-03-19 00:00:21 +00:00
|
|
|
"%s:%d /dev/mem expected mapping type %s for %Lx-%Lx, got %s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
cattr_name(want_flags),
|
2008-05-12 09:22:26 +00:00
|
|
|
addr, (unsigned long long)(addr + size),
|
2008-03-19 00:00:21 +00:00
|
|
|
cattr_name(flags));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void unmap_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
u64 addr = (u64)pfn << PAGE_SHIFT;
|
|
|
|
|
|
|
|
free_memtype(addr, addr + size);
|
|
|
|
}
|
|
|
|
|
2008-12-18 19:41:30 +00:00
|
|
|
/*
|
|
|
|
* Internal interface to reserve a range of physical memory with prot.
|
|
|
|
* Reserved non RAM regions only and after successful reserve_memtype,
|
|
|
|
* this func also keeps identity mapping (if any) in sync with this new prot.
|
|
|
|
*/
|
|
|
|
static int reserve_pfn_range(u64 paddr, unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
int is_ram = 0;
|
|
|
|
int id_sz, ret;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
|
|
|
|
|
|
|
|
is_ram = pagerange_is_ram(paddr, paddr + size);
|
|
|
|
|
|
|
|
if (is_ram != 0) {
|
|
|
|
/*
|
|
|
|
* For mapping RAM pages, drivers need to call
|
|
|
|
* set_memory_[uc|wc|wb] directly, for reserve and free, before
|
|
|
|
* setting up the PTE.
|
|
|
|
*/
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = reserve_memtype(paddr, paddr + size, want_flags, &flags);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (flags != want_flags) {
|
|
|
|
free_memtype(paddr, paddr + size);
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s:%d map pfn expected mapping type %s for %Lx-%Lx, got %s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
cattr_name(want_flags),
|
|
|
|
(unsigned long long)paddr,
|
|
|
|
(unsigned long long)(paddr + size),
|
|
|
|
cattr_name(flags));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Need to keep identity mapping in sync */
|
|
|
|
if (paddr >= __pa(high_memory))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
id_sz = (__pa(high_memory) < paddr + size) ?
|
|
|
|
__pa(high_memory) - paddr :
|
|
|
|
size;
|
|
|
|
|
|
|
|
if (ioremap_change_attr((unsigned long)__va(paddr), id_sz, flags) < 0) {
|
|
|
|
free_memtype(paddr, paddr + size);
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s:%d reserve_pfn_range ioremap_change_attr failed %s "
|
|
|
|
"for %Lx-%Lx\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
cattr_name(flags),
|
|
|
|
(unsigned long long)paddr,
|
|
|
|
(unsigned long long)(paddr + size));
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Internal interface to free a range of physical memory.
|
|
|
|
* Frees non RAM regions only.
|
|
|
|
*/
|
|
|
|
static void free_pfn_range(u64 paddr, unsigned long size)
|
|
|
|
{
|
|
|
|
int is_ram;
|
|
|
|
|
|
|
|
is_ram = pagerange_is_ram(paddr, paddr + size);
|
|
|
|
if (is_ram == 0)
|
|
|
|
free_memtype(paddr, paddr + size);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* track_pfn_vma_copy is called when vma that is covering the pfnmap gets
|
|
|
|
* copied through copy_page_range().
|
|
|
|
*
|
|
|
|
* If the vma has a linear pfn mapping for the entire range, we get the prot
|
|
|
|
* from pte and reserve the entire vma range with single reserve_pfn_range call.
|
|
|
|
* Otherwise, we reserve the entire vma range, my ging through the PTEs page
|
|
|
|
* by page to get physical address and protection.
|
|
|
|
*/
|
|
|
|
int track_pfn_vma_copy(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
unsigned long i, j;
|
2008-12-23 18:10:40 +00:00
|
|
|
resource_size_t paddr;
|
2008-12-19 21:47:28 +00:00
|
|
|
unsigned long prot;
|
2008-12-18 19:41:30 +00:00
|
|
|
unsigned long vma_start = vma->vm_start;
|
|
|
|
unsigned long vma_end = vma->vm_end;
|
|
|
|
unsigned long vma_size = vma_end - vma_start;
|
|
|
|
|
|
|
|
if (!pat_enabled)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (is_linear_pfn_mapping(vma)) {
|
|
|
|
/*
|
2008-12-19 21:47:28 +00:00
|
|
|
* reserve the whole chunk covered by vma. We need the
|
|
|
|
* starting address and protection from pte.
|
2008-12-18 19:41:30 +00:00
|
|
|
*/
|
2008-12-19 21:47:28 +00:00
|
|
|
if (follow_phys(vma, vma_start, 0, &prot, &paddr)) {
|
2008-12-18 19:41:30 +00:00
|
|
|
WARN_ON_ONCE(1);
|
2008-12-19 21:47:28 +00:00
|
|
|
return -EINVAL;
|
2008-12-18 19:41:30 +00:00
|
|
|
}
|
2008-12-19 21:47:28 +00:00
|
|
|
return reserve_pfn_range(paddr, vma_size, __pgprot(prot));
|
2008-12-18 19:41:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reserve entire vma page by page, using pfn and prot from pte */
|
|
|
|
for (i = 0; i < vma_size; i += PAGE_SIZE) {
|
2008-12-19 21:47:28 +00:00
|
|
|
if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
|
2008-12-18 19:41:30 +00:00
|
|
|
continue;
|
|
|
|
|
2008-12-19 21:47:28 +00:00
|
|
|
retval = reserve_pfn_range(paddr, PAGE_SIZE, __pgprot(prot));
|
2008-12-18 19:41:30 +00:00
|
|
|
if (retval)
|
|
|
|
goto cleanup_ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup_ret:
|
|
|
|
/* Reserve error: Cleanup partial reservation and return error */
|
|
|
|
for (j = 0; j < i; j += PAGE_SIZE) {
|
2008-12-19 21:47:28 +00:00
|
|
|
if (follow_phys(vma, vma_start + j, 0, &prot, &paddr))
|
2008-12-18 19:41:30 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
free_pfn_range(paddr, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* track_pfn_vma_new is called when a _new_ pfn mapping is being established
|
|
|
|
* for physical range indicated by pfn and size.
|
|
|
|
*
|
|
|
|
* prot is passed in as a parameter for the new mapping. If the vma has a
|
|
|
|
* linear pfn mapping for the entire range reserve the entire vma range with
|
|
|
|
* single reserve_pfn_range call.
|
|
|
|
* Otherwise, we look t the pfn and size and reserve only the specified range
|
|
|
|
* page by page.
|
|
|
|
*
|
|
|
|
* Note that this function can be called with caller trying to map only a
|
|
|
|
* subrange/page inside the vma.
|
|
|
|
*/
|
2009-01-10 00:13:11 +00:00
|
|
|
int track_pfn_vma_new(struct vm_area_struct *vma, pgprot_t *prot,
|
2008-12-18 19:41:30 +00:00
|
|
|
unsigned long pfn, unsigned long size)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
unsigned long i, j;
|
2008-12-23 18:10:40 +00:00
|
|
|
resource_size_t base_paddr;
|
|
|
|
resource_size_t paddr;
|
2008-12-18 19:41:30 +00:00
|
|
|
unsigned long vma_start = vma->vm_start;
|
|
|
|
unsigned long vma_end = vma->vm_end;
|
|
|
|
unsigned long vma_size = vma_end - vma_start;
|
|
|
|
|
|
|
|
if (!pat_enabled)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (is_linear_pfn_mapping(vma)) {
|
|
|
|
/* reserve the whole chunk starting from vm_pgoff */
|
2008-12-23 18:10:40 +00:00
|
|
|
paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
|
2009-01-10 00:13:11 +00:00
|
|
|
return reserve_pfn_range(paddr, vma_size, *prot);
|
2008-12-18 19:41:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* reserve page by page using pfn and size */
|
2008-12-23 18:10:40 +00:00
|
|
|
base_paddr = (resource_size_t)pfn << PAGE_SHIFT;
|
2008-12-18 19:41:30 +00:00
|
|
|
for (i = 0; i < size; i += PAGE_SIZE) {
|
|
|
|
paddr = base_paddr + i;
|
2009-01-10 00:13:11 +00:00
|
|
|
retval = reserve_pfn_range(paddr, PAGE_SIZE, *prot);
|
2008-12-18 19:41:30 +00:00
|
|
|
if (retval)
|
|
|
|
goto cleanup_ret;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup_ret:
|
|
|
|
/* Reserve error: Cleanup partial reservation and return error */
|
|
|
|
for (j = 0; j < i; j += PAGE_SIZE) {
|
|
|
|
paddr = base_paddr + j;
|
|
|
|
free_pfn_range(paddr, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* untrack_pfn_vma is called while unmapping a pfnmap for a region.
|
|
|
|
* untrack can be called for a specific region indicated by pfn and size or
|
|
|
|
* can be for the entire vma (in which case size can be zero).
|
|
|
|
*/
|
|
|
|
void untrack_pfn_vma(struct vm_area_struct *vma, unsigned long pfn,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
unsigned long i;
|
2008-12-23 18:10:40 +00:00
|
|
|
resource_size_t paddr;
|
2008-12-19 21:47:28 +00:00
|
|
|
unsigned long prot;
|
2008-12-18 19:41:30 +00:00
|
|
|
unsigned long vma_start = vma->vm_start;
|
|
|
|
unsigned long vma_end = vma->vm_end;
|
|
|
|
unsigned long vma_size = vma_end - vma_start;
|
|
|
|
|
|
|
|
if (!pat_enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (is_linear_pfn_mapping(vma)) {
|
|
|
|
/* free the whole chunk starting from vm_pgoff */
|
2008-12-23 18:10:40 +00:00
|
|
|
paddr = (resource_size_t)vma->vm_pgoff << PAGE_SHIFT;
|
2008-12-18 19:41:30 +00:00
|
|
|
free_pfn_range(paddr, vma_size);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (size != 0 && size != vma_size) {
|
|
|
|
/* free page by page, using pfn and size */
|
2008-12-23 18:10:40 +00:00
|
|
|
paddr = (resource_size_t)pfn << PAGE_SHIFT;
|
2008-12-18 19:41:30 +00:00
|
|
|
for (i = 0; i < size; i += PAGE_SIZE) {
|
|
|
|
paddr = paddr + i;
|
|
|
|
free_pfn_range(paddr, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* free entire vma, page by page, using the pfn from pte */
|
|
|
|
for (i = 0; i < vma_size; i += PAGE_SIZE) {
|
2008-12-19 21:47:28 +00:00
|
|
|
if (follow_phys(vma, vma_start + i, 0, &prot, &paddr))
|
2008-12-18 19:41:30 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
free_pfn_range(paddr, PAGE_SIZE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-12-18 19:41:32 +00:00
|
|
|
pgprot_t pgprot_writecombine(pgprot_t prot)
|
|
|
|
{
|
|
|
|
if (pat_enabled)
|
|
|
|
return __pgprot(pgprot_val(prot) | _PAGE_CACHE_WC);
|
|
|
|
else
|
|
|
|
return pgprot_noncached(prot);
|
|
|
|
}
|
|
|
|
|
2008-08-06 14:23:08 +00:00
|
|
|
#if defined(CONFIG_DEBUG_FS) && defined(CONFIG_X86_PAT)
|
2008-07-18 23:08:14 +00:00
|
|
|
|
|
|
|
/* get Nth element of the linked list */
|
|
|
|
static struct memtype *memtype_get_idx(loff_t pos)
|
|
|
|
{
|
|
|
|
struct memtype *list_node, *print_entry;
|
|
|
|
int i = 1;
|
|
|
|
|
|
|
|
print_entry = kmalloc(sizeof(struct memtype), GFP_KERNEL);
|
|
|
|
if (!print_entry)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
spin_lock(&memtype_lock);
|
|
|
|
list_for_each_entry(list_node, &memtype_list, nd) {
|
|
|
|
if (pos == i) {
|
|
|
|
*print_entry = *list_node;
|
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
return print_entry;
|
|
|
|
}
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
kfree(print_entry);
|
2008-09-30 11:20:45 +00:00
|
|
|
|
2008-07-18 23:08:14 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *memtype_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
|
|
|
if (*pos == 0) {
|
|
|
|
++*pos;
|
|
|
|
seq_printf(seq, "PAT memtype list:\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
return memtype_get_idx(*pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *memtype_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
++*pos;
|
|
|
|
return memtype_get_idx(*pos);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void memtype_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static int memtype_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct memtype *print_entry = (struct memtype *)v;
|
|
|
|
|
|
|
|
seq_printf(seq, "%s @ 0x%Lx-0x%Lx\n", cattr_name(print_entry->type),
|
|
|
|
print_entry->start, print_entry->end);
|
|
|
|
kfree(print_entry);
|
2008-09-30 11:20:45 +00:00
|
|
|
|
2008-07-18 23:08:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct seq_operations memtype_seq_ops = {
|
|
|
|
.start = memtype_seq_start,
|
|
|
|
.next = memtype_seq_next,
|
|
|
|
.stop = memtype_seq_stop,
|
|
|
|
.show = memtype_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int memtype_seq_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
return seq_open(file, &memtype_seq_ops);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations memtype_fops = {
|
|
|
|
.open = memtype_seq_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = seq_release,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init pat_memtype_list_init(void)
|
|
|
|
{
|
|
|
|
debugfs_create_file("pat_memtype_list", S_IRUSR, arch_debugfs_dir,
|
|
|
|
NULL, &memtype_fops);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(pat_memtype_list_init);
|
|
|
|
|
2008-08-06 14:23:08 +00:00
|
|
|
#endif /* CONFIG_DEBUG_FS && CONFIG_X86_PAT */
|