2019-05-19 19:08:55 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Re-map IO memory to kernel address space so that we can access it.
|
|
|
|
* This is needed for high PCI addresses that aren't mapped in the
|
|
|
|
* 640k-1MB IO memory area on PC's
|
|
|
|
*
|
|
|
|
* (C) Copyright 1995 1996 Linus Torvalds
|
|
|
|
*/
|
|
|
|
|
2018-10-31 05:09:49 +07:00
|
|
|
#include <linux/memblock.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/init.h>
|
2006-10-01 13:29:17 +07:00
|
|
|
#include <linux/io.h>
|
2017-01-27 19:08:42 +07:00
|
|
|
#include <linux/ioport.h>
|
2008-01-30 19:34:05 +07:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/vmalloc.h>
|
2008-05-13 02:20:57 +07:00
|
|
|
#include <linux/mmiotrace.h>
|
2017-07-18 04:10:16 +07:00
|
|
|
#include <linux/mem_encrypt.h>
|
|
|
|
#include <linux/efi.h>
|
2008-01-30 19:34:05 +07:00
|
|
|
|
2017-05-09 05:58:11 +07:00
|
|
|
#include <asm/set_memory.h>
|
2017-01-27 16:27:10 +07:00
|
|
|
#include <asm/e820/api.h>
|
2019-06-25 20:36:45 +07:00
|
|
|
#include <asm/efi.h>
|
2008-01-30 19:34:05 +07:00
|
|
|
#include <asm/fixmap.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <asm/pgtable.h>
|
2008-01-30 19:34:05 +07:00
|
|
|
#include <asm/tlbflush.h>
|
2008-01-30 19:34:11 +07:00
|
|
|
#include <asm/pgalloc.h>
|
2008-03-19 07:00:17 +07:00
|
|
|
#include <asm/pat.h>
|
2017-07-18 04:10:16 +07:00
|
|
|
#include <asm/setup.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-09-11 00:09:38 +07:00
|
|
|
#include "physaddr.h"
|
2008-01-30 19:34:05 +07:00
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
/*
|
|
|
|
* Descriptor controlling ioremap() behavior.
|
|
|
|
*/
|
|
|
|
struct ioremap_desc {
|
|
|
|
unsigned int flags;
|
2017-10-20 21:30:52 +07:00
|
|
|
};
|
|
|
|
|
2008-01-30 19:34:05 +07:00
|
|
|
/*
|
|
|
|
* Fix up the linear direct mapping of the kernel to avoid cache attribute
|
|
|
|
* conflicts.
|
|
|
|
*/
|
2008-03-19 07:00:16 +07:00
|
|
|
int ioremap_change_attr(unsigned long vaddr, unsigned long size,
|
2014-11-03 20:01:58 +07:00
|
|
|
enum page_cache_mode pcm)
|
2008-01-30 19:34:05 +07:00
|
|
|
{
|
2008-01-30 19:34:06 +07:00
|
|
|
unsigned long nrpages = size >> PAGE_SHIFT;
|
2008-02-01 23:49:43 +07:00
|
|
|
int err;
|
2008-01-30 19:34:05 +07:00
|
|
|
|
2014-11-03 20:01:58 +07:00
|
|
|
switch (pcm) {
|
|
|
|
case _PAGE_CACHE_MODE_UC:
|
2008-01-30 19:34:06 +07:00
|
|
|
default:
|
2008-03-19 07:00:18 +07:00
|
|
|
err = _set_memory_uc(vaddr, nrpages);
|
2008-01-30 19:34:06 +07:00
|
|
|
break;
|
2014-11-03 20:01:58 +07:00
|
|
|
case _PAGE_CACHE_MODE_WC:
|
2008-03-19 07:00:24 +07:00
|
|
|
err = _set_memory_wc(vaddr, nrpages);
|
|
|
|
break;
|
2015-06-04 23:55:20 +07:00
|
|
|
case _PAGE_CACHE_MODE_WT:
|
|
|
|
err = _set_memory_wt(vaddr, nrpages);
|
|
|
|
break;
|
2014-11-03 20:01:58 +07:00
|
|
|
case _PAGE_CACHE_MODE_WB:
|
2008-03-19 07:00:18 +07:00
|
|
|
err = _set_memory_wb(vaddr, nrpages);
|
2008-01-30 19:34:06 +07:00
|
|
|
break;
|
|
|
|
}
|
2008-01-30 19:34:05 +07:00
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
/* Does the range (or a subset of) contain normal RAM? */
|
|
|
|
static unsigned int __ioremap_check_ram(struct resource *res)
|
x86, ioremap: Speed up check for RAM pages
In __ioremap_caller() (the guts of ioremap), we loop over the range of
pfns being remapped and checks each one individually with page_is_ram().
For large ioremaps, this can be very slow. For example, we have a
device with a 256 GiB PCI BAR, and ioremapping this BAR can take 20+
seconds -- sometimes long enough to trigger the soft lockup detector!
Internally, page_is_ram() calls walk_system_ram_range() on a single
page. Instead, we can make a single call to walk_system_ram_range()
from __ioremap_caller(), and do our further checks only for any RAM
pages that we find. For the common case of MMIO, this saves an enormous
amount of work, since the range being ioremapped doesn't intersect
system RAM at all.
With this change, ioremap on our 256 GiB BAR takes less than 1 second.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Link: http://lkml.kernel.org/r/1399054721-1331-1-git-send-email-roland@kernel.org
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-03 01:18:41 +07:00
|
|
|
{
|
2017-10-20 21:30:52 +07:00
|
|
|
unsigned long start_pfn, stop_pfn;
|
x86, ioremap: Speed up check for RAM pages
In __ioremap_caller() (the guts of ioremap), we loop over the range of
pfns being remapped and checks each one individually with page_is_ram().
For large ioremaps, this can be very slow. For example, we have a
device with a 256 GiB PCI BAR, and ioremapping this BAR can take 20+
seconds -- sometimes long enough to trigger the soft lockup detector!
Internally, page_is_ram() calls walk_system_ram_range() on a single
page. Instead, we can make a single call to walk_system_ram_range()
from __ioremap_caller(), and do our further checks only for any RAM
pages that we find. For the common case of MMIO, this saves an enormous
amount of work, since the range being ioremapped doesn't intersect
system RAM at all.
With this change, ioremap on our 256 GiB BAR takes less than 1 second.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Link: http://lkml.kernel.org/r/1399054721-1331-1-git-send-email-roland@kernel.org
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-03 01:18:41 +07:00
|
|
|
unsigned long i;
|
|
|
|
|
2017-10-20 21:30:52 +07:00
|
|
|
if ((res->flags & IORESOURCE_SYSTEM_RAM) != IORESOURCE_SYSTEM_RAM)
|
2019-04-23 08:30:06 +07:00
|
|
|
return 0;
|
2017-10-20 21:30:52 +07:00
|
|
|
|
|
|
|
start_pfn = (res->start + PAGE_SIZE - 1) >> PAGE_SHIFT;
|
|
|
|
stop_pfn = (res->end + 1) >> PAGE_SHIFT;
|
|
|
|
if (stop_pfn > start_pfn) {
|
|
|
|
for (i = 0; i < (stop_pfn - start_pfn); ++i)
|
|
|
|
if (pfn_valid(start_pfn + i) &&
|
|
|
|
!PageReserved(pfn_to_page(start_pfn + i)))
|
2019-04-23 08:30:06 +07:00
|
|
|
return IORES_MAP_SYSTEM_RAM;
|
2017-10-20 21:30:52 +07:00
|
|
|
}
|
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
return 0;
|
2017-10-20 21:30:52 +07:00
|
|
|
}
|
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
/*
|
|
|
|
* In a SEV guest, NONE and RESERVED should not be mapped encrypted because
|
|
|
|
* there the whole memory is already encrypted.
|
|
|
|
*/
|
|
|
|
static unsigned int __ioremap_check_encrypted(struct resource *res)
|
2017-10-20 21:30:52 +07:00
|
|
|
{
|
2019-04-23 08:30:06 +07:00
|
|
|
if (!sev_active())
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (res->desc) {
|
|
|
|
case IORES_DESC_NONE:
|
|
|
|
case IORES_DESC_RESERVED:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return IORES_MAP_ENCRYPTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2017-10-20 21:30:52 +07:00
|
|
|
}
|
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
static int __ioremap_collect_map_flags(struct resource *res, void *arg)
|
2017-10-20 21:30:52 +07:00
|
|
|
{
|
2019-04-23 08:30:06 +07:00
|
|
|
struct ioremap_desc *desc = arg;
|
2017-10-20 21:30:52 +07:00
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
if (!(desc->flags & IORES_MAP_SYSTEM_RAM))
|
|
|
|
desc->flags |= __ioremap_check_ram(res);
|
2017-10-20 21:30:52 +07:00
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
if (!(desc->flags & IORES_MAP_ENCRYPTED))
|
|
|
|
desc->flags |= __ioremap_check_encrypted(res);
|
x86, ioremap: Speed up check for RAM pages
In __ioremap_caller() (the guts of ioremap), we loop over the range of
pfns being remapped and checks each one individually with page_is_ram().
For large ioremaps, this can be very slow. For example, we have a
device with a 256 GiB PCI BAR, and ioremapping this BAR can take 20+
seconds -- sometimes long enough to trigger the soft lockup detector!
Internally, page_is_ram() calls walk_system_ram_range() on a single
page. Instead, we can make a single call to walk_system_ram_range()
from __ioremap_caller(), and do our further checks only for any RAM
pages that we find. For the common case of MMIO, this saves an enormous
amount of work, since the range being ioremapped doesn't intersect
system RAM at all.
With this change, ioremap on our 256 GiB BAR takes less than 1 second.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Link: http://lkml.kernel.org/r/1399054721-1331-1-git-send-email-roland@kernel.org
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-03 01:18:41 +07:00
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
return ((desc->flags & (IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED)) ==
|
|
|
|
(IORES_MAP_SYSTEM_RAM | IORES_MAP_ENCRYPTED));
|
2017-10-20 21:30:52 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* To avoid multiple resource walks, this function walks resources marked as
|
|
|
|
* IORESOURCE_MEM and IORESOURCE_BUSY and looking for system RAM and/or a
|
|
|
|
* resource described not as IORES_DESC_NONE (e.g. IORES_DESC_ACPI_TABLES).
|
|
|
|
*/
|
|
|
|
static void __ioremap_check_mem(resource_size_t addr, unsigned long size,
|
2019-04-23 08:30:06 +07:00
|
|
|
struct ioremap_desc *desc)
|
2017-10-20 21:30:52 +07:00
|
|
|
{
|
|
|
|
u64 start, end;
|
|
|
|
|
|
|
|
start = (u64)addr;
|
|
|
|
end = start + size - 1;
|
2019-04-23 08:30:06 +07:00
|
|
|
memset(desc, 0, sizeof(struct ioremap_desc));
|
2017-10-20 21:30:52 +07:00
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
walk_mem_res(start, end, desc, __ioremap_collect_map_flags);
|
x86, ioremap: Speed up check for RAM pages
In __ioremap_caller() (the guts of ioremap), we loop over the range of
pfns being remapped and checks each one individually with page_is_ram().
For large ioremaps, this can be very slow. For example, we have a
device with a 256 GiB PCI BAR, and ioremapping this BAR can take 20+
seconds -- sometimes long enough to trigger the soft lockup detector!
Internally, page_is_ram() calls walk_system_ram_range() on a single
page. Instead, we can make a single call to walk_system_ram_range()
from __ioremap_caller(), and do our further checks only for any RAM
pages that we find. For the common case of MMIO, this saves an enormous
amount of work, since the range being ioremapped doesn't intersect
system RAM at all.
With this change, ioremap on our 256 GiB BAR takes less than 1 second.
Signed-off-by: Roland Dreier <roland@purestorage.com>
Link: http://lkml.kernel.org/r/1399054721-1331-1-git-send-email-roland@kernel.org
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
2014-05-03 01:18:41 +07:00
|
|
|
}
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Remap an arbitrary physical address space into the kernel virtual
|
2015-04-15 05:47:29 +07:00
|
|
|
* address space. It transparently creates kernel huge I/O mapping when
|
|
|
|
* the physical address is aligned by a huge page size (1GB or 2MB) and
|
|
|
|
* the requested size is at least the huge page size.
|
|
|
|
*
|
|
|
|
* NOTE: MTRRs can override PAT memory types with a 4KB granularity.
|
|
|
|
* Therefore, the mapping code falls back to use a smaller page toward 4KB
|
|
|
|
* when a mapping range is covered by non-WB type of MTRRs.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* NOTE! We need to allow non-page-aligned mappings too: we will obviously
|
|
|
|
* have to convert them into an offset in a page-aligned mapping, but the
|
|
|
|
* caller shouldn't need to know that small detail.
|
|
|
|
*/
|
2019-04-23 08:30:06 +07:00
|
|
|
static void __iomem *
|
|
|
|
__ioremap_caller(resource_size_t phys_addr, unsigned long size,
|
|
|
|
enum page_cache_mode pcm, void *caller, bool encrypted)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2010-06-18 10:22:40 +07:00
|
|
|
unsigned long offset, vaddr;
|
2017-10-20 21:30:52 +07:00
|
|
|
resource_size_t last_addr;
|
2008-05-13 02:21:03 +07:00
|
|
|
const resource_size_t unaligned_phys_addr = phys_addr;
|
|
|
|
const unsigned long unaligned_size = size;
|
2019-04-23 08:30:06 +07:00
|
|
|
struct ioremap_desc io_desc;
|
2008-01-30 19:34:05 +07:00
|
|
|
struct vm_struct *area;
|
2014-11-03 20:01:58 +07:00
|
|
|
enum page_cache_mode new_pcm;
|
2008-01-30 19:34:06 +07:00
|
|
|
pgprot_t prot;
|
2008-03-25 04:39:55 +07:00
|
|
|
int retval;
|
2008-05-13 02:20:57 +07:00
|
|
|
void __iomem *ret_addr;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* Don't allow wraparound or zero size */
|
|
|
|
last_addr = phys_addr + size - 1;
|
|
|
|
if (!size || last_addr < phys_addr)
|
|
|
|
return NULL;
|
|
|
|
|
2008-02-28 02:57:40 +07:00
|
|
|
if (!phys_addr_valid(phys_addr)) {
|
2008-03-19 07:00:25 +07:00
|
|
|
printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
|
2008-04-11 05:09:50 +07:00
|
|
|
(unsigned long long)phys_addr);
|
2008-02-28 02:57:40 +07:00
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-04-23 08:30:06 +07:00
|
|
|
__ioremap_check_mem(phys_addr, size, &io_desc);
|
2017-10-20 21:30:52 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Don't allow anybody to remap normal RAM that we're using..
|
|
|
|
*/
|
2019-04-23 08:30:06 +07:00
|
|
|
if (io_desc.flags & IORES_MAP_SYSTEM_RAM) {
|
2015-07-24 21:13:43 +07:00
|
|
|
WARN_ONCE(1, "ioremap on RAM at %pa - %pa\n",
|
|
|
|
&phys_addr, &last_addr);
|
2015-07-17 06:23:15 +07:00
|
|
|
return NULL;
|
2014-10-14 05:54:05 +07:00
|
|
|
}
|
2015-07-17 06:23:15 +07:00
|
|
|
|
2008-03-19 07:00:17 +07:00
|
|
|
/*
|
|
|
|
* Mappings have to be page-aligned
|
|
|
|
*/
|
|
|
|
offset = phys_addr & ~PAGE_MASK;
|
2010-06-18 10:22:40 +07:00
|
|
|
phys_addr &= PHYSICAL_PAGE_MASK;
|
2008-03-19 07:00:17 +07:00
|
|
|
size = PAGE_ALIGN(last_addr+1) - phys_addr;
|
|
|
|
|
2008-08-15 23:12:47 +07:00
|
|
|
retval = reserve_memtype(phys_addr, (u64)phys_addr + size,
|
2014-11-03 20:01:59 +07:00
|
|
|
pcm, &new_pcm);
|
2008-03-25 04:39:55 +07:00
|
|
|
if (retval) {
|
2009-07-10 23:57:33 +07:00
|
|
|
printk(KERN_ERR "ioremap reserve_memtype failed %d\n", retval);
|
2008-03-25 04:39:55 +07:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-11-03 20:01:58 +07:00
|
|
|
if (pcm != new_pcm) {
|
|
|
|
if (!is_new_memtype_allowed(phys_addr, size, pcm, new_pcm)) {
|
2009-07-10 23:57:33 +07:00
|
|
|
printk(KERN_ERR
|
2014-11-03 20:01:58 +07:00
|
|
|
"ioremap error for 0x%llx-0x%llx, requested 0x%x, got 0x%x\n",
|
2008-04-11 05:09:50 +07:00
|
|
|
(unsigned long long)phys_addr,
|
|
|
|
(unsigned long long)(phys_addr + size),
|
2014-11-03 20:01:58 +07:00
|
|
|
pcm, new_pcm);
|
2009-11-05 09:43:51 +07:00
|
|
|
goto err_free_memtype;
|
2008-03-19 07:00:17 +07:00
|
|
|
}
|
2014-11-03 20:01:58 +07:00
|
|
|
pcm = new_pcm;
|
2008-03-19 07:00:17 +07:00
|
|
|
}
|
|
|
|
|
2017-10-20 21:30:52 +07:00
|
|
|
/*
|
|
|
|
* If the page being mapped is in memory and SEV is active then
|
|
|
|
* make sure the memory encryption attribute is enabled in the
|
|
|
|
* resulting mapping.
|
|
|
|
*/
|
2014-11-03 20:01:58 +07:00
|
|
|
prot = PAGE_KERNEL_IO;
|
2019-04-23 08:30:06 +07:00
|
|
|
if ((io_desc.flags & IORES_MAP_ENCRYPTED) || encrypted)
|
2017-10-20 21:30:52 +07:00
|
|
|
prot = pgprot_encrypted(prot);
|
|
|
|
|
2014-11-03 20:01:58 +07:00
|
|
|
switch (pcm) {
|
|
|
|
case _PAGE_CACHE_MODE_UC:
|
2008-01-30 19:34:06 +07:00
|
|
|
default:
|
2014-11-03 20:01:58 +07:00
|
|
|
prot = __pgprot(pgprot_val(prot) |
|
|
|
|
cachemode2protval(_PAGE_CACHE_MODE_UC));
|
2008-01-30 19:34:06 +07:00
|
|
|
break;
|
2014-11-03 20:01:58 +07:00
|
|
|
case _PAGE_CACHE_MODE_UC_MINUS:
|
|
|
|
prot = __pgprot(pgprot_val(prot) |
|
|
|
|
cachemode2protval(_PAGE_CACHE_MODE_UC_MINUS));
|
2008-04-26 07:07:22 +07:00
|
|
|
break;
|
2014-11-03 20:01:58 +07:00
|
|
|
case _PAGE_CACHE_MODE_WC:
|
|
|
|
prot = __pgprot(pgprot_val(prot) |
|
|
|
|
cachemode2protval(_PAGE_CACHE_MODE_WC));
|
2008-03-19 07:00:24 +07:00
|
|
|
break;
|
2015-06-04 23:55:15 +07:00
|
|
|
case _PAGE_CACHE_MODE_WT:
|
|
|
|
prot = __pgprot(pgprot_val(prot) |
|
|
|
|
cachemode2protval(_PAGE_CACHE_MODE_WT));
|
|
|
|
break;
|
2014-11-03 20:01:58 +07:00
|
|
|
case _PAGE_CACHE_MODE_WB:
|
2008-01-30 19:34:06 +07:00
|
|
|
break;
|
|
|
|
}
|
2006-10-01 13:29:17 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* Ok, go for it..
|
|
|
|
*/
|
2008-04-28 16:12:42 +07:00
|
|
|
area = get_vm_area_caller(size, VM_IOREMAP, caller);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!area)
|
2009-11-05 09:43:51 +07:00
|
|
|
goto err_free_memtype;
|
2005-04-17 05:20:36 +07:00
|
|
|
area->phys_addr = phys_addr;
|
2008-02-04 22:48:05 +07:00
|
|
|
vaddr = (unsigned long) area->addr;
|
2009-04-10 04:26:47 +07:00
|
|
|
|
2014-11-03 20:01:58 +07:00
|
|
|
if (kernel_map_sync_memtype(phys_addr, size, pcm))
|
2009-11-05 09:43:51 +07:00
|
|
|
goto err_free_area;
|
2008-01-30 19:34:05 +07:00
|
|
|
|
2009-11-05 09:43:51 +07:00
|
|
|
if (ioremap_page_range(vaddr, vaddr + size, phys_addr, prot))
|
|
|
|
goto err_free_area;
|
2008-01-30 19:34:05 +07:00
|
|
|
|
2008-05-13 02:20:57 +07:00
|
|
|
ret_addr = (void __iomem *) (vaddr + offset);
|
2008-05-13 02:21:03 +07:00
|
|
|
mmiotrace_ioremap(unaligned_phys_addr, unaligned_size, ret_addr);
|
2008-05-13 02:20:57 +07:00
|
|
|
|
2011-04-29 00:00:30 +07:00
|
|
|
/*
|
|
|
|
* Check if the request spans more than any BAR in the iomem resource
|
|
|
|
* tree.
|
|
|
|
*/
|
2015-12-22 03:01:14 +07:00
|
|
|
if (iomem_map_sanity_check(unaligned_phys_addr, unaligned_size))
|
|
|
|
pr_warn("caller %pS mapping multiple BARs\n", caller);
|
2011-04-29 00:00:30 +07:00
|
|
|
|
2008-05-13 02:20:57 +07:00
|
|
|
return ret_addr;
|
2009-11-05 09:43:51 +07:00
|
|
|
err_free_area:
|
|
|
|
free_vm_area(area);
|
|
|
|
err_free_memtype:
|
|
|
|
free_memtype(phys_addr, phys_addr + size);
|
|
|
|
return NULL;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ioremap_nocache - map bus memory into CPU space
|
2012-06-10 09:50:52 +07:00
|
|
|
* @phys_addr: bus address of the memory
|
2005-04-17 05:20:36 +07:00
|
|
|
* @size: size of the resource to map
|
|
|
|
*
|
|
|
|
* ioremap_nocache performs a platform specific sequence of operations to
|
|
|
|
* make bus memory CPU accessible via the readb/readw/readl/writeb/
|
|
|
|
* writew/writel functions and the other mmio helpers. The returned
|
|
|
|
* address is not guaranteed to be usable directly as a virtual
|
2008-01-30 19:34:05 +07:00
|
|
|
* address.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* This version of ioremap ensures that the memory is marked uncachable
|
|
|
|
* on the CPU as well as honouring existing caching rules from things like
|
2008-01-30 19:34:05 +07:00
|
|
|
* the PCI bus. Note that there are other caches and buffers on many
|
2005-04-17 05:20:36 +07:00
|
|
|
* busses. In particular driver authors should read up on PCI writes
|
|
|
|
*
|
|
|
|
* It's useful if some control registers are in such an area and
|
|
|
|
* write combining or read caching is not desirable:
|
2008-01-30 19:34:05 +07:00
|
|
|
*
|
2005-04-17 05:20:36 +07:00
|
|
|
* Must be freed with iounmap.
|
|
|
|
*/
|
2008-03-25 01:22:39 +07:00
|
|
|
void __iomem *ioremap_nocache(resource_size_t phys_addr, unsigned long size)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-04-26 07:07:22 +07:00
|
|
|
/*
|
|
|
|
* Ideally, this should be:
|
2015-05-26 15:28:15 +07:00
|
|
|
* pat_enabled() ? _PAGE_CACHE_MODE_UC : _PAGE_CACHE_MODE_UC_MINUS;
|
2008-04-26 07:07:22 +07:00
|
|
|
*
|
|
|
|
* Till we fix all X drivers to use ioremap_wc(), we will use
|
x86/mm: Add ioremap_uc() helper to map memory uncacheable (not UC-)
ioremap_nocache() currently uses UC- by default. Our goal is to
eventually make UC the default. Linux maps UC- to PCD=1, PWT=0
page attributes on non-PAT systems. Linux maps UC to PCD=1,
PWT=1 page attributes on non-PAT systems. On non-PAT and PAT
systems a WC MTRR has different effects on pages with either of
these attributes. In order to help with a smooth transition its
best to enable use of UC (PCD,1, PWT=1) on a region as that
ensures a WC MTRR will have no effect on a region, this however
requires us to have an way to declare a region as UC and we
currently do not have a way to do this.
WC MTRR on non-PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on non-PAT system with PCD=1, PWT=1 (UC) yields UC.
WC MTRR on PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on PAT system with PCD=1, PWT=1 (UC) yields UC.
A flip of the default ioremap_nocache() behaviour from UC- to UC
can therefore regress a memory region from effective memory type
WC to UC if MTRRs are used. Use of MTRRs should be phased out
and in the best case only arch_phys_wc_add() use will remain,
even if this happens arch_phys_wc_add() will have an effect on
non-PAT systems and changes to default ioremap_nocache()
behaviour could regress drivers.
Now, ideally we'd use ioremap_nocache() on the regions in which
we'd need uncachable memory types and avoid any MTRRs on those
regions. There are however some restrictions on MTRRs use, such
as the requirement of having the base and size of variable sized
MTRRs to be powers of two, which could mean having to use a WC
MTRR over a large area which includes a region in which
write-combining effects are undesirable.
Add ioremap_uc() to help with the both phasing out of MTRR use
and also provide a way to blacklist small WC undesirable regions
in devices with mixed regions which are size-implicated to use
large WC MTRRs. Use of ioremap_uc() helps phase out MTRR use by
avoiding regressions with an eventual flip of default behaviour
or ioremap_nocache() from UC- to UC.
Drivers working with WC MTRRs can use the below table to review
and consider the use of ioremap*() and similar helpers to ensure
appropriate behaviour long term even if default
ioremap_nocache() behaviour changes from UC- to UC.
Although ioremap_uc() is being added we leave set_memory_uc() to
use UC- as only initial memory type setup is required to be able
to accommodate existing device drivers and phase out MTRR use.
It should also be clarified that set_memory_uc() cannot be used
with IO memory, even though its use will not return any errors,
it really has no effect.
----------------------------------------------------------------------
MTRR Non-PAT PAT Linux ioremap value Effective memory type
----------------------------------------------------------------------
Non-PAT | PAT
PAT
|PCD
||PWT
|||
WC 000 WB _PAGE_CACHE_MODE_WB WC | WC
WC 001 WC _PAGE_CACHE_MODE_WC WC* | WC
WC 010 UC- _PAGE_CACHE_MODE_UC_MINUS WC* | WC
WC 011 UC _PAGE_CACHE_MODE_UC UC | UC
----------------------------------------------------------------------
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Antonino Daplas <adaplas@gmail.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Dave Airlie <airlied@redhat.com>
Cc: Davidlohr Bueso <dbueso@suse.de>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Jean-Christophe Plagniol-Villard <plagnioj@jcrosoft.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Mike Travis <travis@sgi.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Suresh Siddha <sbsiddha@gmail.com>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tomi Valkeinen <tomi.valkeinen@ti.com>
Cc: Toshi Kani <toshi.kani@hp.com>
Cc: Ville Syrjälä <syrjala@sci.fi>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-fbdev@vger.kernel.org
Link: http://lkml.kernel.org/r/1430343851-967-2-git-send-email-mcgrof@do-not-panic.com
Link: http://lkml.kernel.org/r/1431332153-18566-9-git-send-email-bp@alien8.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-11 15:15:53 +07:00
|
|
|
* UC MINUS. Drivers that are certain they need or can already
|
|
|
|
* be converted over to strong UC can use ioremap_uc().
|
2008-04-26 07:07:22 +07:00
|
|
|
*/
|
2014-11-03 20:01:58 +07:00
|
|
|
enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC_MINUS;
|
2008-04-26 07:07:22 +07:00
|
|
|
|
2014-11-03 20:01:58 +07:00
|
|
|
return __ioremap_caller(phys_addr, size, pcm,
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-06-23 14:08:33 +07:00
|
|
|
EXPORT_SYMBOL(ioremap_nocache);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
x86/mm: Add ioremap_uc() helper to map memory uncacheable (not UC-)
ioremap_nocache() currently uses UC- by default. Our goal is to
eventually make UC the default. Linux maps UC- to PCD=1, PWT=0
page attributes on non-PAT systems. Linux maps UC to PCD=1,
PWT=1 page attributes on non-PAT systems. On non-PAT and PAT
systems a WC MTRR has different effects on pages with either of
these attributes. In order to help with a smooth transition its
best to enable use of UC (PCD,1, PWT=1) on a region as that
ensures a WC MTRR will have no effect on a region, this however
requires us to have an way to declare a region as UC and we
currently do not have a way to do this.
WC MTRR on non-PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on non-PAT system with PCD=1, PWT=1 (UC) yields UC.
WC MTRR on PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on PAT system with PCD=1, PWT=1 (UC) yields UC.
A flip of the default ioremap_nocache() behaviour from UC- to UC
can therefore regress a memory region from effective memory type
WC to UC if MTRRs are used. Use of MTRRs should be phased out
and in the best case only arch_phys_wc_add() use will remain,
even if this happens arch_phys_wc_add() will have an effect on
non-PAT systems and changes to default ioremap_nocache()
behaviour could regress drivers.
Now, ideally we'd use ioremap_nocache() on the regions in which
we'd need uncachable memory types and avoid any MTRRs on those
regions. There are however some restrictions on MTRRs use, such
as the requirement of having the base and size of variable sized
MTRRs to be powers of two, which could mean having to use a WC
MTRR over a large area which includes a region in which
write-combining effects are undesirable.
Add ioremap_uc() to help with the both phasing out of MTRR use
and also provide a way to blacklist small WC undesirable regions
in devices with mixed regions which are size-implicated to use
large WC MTRRs. Use of ioremap_uc() helps phase out MTRR use by
avoiding regressions with an eventual flip of default behaviour
or ioremap_nocache() from UC- to UC.
Drivers working with WC MTRRs can use the below table to review
and consider the use of ioremap*() and similar helpers to ensure
appropriate behaviour long term even if default
ioremap_nocache() behaviour changes from UC- to UC.
Although ioremap_uc() is being added we leave set_memory_uc() to
use UC- as only initial memory type setup is required to be able
to accommodate existing device drivers and phase out MTRR use.
It should also be clarified that set_memory_uc() cannot be used
with IO memory, even though its use will not return any errors,
it really has no effect.
----------------------------------------------------------------------
MTRR Non-PAT PAT Linux ioremap value Effective memory type
----------------------------------------------------------------------
Non-PAT | PAT
PAT
|PCD
||PWT
|||
WC 000 WB _PAGE_CACHE_MODE_WB WC | WC
WC 001 WC _PAGE_CACHE_MODE_WC WC* | WC
WC 010 UC- _PAGE_CACHE_MODE_UC_MINUS WC* | WC
WC 011 UC _PAGE_CACHE_MODE_UC UC | UC
----------------------------------------------------------------------
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Antonino Daplas <adaplas@gmail.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Dave Airlie <airlied@redhat.com>
Cc: Davidlohr Bueso <dbueso@suse.de>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Jean-Christophe Plagniol-Villard <plagnioj@jcrosoft.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Mike Travis <travis@sgi.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Suresh Siddha <sbsiddha@gmail.com>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tomi Valkeinen <tomi.valkeinen@ti.com>
Cc: Toshi Kani <toshi.kani@hp.com>
Cc: Ville Syrjälä <syrjala@sci.fi>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-fbdev@vger.kernel.org
Link: http://lkml.kernel.org/r/1430343851-967-2-git-send-email-mcgrof@do-not-panic.com
Link: http://lkml.kernel.org/r/1431332153-18566-9-git-send-email-bp@alien8.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-11 15:15:53 +07:00
|
|
|
/**
|
|
|
|
* ioremap_uc - map bus memory into CPU space as strongly uncachable
|
|
|
|
* @phys_addr: bus address of the memory
|
|
|
|
* @size: size of the resource to map
|
|
|
|
*
|
|
|
|
* ioremap_uc performs a platform specific sequence of operations to
|
|
|
|
* make bus memory CPU accessible via the readb/readw/readl/writeb/
|
|
|
|
* writew/writel functions and the other mmio helpers. The returned
|
|
|
|
* address is not guaranteed to be usable directly as a virtual
|
|
|
|
* address.
|
|
|
|
*
|
|
|
|
* This version of ioremap ensures that the memory is marked with a strong
|
|
|
|
* preference as completely uncachable on the CPU when possible. For non-PAT
|
|
|
|
* systems this ends up setting page-attribute flags PCD=1, PWT=1. For PAT
|
|
|
|
* systems this will set the PAT entry for the pages as strong UC. This call
|
|
|
|
* will honor existing caching rules from things like the PCI bus. Note that
|
|
|
|
* there are other caches and buffers on many busses. In particular driver
|
|
|
|
* authors should read up on PCI writes.
|
|
|
|
*
|
|
|
|
* It's useful if some control registers are in such an area and
|
|
|
|
* write combining or read caching is not desirable:
|
|
|
|
*
|
|
|
|
* Must be freed with iounmap.
|
|
|
|
*/
|
|
|
|
void __iomem *ioremap_uc(resource_size_t phys_addr, unsigned long size)
|
|
|
|
{
|
|
|
|
enum page_cache_mode pcm = _PAGE_CACHE_MODE_UC;
|
|
|
|
|
|
|
|
return __ioremap_caller(phys_addr, size, pcm,
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
x86/mm: Add ioremap_uc() helper to map memory uncacheable (not UC-)
ioremap_nocache() currently uses UC- by default. Our goal is to
eventually make UC the default. Linux maps UC- to PCD=1, PWT=0
page attributes on non-PAT systems. Linux maps UC to PCD=1,
PWT=1 page attributes on non-PAT systems. On non-PAT and PAT
systems a WC MTRR has different effects on pages with either of
these attributes. In order to help with a smooth transition its
best to enable use of UC (PCD,1, PWT=1) on a region as that
ensures a WC MTRR will have no effect on a region, this however
requires us to have an way to declare a region as UC and we
currently do not have a way to do this.
WC MTRR on non-PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on non-PAT system with PCD=1, PWT=1 (UC) yields UC.
WC MTRR on PAT system with PCD=1, PWT=0 (UC-) yields WC.
WC MTRR on PAT system with PCD=1, PWT=1 (UC) yields UC.
A flip of the default ioremap_nocache() behaviour from UC- to UC
can therefore regress a memory region from effective memory type
WC to UC if MTRRs are used. Use of MTRRs should be phased out
and in the best case only arch_phys_wc_add() use will remain,
even if this happens arch_phys_wc_add() will have an effect on
non-PAT systems and changes to default ioremap_nocache()
behaviour could regress drivers.
Now, ideally we'd use ioremap_nocache() on the regions in which
we'd need uncachable memory types and avoid any MTRRs on those
regions. There are however some restrictions on MTRRs use, such
as the requirement of having the base and size of variable sized
MTRRs to be powers of two, which could mean having to use a WC
MTRR over a large area which includes a region in which
write-combining effects are undesirable.
Add ioremap_uc() to help with the both phasing out of MTRR use
and also provide a way to blacklist small WC undesirable regions
in devices with mixed regions which are size-implicated to use
large WC MTRRs. Use of ioremap_uc() helps phase out MTRR use by
avoiding regressions with an eventual flip of default behaviour
or ioremap_nocache() from UC- to UC.
Drivers working with WC MTRRs can use the below table to review
and consider the use of ioremap*() and similar helpers to ensure
appropriate behaviour long term even if default
ioremap_nocache() behaviour changes from UC- to UC.
Although ioremap_uc() is being added we leave set_memory_uc() to
use UC- as only initial memory type setup is required to be able
to accommodate existing device drivers and phase out MTRR use.
It should also be clarified that set_memory_uc() cannot be used
with IO memory, even though its use will not return any errors,
it really has no effect.
----------------------------------------------------------------------
MTRR Non-PAT PAT Linux ioremap value Effective memory type
----------------------------------------------------------------------
Non-PAT | PAT
PAT
|PCD
||PWT
|||
WC 000 WB _PAGE_CACHE_MODE_WB WC | WC
WC 001 WC _PAGE_CACHE_MODE_WC WC* | WC
WC 010 UC- _PAGE_CACHE_MODE_UC_MINUS WC* | WC
WC 011 UC _PAGE_CACHE_MODE_UC UC | UC
----------------------------------------------------------------------
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Acked-by: H. Peter Anvin <hpa@zytor.com>
Cc: Andy Lutomirski <luto@amacapital.net>
Cc: Antonino Daplas <adaplas@gmail.com>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Brian Gerst <brgerst@gmail.com>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: Dave Airlie <airlied@redhat.com>
Cc: Davidlohr Bueso <dbueso@suse.de>
Cc: Denys Vlasenko <dvlasenk@redhat.com>
Cc: Jean-Christophe Plagniol-Villard <plagnioj@jcrosoft.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Mike Travis <travis@sgi.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Suresh Siddha <sbsiddha@gmail.com>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tomi Valkeinen <tomi.valkeinen@ti.com>
Cc: Toshi Kani <toshi.kani@hp.com>
Cc: Ville Syrjälä <syrjala@sci.fi>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-fbdev@vger.kernel.org
Link: http://lkml.kernel.org/r/1430343851-967-2-git-send-email-mcgrof@do-not-panic.com
Link: http://lkml.kernel.org/r/1431332153-18566-9-git-send-email-bp@alien8.de
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2015-05-11 15:15:53 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ioremap_uc);
|
|
|
|
|
2008-03-19 07:00:24 +07:00
|
|
|
/**
|
|
|
|
* ioremap_wc - map memory into CPU space write combined
|
2012-06-10 09:50:52 +07:00
|
|
|
* @phys_addr: bus address of the memory
|
2008-03-19 07:00:24 +07:00
|
|
|
* @size: size of the resource to map
|
|
|
|
*
|
|
|
|
* This version of ioremap ensures that the memory is marked write combining.
|
|
|
|
* Write combining allows faster writes to some hardware devices.
|
|
|
|
*
|
|
|
|
* Must be freed with iounmap.
|
|
|
|
*/
|
2009-01-10 07:13:13 +07:00
|
|
|
void __iomem *ioremap_wc(resource_size_t phys_addr, unsigned long size)
|
2008-03-19 07:00:24 +07:00
|
|
|
{
|
2015-06-04 23:55:11 +07:00
|
|
|
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WC,
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
2008-03-19 07:00:24 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_wc);
|
|
|
|
|
2015-06-04 23:55:15 +07:00
|
|
|
/**
|
|
|
|
* ioremap_wt - map memory into CPU space write through
|
|
|
|
* @phys_addr: bus address of the memory
|
|
|
|
* @size: size of the resource to map
|
|
|
|
*
|
|
|
|
* This version of ioremap ensures that the memory is marked write through.
|
|
|
|
* Write through stores data into memory while keeping the cache up-to-date.
|
|
|
|
*
|
|
|
|
* Must be freed with iounmap.
|
|
|
|
*/
|
|
|
|
void __iomem *ioremap_wt(resource_size_t phys_addr, unsigned long size)
|
|
|
|
{
|
|
|
|
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WT,
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
2015-06-04 23:55:15 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_wt);
|
|
|
|
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
void __iomem *ioremap_encrypted(resource_size_t phys_addr, unsigned long size)
|
|
|
|
{
|
|
|
|
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
|
|
|
|
__builtin_return_address(0), true);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_encrypted);
|
|
|
|
|
2008-03-25 01:22:39 +07:00
|
|
|
void __iomem *ioremap_cache(resource_size_t phys_addr, unsigned long size)
|
2008-01-30 19:34:06 +07:00
|
|
|
{
|
2014-11-03 20:01:58 +07:00
|
|
|
return __ioremap_caller(phys_addr, size, _PAGE_CACHE_MODE_WB,
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
2008-01-30 19:34:06 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_cache);
|
|
|
|
|
2008-07-24 11:27:05 +07:00
|
|
|
void __iomem *ioremap_prot(resource_size_t phys_addr, unsigned long size,
|
|
|
|
unsigned long prot_val)
|
|
|
|
{
|
2014-11-03 20:01:58 +07:00
|
|
|
return __ioremap_caller(phys_addr, size,
|
|
|
|
pgprot2cachemode(__pgprot(prot_val)),
|
x86/ioremap: Add an ioremap_encrypted() helper
When SME is enabled, the memory is encrypted in the first kernel. In
this case, SME also needs to be enabled in the kdump kernel, and we have
to remap the old memory with the memory encryption mask.
The case of concern here is if SME is active in the first kernel,
and it is active too in the kdump kernel. There are four cases to be
considered:
a. dump vmcore
It is encrypted in the first kernel, and needs be read out in the
kdump kernel.
b. crash notes
When dumping vmcore, the people usually need to read useful
information from notes, and the notes is also encrypted.
c. iommu device table
It's encrypted in the first kernel, kdump kernel needs to access its
content to analyze and get information it needs.
d. mmio of AMD iommu
not encrypted in both kernels
Add a new bool parameter @encrypted to __ioremap_caller(). If set,
memory will be remapped with the SME mask.
Add a new function ioremap_encrypted() to explicitly pass in a true
value for @encrypted. Use ioremap_encrypted() for the above a, b, c
cases.
[ bp: cleanup commit message, extern defs in io.h and drop forgotten
include. ]
Signed-off-by: Lianbo Jiang <lijiang@redhat.com>
Signed-off-by: Borislav Petkov <bp@suse.de>
Reviewed-by: Tom Lendacky <thomas.lendacky@amd.com>
Cc: kexec@lists.infradead.org
Cc: tglx@linutronix.de
Cc: mingo@redhat.com
Cc: hpa@zytor.com
Cc: akpm@linux-foundation.org
Cc: dan.j.williams@intel.com
Cc: bhelgaas@google.com
Cc: baiyaowei@cmss.chinamobile.com
Cc: tiwai@suse.de
Cc: brijesh.singh@amd.com
Cc: dyoung@redhat.com
Cc: bhe@redhat.com
Cc: jroedel@suse.de
Link: https://lkml.kernel.org/r/20180927071954.29615-2-lijiang@redhat.com
2018-09-27 14:19:51 +07:00
|
|
|
__builtin_return_address(0), false);
|
2008-07-24 11:27:05 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ioremap_prot);
|
|
|
|
|
2005-12-13 13:17:09 +07:00
|
|
|
/**
|
|
|
|
* iounmap - Free a IO remapping
|
|
|
|
* @addr: virtual address from ioremap_*
|
|
|
|
*
|
|
|
|
* Caller must ensure there is only one unmapping for the same pointer.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
void iounmap(volatile void __iomem *addr)
|
|
|
|
{
|
2005-12-13 13:17:09 +07:00
|
|
|
struct vm_struct *p, *o;
|
2005-07-08 07:56:02 +07:00
|
|
|
|
|
|
|
if ((void __force *)addr <= high_memory)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
2017-07-18 04:10:04 +07:00
|
|
|
* The PCI/ISA range special-casing was removed from __ioremap()
|
|
|
|
* so this check, in theory, can be removed. However, there are
|
|
|
|
* cases where iounmap() is called for addresses not obtained via
|
|
|
|
* ioremap() (vga16fb for example). Add a warning so that these
|
|
|
|
* cases can be caught and fixed.
|
2005-04-17 05:20:36 +07:00
|
|
|
*/
|
2008-05-12 20:43:35 +07:00
|
|
|
if ((void __force *)addr >= phys_to_virt(ISA_START_ADDRESS) &&
|
2017-07-18 04:10:04 +07:00
|
|
|
(void __force *)addr < phys_to_virt(ISA_END_ADDRESS)) {
|
|
|
|
WARN(1, "iounmap() called for ISA range not obtained using ioremap()\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
2017-07-18 04:10:04 +07:00
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2017-11-27 14:51:39 +07:00
|
|
|
mmiotrace_iounmap(addr);
|
|
|
|
|
2008-01-30 19:34:05 +07:00
|
|
|
addr = (volatile void __iomem *)
|
|
|
|
(PAGE_MASK & (unsigned long __force)addr);
|
2005-12-13 13:17:09 +07:00
|
|
|
|
|
|
|
/* Use the vm area unlocked, assuming the caller
|
|
|
|
ensures there isn't another iounmap for the same address
|
|
|
|
in parallel. Reuse of the virtual address is prevented by
|
|
|
|
leaving it in the global lists until we're done with it.
|
|
|
|
cpa takes care of the direct mappings. */
|
2013-04-30 05:07:27 +07:00
|
|
|
p = find_vm_area((void __force *)addr);
|
2005-12-13 13:17:09 +07:00
|
|
|
|
|
|
|
if (!p) {
|
2008-01-30 19:34:05 +07:00
|
|
|
printk(KERN_ERR "iounmap: bad address %p\n", addr);
|
2005-07-08 07:56:02 +07:00
|
|
|
dump_stack();
|
2005-12-13 13:17:09 +07:00
|
|
|
return;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-03-19 07:00:17 +07:00
|
|
|
free_memtype(p->phys_addr, p->phys_addr + get_vm_area_size(p));
|
|
|
|
|
2005-12-13 13:17:09 +07:00
|
|
|
/* Finally remove it */
|
2008-05-12 20:43:35 +07:00
|
|
|
o = remove_vm_area((void __force *)addr);
|
2005-12-13 13:17:09 +07:00
|
|
|
BUG_ON(p != o || o == NULL);
|
2008-01-30 19:34:05 +07:00
|
|
|
kfree(p);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-06-23 14:08:33 +07:00
|
|
|
EXPORT_SYMBOL(iounmap);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2019-07-17 06:27:33 +07:00
|
|
|
int __init arch_ioremap_p4d_supported(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-28 15:29:27 +07:00
|
|
|
int __init arch_ioremap_pud_supported(void)
|
2015-04-15 05:47:29 +07:00
|
|
|
{
|
|
|
|
#ifdef CONFIG_X86_64
|
2016-03-29 22:41:58 +07:00
|
|
|
return boot_cpu_has(X86_FEATURE_GBPAGES);
|
2015-04-15 05:47:29 +07:00
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-05-28 15:29:27 +07:00
|
|
|
int __init arch_ioremap_pmd_supported(void)
|
2015-04-15 05:47:29 +07:00
|
|
|
{
|
2016-03-29 22:42:03 +07:00
|
|
|
return boot_cpu_has(X86_FEATURE_PSE);
|
2015-04-15 05:47:29 +07:00
|
|
|
}
|
|
|
|
|
2008-03-19 07:00:15 +07:00
|
|
|
/*
|
|
|
|
* Convert a physical pointer to a virtual kernel pointer for /dev/mem
|
|
|
|
* access
|
|
|
|
*/
|
2014-07-28 22:20:33 +07:00
|
|
|
void *xlate_dev_mem_ptr(phys_addr_t phys)
|
2008-03-19 07:00:15 +07:00
|
|
|
{
|
2012-11-24 01:19:07 +07:00
|
|
|
unsigned long start = phys & PAGE_MASK;
|
|
|
|
unsigned long offset = phys & ~PAGE_MASK;
|
2015-05-08 17:43:53 +07:00
|
|
|
void *vaddr;
|
2008-03-19 07:00:15 +07:00
|
|
|
|
2017-07-18 04:10:30 +07:00
|
|
|
/* memremap() maps if RAM, otherwise falls back to ioremap() */
|
|
|
|
vaddr = memremap(start, PAGE_SIZE, MEMREMAP_WB);
|
2008-03-19 07:00:15 +07:00
|
|
|
|
2017-07-18 04:10:30 +07:00
|
|
|
/* Only add the offset on success and return NULL if memremap() failed */
|
2012-11-24 01:19:07 +07:00
|
|
|
if (vaddr)
|
|
|
|
vaddr += offset;
|
2008-03-19 07:00:15 +07:00
|
|
|
|
2015-05-08 17:43:53 +07:00
|
|
|
return vaddr;
|
2008-03-19 07:00:15 +07:00
|
|
|
}
|
|
|
|
|
2014-07-28 22:20:33 +07:00
|
|
|
void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr)
|
2008-03-19 07:00:15 +07:00
|
|
|
{
|
2017-07-18 04:10:30 +07:00
|
|
|
memunmap((void *)((unsigned long)addr & PAGE_MASK));
|
2008-03-19 07:00:15 +07:00
|
|
|
}
|
|
|
|
|
2017-07-18 04:10:16 +07:00
|
|
|
/*
|
|
|
|
* Examine the physical address to determine if it is an area of memory
|
|
|
|
* that should be mapped decrypted. If the memory is not part of the
|
|
|
|
* kernel usable area it was accessed and created decrypted, so these
|
2017-07-18 04:10:18 +07:00
|
|
|
* areas should be mapped decrypted. And since the encryption key can
|
|
|
|
* change across reboots, persistent memory should also be mapped
|
|
|
|
* decrypted.
|
2017-10-20 21:30:47 +07:00
|
|
|
*
|
|
|
|
* If SEV is active, that implies that BIOS/UEFI also ran encrypted so
|
|
|
|
* only persistent memory should be mapped decrypted.
|
2017-07-18 04:10:16 +07:00
|
|
|
*/
|
|
|
|
static bool memremap_should_map_decrypted(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
2017-07-18 04:10:18 +07:00
|
|
|
int is_pmem;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the address is part of a persistent memory region.
|
|
|
|
* This check covers areas added by E820, EFI and ACPI.
|
|
|
|
*/
|
|
|
|
is_pmem = region_intersects(phys_addr, size, IORESOURCE_MEM,
|
|
|
|
IORES_DESC_PERSISTENT_MEMORY);
|
|
|
|
if (is_pmem != REGION_DISJOINT)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the non-volatile attribute is set for an EFI
|
|
|
|
* reserved area.
|
|
|
|
*/
|
|
|
|
if (efi_enabled(EFI_BOOT)) {
|
|
|
|
switch (efi_mem_type(phys_addr)) {
|
|
|
|
case EFI_RESERVED_TYPE:
|
|
|
|
if (efi_mem_attributes(phys_addr) & EFI_MEMORY_NV)
|
|
|
|
return true;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-07-18 04:10:16 +07:00
|
|
|
/* Check if the address is outside kernel usable area */
|
|
|
|
switch (e820__get_entry_type(phys_addr, phys_addr + size - 1)) {
|
|
|
|
case E820_TYPE_RESERVED:
|
|
|
|
case E820_TYPE_ACPI:
|
|
|
|
case E820_TYPE_NVS:
|
|
|
|
case E820_TYPE_UNUSABLE:
|
2017-10-20 21:30:47 +07:00
|
|
|
/* For SEV, these areas are encrypted */
|
|
|
|
if (sev_active())
|
|
|
|
break;
|
|
|
|
/* Fallthrough */
|
|
|
|
|
2017-07-18 04:10:18 +07:00
|
|
|
case E820_TYPE_PRAM:
|
2017-07-18 04:10:16 +07:00
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine the physical address to determine if it is EFI data. Check
|
|
|
|
* it against the boot params structure and EFI tables and memory types.
|
|
|
|
*/
|
|
|
|
static bool memremap_is_efi_data(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
u64 paddr;
|
|
|
|
|
|
|
|
/* Check if the address is part of EFI boot/runtime data */
|
|
|
|
if (!efi_enabled(EFI_BOOT))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
paddr = boot_params.efi_info.efi_memmap_hi;
|
|
|
|
paddr <<= 32;
|
|
|
|
paddr |= boot_params.efi_info.efi_memmap;
|
|
|
|
if (phys_addr == paddr)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
paddr = boot_params.efi_info.efi_systab_hi;
|
|
|
|
paddr <<= 32;
|
|
|
|
paddr |= boot_params.efi_info.efi_systab;
|
|
|
|
if (phys_addr == paddr)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (efi_is_table_address(phys_addr))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
switch (efi_mem_type(phys_addr)) {
|
|
|
|
case EFI_BOOT_SERVICES_DATA:
|
|
|
|
case EFI_RUNTIME_SERVICES_DATA:
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine the physical address to determine if it is boot data by checking
|
|
|
|
* it against the boot params setup_data chain.
|
|
|
|
*/
|
|
|
|
static bool memremap_is_setup_data(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
struct setup_data *data;
|
|
|
|
u64 paddr, paddr_next;
|
|
|
|
|
|
|
|
paddr = boot_params.hdr.setup_data;
|
|
|
|
while (paddr) {
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
if (phys_addr == paddr)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
data = memremap(paddr, sizeof(*data),
|
|
|
|
MEMREMAP_WB | MEMREMAP_DEC);
|
|
|
|
|
|
|
|
paddr_next = data->next;
|
|
|
|
len = data->len;
|
|
|
|
|
|
|
|
memunmap(data);
|
|
|
|
|
|
|
|
if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
paddr = paddr_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Examine the physical address to determine if it is boot data by checking
|
|
|
|
* it against the boot params setup_data chain (early boot version).
|
|
|
|
*/
|
|
|
|
static bool __init early_memremap_is_setup_data(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
struct setup_data *data;
|
|
|
|
u64 paddr, paddr_next;
|
|
|
|
|
|
|
|
paddr = boot_params.hdr.setup_data;
|
|
|
|
while (paddr) {
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
if (phys_addr == paddr)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
data = early_memremap_decrypted(paddr, sizeof(*data));
|
|
|
|
|
|
|
|
paddr_next = data->next;
|
|
|
|
len = data->len;
|
|
|
|
|
|
|
|
early_memunmap(data, sizeof(*data));
|
|
|
|
|
|
|
|
if ((phys_addr > paddr) && (phys_addr < (paddr + len)))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
paddr = paddr_next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Architecture function to determine if RAM remap is allowed. By default, a
|
|
|
|
* RAM remap will map the data as encrypted. Determine if a RAM remap should
|
|
|
|
* not be done so that the data will be mapped decrypted.
|
|
|
|
*/
|
|
|
|
bool arch_memremap_can_ram_remap(resource_size_t phys_addr, unsigned long size,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
2017-10-20 21:30:47 +07:00
|
|
|
if (!mem_encrypt_active())
|
2017-07-18 04:10:16 +07:00
|
|
|
return true;
|
|
|
|
|
|
|
|
if (flags & MEMREMAP_ENC)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (flags & MEMREMAP_DEC)
|
|
|
|
return false;
|
|
|
|
|
2017-10-20 21:30:47 +07:00
|
|
|
if (sme_active()) {
|
|
|
|
if (memremap_is_setup_data(phys_addr, size) ||
|
|
|
|
memremap_is_efi_data(phys_addr, size))
|
|
|
|
return false;
|
|
|
|
}
|
2017-07-18 04:10:16 +07:00
|
|
|
|
2017-10-20 21:30:47 +07:00
|
|
|
return !memremap_should_map_decrypted(phys_addr, size);
|
2017-07-18 04:10:16 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Architecture override of __weak function to adjust the protection attributes
|
|
|
|
* used when remapping memory. By default, early_memremap() will map the data
|
|
|
|
* as encrypted. Determine if an encrypted mapping should not be done and set
|
|
|
|
* the appropriate protection attributes.
|
|
|
|
*/
|
|
|
|
pgprot_t __init early_memremap_pgprot_adjust(resource_size_t phys_addr,
|
|
|
|
unsigned long size,
|
|
|
|
pgprot_t prot)
|
|
|
|
{
|
2017-10-20 21:30:47 +07:00
|
|
|
bool encrypted_prot;
|
|
|
|
|
|
|
|
if (!mem_encrypt_active())
|
2017-07-18 04:10:16 +07:00
|
|
|
return prot;
|
|
|
|
|
2017-10-20 21:30:47 +07:00
|
|
|
encrypted_prot = true;
|
|
|
|
|
|
|
|
if (sme_active()) {
|
|
|
|
if (early_memremap_is_setup_data(phys_addr, size) ||
|
|
|
|
memremap_is_efi_data(phys_addr, size))
|
|
|
|
encrypted_prot = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (encrypted_prot && memremap_should_map_decrypted(phys_addr, size))
|
|
|
|
encrypted_prot = false;
|
2017-07-18 04:10:16 +07:00
|
|
|
|
2017-10-20 21:30:47 +07:00
|
|
|
return encrypted_prot ? pgprot_encrypted(prot)
|
|
|
|
: pgprot_decrypted(prot);
|
2017-07-18 04:10:16 +07:00
|
|
|
}
|
|
|
|
|
2017-07-18 04:10:30 +07:00
|
|
|
bool phys_mem_access_encrypted(unsigned long phys_addr, unsigned long size)
|
|
|
|
{
|
|
|
|
return arch_memremap_can_ram_remap(phys_addr, size, 0);
|
|
|
|
}
|
|
|
|
|
2019-02-02 16:41:17 +07:00
|
|
|
#ifdef CONFIG_AMD_MEM_ENCRYPT
|
2017-07-18 04:10:09 +07:00
|
|
|
/* Remap memory with encryption */
|
|
|
|
void __init *early_memremap_encrypted(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remap memory with encryption and write-protected - cannot be called
|
|
|
|
* before pat_init() is called
|
|
|
|
*/
|
|
|
|
void __init *early_memremap_encrypted_wp(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
/* Be sure the write-protect PAT entry is set for write-protect */
|
|
|
|
if (__pte2cachemode_tbl[_PAGE_CACHE_MODE_WP] != _PAGE_CACHE_MODE_WP)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_ENC_WP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Remap memory without encryption */
|
|
|
|
void __init *early_memremap_decrypted(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Remap memory without encryption and write-protected - cannot be called
|
|
|
|
* before pat_init() is called
|
|
|
|
*/
|
|
|
|
void __init *early_memremap_decrypted_wp(resource_size_t phys_addr,
|
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
/* Be sure the write-protect PAT entry is set for write-protect */
|
|
|
|
if (__pte2cachemode_tbl[_PAGE_CACHE_MODE_WP] != _PAGE_CACHE_MODE_WP)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return early_memremap_prot(phys_addr, size, __PAGE_KERNEL_NOENC_WP);
|
|
|
|
}
|
2019-02-02 16:41:17 +07:00
|
|
|
#endif /* CONFIG_AMD_MEM_ENCRYPT */
|
2017-07-18 04:10:09 +07:00
|
|
|
|
2009-03-21 07:53:34 +07:00
|
|
|
static pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)] __page_aligned_bss;
|
2008-01-30 19:33:44 +07:00
|
|
|
|
2008-02-10 05:24:09 +07:00
|
|
|
static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
|
2008-01-30 19:33:44 +07:00
|
|
|
{
|
2008-02-13 22:20:35 +07:00
|
|
|
/* Don't assume we're using swapper_pg_dir at this point */
|
2017-06-13 00:26:14 +07:00
|
|
|
pgd_t *base = __va(read_cr3_pa());
|
2008-02-13 22:20:35 +07:00
|
|
|
pgd_t *pgd = &base[pgd_index(addr)];
|
2017-03-13 21:33:05 +07:00
|
|
|
p4d_t *p4d = p4d_offset(pgd, addr);
|
|
|
|
pud_t *pud = pud_offset(p4d, addr);
|
2008-02-10 05:24:09 +07:00
|
|
|
pmd_t *pmd = pmd_offset(pud, addr);
|
|
|
|
|
|
|
|
return pmd;
|
2008-01-30 19:33:44 +07:00
|
|
|
}
|
|
|
|
|
2008-02-10 05:24:09 +07:00
|
|
|
static inline pte_t * __init early_ioremap_pte(unsigned long addr)
|
2008-01-30 19:33:44 +07:00
|
|
|
{
|
2008-02-10 05:24:09 +07:00
|
|
|
return &bm_pte[pte_index(addr)];
|
2008-01-30 19:33:44 +07:00
|
|
|
}
|
|
|
|
|
2010-10-14 06:02:24 +07:00
|
|
|
bool __init is_early_ioremap_ptep(pte_t *ptep)
|
|
|
|
{
|
|
|
|
return ptep >= &bm_pte[0] && ptep < &bm_pte[PAGE_SIZE/sizeof(pte_t)];
|
|
|
|
}
|
|
|
|
|
2008-01-30 19:33:44 +07:00
|
|
|
void __init early_ioremap_init(void)
|
2008-01-30 19:33:44 +07:00
|
|
|
{
|
2008-02-10 05:24:09 +07:00
|
|
|
pmd_t *pmd;
|
2008-01-30 19:33:44 +07:00
|
|
|
|
2014-05-06 02:19:31 +07:00
|
|
|
#ifdef CONFIG_X86_64
|
|
|
|
BUILD_BUG_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
|
|
|
|
#else
|
|
|
|
WARN_ON((fix_to_virt(0) + PAGE_SIZE) & ((1 << PMD_SHIFT) - 1));
|
|
|
|
#endif
|
|
|
|
|
2014-04-08 05:39:49 +07:00
|
|
|
early_ioremap_setup();
|
2009-03-07 12:34:19 +07:00
|
|
|
|
2008-02-10 05:24:09 +07:00
|
|
|
pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
|
2009-03-21 07:53:34 +07:00
|
|
|
memset(bm_pte, 0, sizeof(bm_pte));
|
|
|
|
pmd_populate_kernel(&init_mm, pmd, bm_pte);
|
2008-02-10 05:24:09 +07:00
|
|
|
|
2008-01-30 19:33:49 +07:00
|
|
|
/*
|
2008-02-10 05:24:09 +07:00
|
|
|
* The boot-ioremap range spans multiple pmds, for which
|
2008-01-30 19:33:49 +07:00
|
|
|
* we are not prepared:
|
|
|
|
*/
|
2009-12-18 23:05:51 +07:00
|
|
|
#define __FIXADDR_TOP (-PAGE_SIZE)
|
|
|
|
BUILD_BUG_ON((__fix_to_virt(FIX_BTMAP_BEGIN) >> PMD_SHIFT)
|
|
|
|
!= (__fix_to_virt(FIX_BTMAP_END) >> PMD_SHIFT));
|
|
|
|
#undef __FIXADDR_TOP
|
2008-02-10 05:24:09 +07:00
|
|
|
if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
|
2008-01-30 19:33:49 +07:00
|
|
|
WARN_ON(1);
|
2008-02-10 05:24:09 +07:00
|
|
|
printk(KERN_WARNING "pmd %p != %p\n",
|
|
|
|
pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
|
2008-01-30 19:34:05 +07:00
|
|
|
printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
|
2008-02-10 05:24:09 +07:00
|
|
|
fix_to_virt(FIX_BTMAP_BEGIN));
|
2008-01-30 19:34:05 +07:00
|
|
|
printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END): %08lx\n",
|
2008-02-10 05:24:09 +07:00
|
|
|
fix_to_virt(FIX_BTMAP_END));
|
2008-01-30 19:34:05 +07:00
|
|
|
|
|
|
|
printk(KERN_WARNING "FIX_BTMAP_END: %d\n", FIX_BTMAP_END);
|
|
|
|
printk(KERN_WARNING "FIX_BTMAP_BEGIN: %d\n",
|
|
|
|
FIX_BTMAP_BEGIN);
|
2008-01-30 19:33:49 +07:00
|
|
|
}
|
2008-01-30 19:33:44 +07:00
|
|
|
}
|
|
|
|
|
2014-04-08 05:39:49 +07:00
|
|
|
void __init __early_set_fixmap(enum fixed_addresses idx,
|
|
|
|
phys_addr_t phys, pgprot_t flags)
|
2008-01-30 19:33:44 +07:00
|
|
|
{
|
2008-02-10 05:24:09 +07:00
|
|
|
unsigned long addr = __fix_to_virt(idx);
|
|
|
|
pte_t *pte;
|
2008-01-30 19:33:44 +07:00
|
|
|
|
|
|
|
if (idx >= __end_of_fixed_addresses) {
|
|
|
|
BUG();
|
|
|
|
return;
|
|
|
|
}
|
2008-01-30 19:33:44 +07:00
|
|
|
pte = early_ioremap_pte(addr);
|
2008-06-25 11:19:03 +07:00
|
|
|
|
2018-04-07 03:55:09 +07:00
|
|
|
/* Sanitize 'prot' against any unsupported bits: */
|
2019-04-15 15:46:07 +07:00
|
|
|
pgprot_val(flags) &= __supported_pte_mask;
|
2018-04-07 03:55:09 +07:00
|
|
|
|
2008-01-30 19:33:44 +07:00
|
|
|
if (pgprot_val(flags))
|
2008-02-10 05:24:09 +07:00
|
|
|
set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
|
2008-01-30 19:33:44 +07:00
|
|
|
else
|
2008-06-25 11:19:19 +07:00
|
|
|
pte_clear(&init_mm, addr, pte);
|
2018-01-31 23:03:10 +07:00
|
|
|
__flush_tlb_one_kernel(addr);
|
2008-01-30 19:33:44 +07:00
|
|
|
}
|