2008-03-18 20:00:14 -04: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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/gfp.h>
|
|
|
|
#include <linux/fs.h>
|
2008-03-18 20:00:21 -04:00
|
|
|
#include <linux/bootmem.h>
|
2008-03-18 20:00:14 -04:00
|
|
|
|
|
|
|
#include <asm/msr.h>
|
|
|
|
#include <asm/tlbflush.h>
|
|
|
|
#include <asm/processor.h>
|
2008-04-26 14:32:12 -04:00
|
|
|
#include <asm/page.h>
|
2008-03-18 20:00:14 -04:00
|
|
|
#include <asm/pgtable.h>
|
|
|
|
#include <asm/pat.h>
|
|
|
|
#include <asm/e820.h>
|
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#include <asm/fcntl.h>
|
|
|
|
#include <asm/mtrr.h>
|
2008-03-18 20:00:21 -04:00
|
|
|
#include <asm/io.h>
|
2008-03-18 20:00:14 -04:00
|
|
|
|
2008-05-08 03:18:43 -04:00
|
|
|
#ifdef CONFIG_X86_PAT
|
2008-06-10 10:06:21 -04:00
|
|
|
int __read_mostly pat_enabled = 1;
|
2008-03-18 20:00:14 -04:00
|
|
|
|
2008-05-14 05:20:32 -04:00
|
|
|
void __cpuinit pat_disable(char *reason)
|
2008-03-18 20:00:14 -04:00
|
|
|
{
|
2008-06-10 10:06:21 -04:00
|
|
|
pat_enabled = 0;
|
2008-05-08 03:18:43 -04:00
|
|
|
printk(KERN_INFO "%s\n", reason);
|
2008-03-18 20:00:14 -04:00
|
|
|
}
|
|
|
|
|
2008-05-29 03:01:28 -04:00
|
|
|
static int __init nopat(char *str)
|
2008-03-18 20:00:14 -04:00
|
|
|
{
|
2008-05-08 03:18:43 -04:00
|
|
|
pat_disable("PAT support disabled.");
|
2008-03-18 20:00:14 -04:00
|
|
|
return 0;
|
|
|
|
}
|
2008-05-08 03:18:43 -04:00
|
|
|
early_param("nopat", nopat);
|
|
|
|
#endif
|
|
|
|
|
2008-05-05 22:09:10 -04:00
|
|
|
|
|
|
|
static int debug_enable;
|
|
|
|
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 03:18:43 -04:00
|
|
|
static u64 __read_mostly boot_pat_state;
|
2008-03-18 20:00:14 -04: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 10:05:39 -04:00
|
|
|
#define PAT(x, y) ((u64)PAT_ ## y << ((x)*8))
|
2008-03-18 20:00:14 -04:00
|
|
|
|
|
|
|
void pat_init(void)
|
|
|
|
{
|
|
|
|
u64 pat;
|
|
|
|
|
2008-06-10 10:06:21 -04:00
|
|
|
if (!pat_enabled)
|
2008-03-18 20:00:14 -04:00
|
|
|
return;
|
|
|
|
|
2008-05-08 03:18:43 -04:00
|
|
|
/* Paranoia check. */
|
2008-06-10 10:05:18 -04:00
|
|
|
if (!cpu_has_pat && boot_pat_state) {
|
2008-05-08 03:18:43 -04:00
|
|
|
/*
|
2008-06-10 10:05:18 -04:00
|
|
|
* If this happens we are on a secondary CPU, but
|
2008-05-08 03:18:43 -04:00
|
|
|
* switched to PAT on the boot CPU. We have no way to
|
|
|
|
* undo PAT.
|
2008-06-10 10:05:18 -04:00
|
|
|
*/
|
|
|
|
printk(KERN_ERR "PAT enabled, "
|
|
|
|
"but not supported by secondary CPU\n");
|
|
|
|
BUG();
|
2008-05-08 03:18:43 -04:00
|
|
|
}
|
2008-03-18 20:00:14 -04: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 10:05:39 -04: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-18 20:00:14 -04:00
|
|
|
|
|
|
|
/* Boot CPU check */
|
2008-05-08 03:18:43 -04:00
|
|
|
if (!boot_pat_state)
|
2008-03-18 20:00:14 -04: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 10:05:39 -04: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-18 20:00:14 -04: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 {
|
|
|
|
u64 start;
|
|
|
|
u64 end;
|
|
|
|
unsigned long type;
|
|
|
|
struct list_head nd;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(memtype_list);
|
|
|
|
static DEFINE_SPINLOCK(memtype_lock); /* protects memtype list */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 13:42:43 -04:00
|
|
|
static unsigned long pat_x_mtrr_type(u64 start, u64 end, unsigned long req_type)
|
2008-03-18 20:00:14 -04: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 15:01:44 -04:00
|
|
|
/*
|
|
|
|
* Look for MTRR hint to get the effective type in case where PAT
|
|
|
|
* request is for WB.
|
|
|
|
*/
|
2008-06-18 09:38:57 -04: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-18 20:00:14 -04:00
|
|
|
}
|
|
|
|
|
2008-03-18 20:00:21 -04: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 16:01:49 -04: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-18 20:00:21 -04:00
|
|
|
* it will return a negative return value.
|
|
|
|
*/
|
2008-03-18 20:00:14 -04:00
|
|
|
int reserve_memtype(u64 start, u64 end, unsigned long req_type,
|
2008-06-20 16:01:49 -04:00
|
|
|
unsigned long *new_type)
|
2008-03-18 20:00:14 -04:00
|
|
|
{
|
2008-06-20 16:01:49 -04:00
|
|
|
struct memtype *new, *entry;
|
2008-03-18 20:00:14 -04:00
|
|
|
unsigned long actual_type;
|
|
|
|
int err = 0;
|
|
|
|
|
2008-06-20 16:03:06 -04:00
|
|
|
BUG_ON(start >= end); /* end is exclusive */
|
|
|
|
|
2008-06-10 10:06:21 -04:00
|
|
|
if (!pat_enabled) {
|
2008-03-18 20:00:21 -04:00
|
|
|
/* This is identical to page table setting without PAT */
|
2008-06-20 16:01:49 -04:00
|
|
|
if (new_type) {
|
|
|
|
if (req_type == -1)
|
|
|
|
*new_type = _PAGE_CACHE_WB;
|
|
|
|
else
|
|
|
|
*new_type = req_type & _PAGE_CACHE_MASK;
|
2008-03-18 20:00:21 -04:00
|
|
|
}
|
2008-03-18 20:00:14 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Low ISA region is always mapped WB in page table. No need to track */
|
2008-06-20 15:58:46 -04:00
|
|
|
if (is_ISA_range(start, end - 1)) {
|
2008-06-20 16:01:49 -04:00
|
|
|
if (new_type)
|
|
|
|
*new_type = _PAGE_CACHE_WB;
|
2008-03-18 20:00:14 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-03-18 20:00:21 -04: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 15:01:44 -04: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-18 20:00:21 -04:00
|
|
|
*/
|
|
|
|
u8 mtrr_type = mtrr_type_lookup(start, end);
|
|
|
|
|
2008-06-20 16:03:06 -04:00
|
|
|
if (mtrr_type == MTRR_TYPE_WRBACK)
|
2008-03-18 20:00:21 -04:00
|
|
|
actual_type = _PAGE_CACHE_WB;
|
2008-06-20 16:03:06 -04:00
|
|
|
else
|
2008-03-18 20:00:21 -04:00
|
|
|
actual_type = _PAGE_CACHE_UC_MINUS;
|
2008-06-20 16:03:06 -04:00
|
|
|
} else
|
|
|
|
actual_type = pat_x_mtrr_type(start, end,
|
|
|
|
req_type & _PAGE_CACHE_MASK);
|
2008-03-18 20:00:14 -04:00
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
new = kmalloc(sizeof(struct memtype), GFP_KERNEL);
|
|
|
|
if (!new)
|
2008-03-18 20:00:14 -04:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
new->start = start;
|
|
|
|
new->end = end;
|
|
|
|
new->type = actual_type;
|
2008-03-18 20:00:14 -04:00
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (new_type)
|
|
|
|
*new_type = actual_type;
|
2008-03-18 20:00:14 -04:00
|
|
|
|
|
|
|
spin_lock(&memtype_lock);
|
|
|
|
|
|
|
|
/* Search for existing mapping that overlaps the current range */
|
2008-06-20 16:01:49 -04:00
|
|
|
list_for_each_entry(entry, &memtype_list, nd) {
|
2008-03-18 20:00:14 -04:00
|
|
|
struct memtype *saved_ptr;
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (entry->start >= end) {
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk("New Entry\n");
|
2008-06-20 16:01:49 -04:00
|
|
|
list_add(&new->nd, entry->nd.prev);
|
|
|
|
new = NULL;
|
2008-03-18 20:00:14 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (start <= entry->start && end >= entry->start) {
|
|
|
|
if (actual_type != entry->type && new_type) {
|
|
|
|
actual_type = entry->type;
|
|
|
|
*new_type = actual_type;
|
|
|
|
new->type = actual_type;
|
2008-03-18 20:00:14 -04:00
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (actual_type != entry->type) {
|
2008-03-18 20:00:14 -04:00
|
|
|
printk(
|
|
|
|
KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
start, end,
|
|
|
|
cattr_name(actual_type),
|
2008-06-20 16:01:49 -04:00
|
|
|
cattr_name(entry->type));
|
2008-03-18 20:00:14 -04:00
|
|
|
err = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
saved_ptr = entry;
|
2008-03-18 20:00:14 -04:00
|
|
|
/*
|
|
|
|
* Check to see whether the request overlaps more
|
|
|
|
* than one entry in the list
|
|
|
|
*/
|
2008-06-20 16:01:49 -04:00
|
|
|
list_for_each_entry_continue(entry, &memtype_list, nd) {
|
|
|
|
if (end <= entry->start) {
|
2008-03-18 20:00:14 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (actual_type != entry->type) {
|
2008-03-18 20:00:14 -04:00
|
|
|
printk(
|
|
|
|
KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
start, end,
|
|
|
|
cattr_name(actual_type),
|
2008-06-20 16:01:49 -04:00
|
|
|
cattr_name(entry->type));
|
2008-03-18 20:00:14 -04:00
|
|
|
err = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk("Overlap at 0x%Lx-0x%Lx\n",
|
2008-03-18 20:00:25 -04:00
|
|
|
saved_ptr->start, saved_ptr->end);
|
2008-03-18 20:00:14 -04:00
|
|
|
/* No conflict. Go ahead and add this new entry */
|
2008-06-20 16:01:49 -04:00
|
|
|
list_add(&new->nd, saved_ptr->nd.prev);
|
|
|
|
new = NULL;
|
2008-03-18 20:00:14 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (start < entry->end) {
|
|
|
|
if (actual_type != entry->type && new_type) {
|
|
|
|
actual_type = entry->type;
|
|
|
|
*new_type = actual_type;
|
|
|
|
new->type = actual_type;
|
2008-03-18 20:00:14 -04:00
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (actual_type != entry->type) {
|
2008-03-18 20:00:14 -04:00
|
|
|
printk(
|
|
|
|
KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
start, end,
|
|
|
|
cattr_name(actual_type),
|
2008-06-20 16:01:49 -04:00
|
|
|
cattr_name(entry->type));
|
2008-03-18 20:00:14 -04:00
|
|
|
err = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
saved_ptr = entry;
|
2008-03-18 20:00:14 -04:00
|
|
|
/*
|
|
|
|
* Check to see whether the request overlaps more
|
|
|
|
* than one entry in the list
|
|
|
|
*/
|
2008-06-20 16:01:49 -04:00
|
|
|
list_for_each_entry_continue(entry, &memtype_list, nd) {
|
|
|
|
if (end <= entry->start) {
|
2008-03-18 20:00:14 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (actual_type != entry->type) {
|
2008-03-18 20:00:14 -04:00
|
|
|
printk(
|
|
|
|
KERN_INFO "%s:%d conflicting memory types %Lx-%Lx %s<->%s\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
start, end,
|
|
|
|
cattr_name(actual_type),
|
2008-06-20 16:01:49 -04:00
|
|
|
cattr_name(entry->type));
|
2008-03-18 20:00:14 -04:00
|
|
|
err = -EBUSY;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk("Overlap at 0x%Lx-0x%Lx\n",
|
2008-04-27 14:59:30 -04:00
|
|
|
saved_ptr->start, saved_ptr->end);
|
2008-03-18 20:00:14 -04:00
|
|
|
/* No conflict. Go ahead and add this new entry */
|
2008-06-20 16:01:49 -04:00
|
|
|
list_add(&new->nd, &saved_ptr->nd);
|
|
|
|
new = NULL;
|
2008-03-18 20:00:14 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err) {
|
2008-04-03 04:14:33 -04:00
|
|
|
printk(KERN_INFO
|
2008-03-18 20:00:25 -04:00
|
|
|
"reserve_memtype failed 0x%Lx-0x%Lx, track %s, req %s\n",
|
2008-06-20 16:01:49 -04:00
|
|
|
start, end, cattr_name(new->type),
|
2008-03-18 20:00:25 -04:00
|
|
|
cattr_name(req_type));
|
2008-06-20 16:01:49 -04:00
|
|
|
kfree(new);
|
2008-03-18 20:00:14 -04:00
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (new) {
|
2008-03-18 20:00:14 -04:00
|
|
|
/* No conflict. Not yet added to the list. Add to the tail */
|
2008-06-20 16:01:49 -04:00
|
|
|
list_add_tail(&new->nd, &memtype_list);
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk("New Entry\n");
|
2008-04-03 04:14:33 -04:00
|
|
|
}
|
2008-03-18 20:00:25 -04:00
|
|
|
|
2008-06-20 16:01:49 -04:00
|
|
|
if (new_type) {
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk(
|
2008-03-18 20:00:25 -04:00
|
|
|
"reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s, ret %s\n",
|
|
|
|
start, end, cattr_name(actual_type),
|
2008-06-20 16:01:49 -04:00
|
|
|
cattr_name(req_type), cattr_name(*new_type));
|
2008-03-18 20:00:25 -04:00
|
|
|
} else {
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk(
|
2008-03-18 20:00:25 -04:00
|
|
|
"reserve_memtype added 0x%Lx-0x%Lx, track %s, req %s\n",
|
|
|
|
start, end, cattr_name(actual_type),
|
|
|
|
cattr_name(req_type));
|
2008-03-18 20:00:14 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int free_memtype(u64 start, u64 end)
|
|
|
|
{
|
2008-06-20 16:01:49 -04:00
|
|
|
struct memtype *entry;
|
2008-03-18 20:00:14 -04:00
|
|
|
int err = -EINVAL;
|
|
|
|
|
2008-06-20 16:03:06 -04:00
|
|
|
if (!pat_enabled)
|
2008-03-18 20:00:14 -04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Low ISA region is always mapped WB. No need to track */
|
2008-06-20 15:58:46 -04:00
|
|
|
if (is_ISA_range(start, end - 1))
|
2008-03-18 20:00:14 -04:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock(&memtype_lock);
|
2008-06-20 16:01:49 -04:00
|
|
|
list_for_each_entry(entry, &memtype_list, nd) {
|
|
|
|
if (entry->start == start && entry->end == end) {
|
|
|
|
list_del(&entry->nd);
|
|
|
|
kfree(entry);
|
2008-03-18 20:00:14 -04:00
|
|
|
err = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock(&memtype_lock);
|
|
|
|
|
|
|
|
if (err) {
|
2008-04-03 04:14:33 -04:00
|
|
|
printk(KERN_INFO "%s:%d freeing invalid memtype %Lx-%Lx\n",
|
2008-03-18 20:00:14 -04:00
|
|
|
current->comm, current->pid, start, end);
|
|
|
|
}
|
2008-03-18 20:00:25 -04:00
|
|
|
|
2008-05-05 22:09:10 -04:00
|
|
|
dprintk("free_memtype request 0x%Lx-0x%Lx\n", start, end);
|
2008-03-18 20:00:14 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2008-03-18 20:00:20 -04:00
|
|
|
|
2008-03-18 20:00:21 -04:00
|
|
|
/*
|
|
|
|
* /dev/mem mmap interface. The memtype used for mapping varies:
|
|
|
|
* - Use UC for mappings with O_SYNC flag
|
|
|
|
* - Without O_SYNC flag, if there is any conflict in reserve_memtype,
|
|
|
|
* inherit the memtype from existing mapping.
|
|
|
|
* - Else use UC_MINUS memtype (for backward compatibility with existing
|
|
|
|
* X drivers.
|
|
|
|
*/
|
2008-03-18 20:00:20 -04:00
|
|
|
pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
|
|
|
|
unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
return vma_prot;
|
|
|
|
}
|
|
|
|
|
2008-04-26 14:32:12 -04:00
|
|
|
#ifdef CONFIG_NONPROMISC_DEVMEM
|
|
|
|
/* This check is done in drivers/char/mem.c in case of NONPROMISC_DEVMEM*/
|
|
|
|
static inline int range_is_allowed(unsigned long pfn, unsigned long size)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
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;
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_NONPROMISC_DEVMEM */
|
|
|
|
|
2008-03-18 20:00:20 -04:00
|
|
|
int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
|
|
|
|
unsigned long size, pgprot_t *vma_prot)
|
|
|
|
{
|
2008-03-18 20:00:21 -04:00
|
|
|
u64 offset = ((u64) pfn) << PAGE_SHIFT;
|
|
|
|
unsigned long flags = _PAGE_CACHE_UC_MINUS;
|
|
|
|
int retval;
|
2008-03-18 20:00:20 -04:00
|
|
|
|
2008-04-26 14:32:12 -04:00
|
|
|
if (!range_is_allowed(pfn, size))
|
|
|
|
return 0;
|
|
|
|
|
2008-03-18 20:00:20 -04:00
|
|
|
if (file->f_flags & O_SYNC) {
|
2008-03-18 20:00:21 -04:00
|
|
|
flags = _PAGE_CACHE_UC;
|
2008-03-18 20:00:20 -04: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 10:06:21 -04:00
|
|
|
if (!pat_enabled &&
|
2008-06-10 10:05:39 -04: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-18 20:00:21 -04:00
|
|
|
flags = _PAGE_CACHE_UC;
|
2008-03-18 20:00:20 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-03-18 20:00:21 -04:00
|
|
|
/*
|
|
|
|
* With O_SYNC, we can only take UC mapping. Fail if we cannot.
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
if (flags != _PAGE_CACHE_UC_MINUS) {
|
|
|
|
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 10:42:28 -04:00
|
|
|
retval = reserve_memtype(offset, offset + size, -1, &flags);
|
2008-03-18 20:00:21 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
if (retval < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (pfn <= max_pfn_mapped &&
|
2008-06-10 10:05:39 -04:00
|
|
|
ioremap_change_attr((unsigned long)__va(offset), size, flags) < 0) {
|
2008-03-18 20:00:21 -04:00
|
|
|
free_memtype(offset, offset + size);
|
2008-04-03 04:14:33 -04:00
|
|
|
printk(KERN_INFO
|
2008-03-18 20:00:21 -04:00
|
|
|
"%s:%d /dev/mem ioremap_change_attr failed %s for %Lx-%Lx\n",
|
|
|
|
current->comm, current->pid,
|
|
|
|
cattr_name(flags),
|
2008-05-12 05:22:26 -04:00
|
|
|
offset, (unsigned long long)(offset + size));
|
2008-03-18 20:00:21 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
*vma_prot = __pgprot((pgprot_val(*vma_prot) & ~_PAGE_CACHE_MASK) |
|
|
|
|
flags);
|
2008-03-18 20:00:20 -04:00
|
|
|
return 1;
|
|
|
|
}
|
2008-03-18 20:00:21 -04:00
|
|
|
|
|
|
|
void map_devmem(unsigned long pfn, unsigned long size, pgprot_t vma_prot)
|
|
|
|
{
|
|
|
|
u64 addr = (u64)pfn << PAGE_SHIFT;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned long want_flags = (pgprot_val(vma_prot) & _PAGE_CACHE_MASK);
|
|
|
|
|
|
|
|
reserve_memtype(addr, addr + size, want_flags, &flags);
|
|
|
|
if (flags != want_flags) {
|
2008-04-03 04:14:33 -04:00
|
|
|
printk(KERN_INFO
|
2008-03-18 20:00:21 -04: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 05:22:26 -04:00
|
|
|
addr, (unsigned long long)(addr + size),
|
2008-03-18 20:00:21 -04: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);
|
|
|
|
}
|