2008-01-30 20:31:19 +08:00
|
|
|
/*
|
|
|
|
* Common EFI (Extensible Firmware Interface) support functions
|
|
|
|
* Based on Extensible Firmware Interface Specification version 1.0
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
|
|
|
|
* Copyright (C) 1999-2002 Hewlett-Packard Co.
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
* Stephane Eranian <eranian@hpl.hp.com>
|
|
|
|
* Copyright (C) 2005-2008 Intel Co.
|
|
|
|
* Fenghua Yu <fenghua.yu@intel.com>
|
|
|
|
* Bibo Mao <bibo.mao@intel.com>
|
|
|
|
* Chandramouli Narayanan <mouli@linux.intel.com>
|
|
|
|
* Huang Ying <ying.huang@intel.com>
|
|
|
|
*
|
|
|
|
* Copied from efi_32.c to eliminate the duplicated code between EFI
|
|
|
|
* 32/64 support code. --ying 2007-10-26
|
|
|
|
*
|
|
|
|
* All EFI Runtime Services are not implemented yet as EFI only
|
|
|
|
* supports physical mode addressing on SoftSDV. This is to be fixed
|
|
|
|
* in a future version. --drummond 1999-07-20
|
|
|
|
*
|
|
|
|
* Implemented EFI runtime services and virtual mode calls. --davidm
|
|
|
|
*
|
|
|
|
* Goutham Rao: <goutham.rao@intel.com>
|
|
|
|
* Skip non-WB memory and ignore empty memory ranges.
|
|
|
|
*/
|
|
|
|
|
2012-02-13 05:24:26 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/efi.h>
|
2012-09-29 08:57:05 +08:00
|
|
|
#include <linux/efi-bgrt.h>
|
2011-05-27 00:22:53 +08:00
|
|
|
#include <linux/export.h>
|
2008-01-30 20:31:19 +08:00
|
|
|
#include <linux/bootmem.h>
|
2013-04-12 06:51:01 +08:00
|
|
|
#include <linux/slab.h>
|
2010-08-26 04:39:17 +08:00
|
|
|
#include <linux/memblock.h>
|
2008-01-30 20:31:19 +08:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/reboot.h>
|
|
|
|
#include <linux/bcd.h>
|
|
|
|
|
|
|
|
#include <asm/setup.h>
|
|
|
|
#include <asm/efi.h>
|
|
|
|
#include <asm/time.h>
|
2008-01-30 20:33:55 +08:00
|
|
|
#include <asm/cacheflush.h>
|
|
|
|
#include <asm/tlbflush.h>
|
2009-09-10 10:48:56 +08:00
|
|
|
#include <asm/x86_init.h>
|
x86: Do full rtc synchronization with ntp
Every 11 minutes ntp attempts to update the x86 rtc with the current
system time. Currently, the x86 code only updates the rtc if the system
time is within +/-15 minutes of the current value of the rtc. This
was done originally to avoid setting the RTC if the RTC was in localtime
mode (common with Windows dualbooting). Other architectures do a full
synchronization and now that we have better infrastructure to detect
when the RTC is in localtime, there is no reason that x86 should be
software limited to a 30 minute window.
This patch changes the behavior of the kernel to do a full synchronization
(year, month, day, hour, minute, and second) of the rtc when ntp requests
a synchronization between the system time and the rtc.
I've used the RTC library functions in this patchset as they do all the
required bounds checking.
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: John Stultz <john.stultz@linaro.org>
Cc: x86@kernel.org
Cc: Matt Fleming <matt.fleming@intel.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: linux-efi@vger.kernel.org
Signed-off-by: Prarit Bhargava <prarit@redhat.com>
[jstultz: Tweak commit message, fold in build fix found by fengguang
Also add select RTC_LIB to X86, per new dependency, as found by prarit]
Signed-off-by: John Stultz <john.stultz@linaro.org>
2013-02-15 01:02:54 +08:00
|
|
|
#include <asm/rtc.h>
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
#define EFI_DEBUG 1
|
|
|
|
|
2013-06-02 04:06:20 +08:00
|
|
|
#define EFI_MIN_RESERVE 5120
|
|
|
|
|
|
|
|
#define EFI_DUMMY_GUID \
|
|
|
|
EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9)
|
|
|
|
|
|
|
|
static efi_char16_t efi_dummy_name[6] = { 'D', 'U', 'M', 'M', 'Y', 0 };
|
2013-04-16 04:09:47 +08:00
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
struct efi_memory_map memmap;
|
|
|
|
|
2008-02-14 05:26:13 +08:00
|
|
|
static struct efi efi_phys __initdata;
|
2008-01-30 20:31:19 +08:00
|
|
|
static efi_system_table_t efi_systab __initdata;
|
|
|
|
|
2012-11-14 17:42:35 +08:00
|
|
|
unsigned long x86_efi_facility;
|
|
|
|
|
2013-09-05 18:34:54 +08:00
|
|
|
static __initdata efi_config_table_type_t arch_tables[] = {
|
|
|
|
#ifdef CONFIG_X86_UV
|
|
|
|
{UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
|
|
|
|
#endif
|
|
|
|
{NULL_GUID, NULL, 0},
|
|
|
|
};
|
|
|
|
|
2012-11-14 17:42:35 +08:00
|
|
|
/*
|
|
|
|
* Returns 1 if 'facility' is enabled, 0 otherwise.
|
|
|
|
*/
|
|
|
|
int efi_enabled(int facility)
|
|
|
|
{
|
|
|
|
return test_bit(facility, &x86_efi_facility) != 0;
|
2012-10-25 01:00:44 +08:00
|
|
|
}
|
2012-11-14 17:42:35 +08:00
|
|
|
EXPORT_SYMBOL(efi_enabled);
|
2012-10-25 01:00:44 +08:00
|
|
|
|
2013-02-22 23:03:47 +08:00
|
|
|
static bool __initdata disable_runtime = false;
|
2008-01-30 20:32:11 +08:00
|
|
|
static int __init setup_noefi(char *arg)
|
|
|
|
{
|
2013-02-21 04:36:12 +08:00
|
|
|
disable_runtime = true;
|
2008-01-30 20:32:11 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("noefi", setup_noefi);
|
|
|
|
|
2008-06-25 20:44:46 +08:00
|
|
|
int add_efi_memmap;
|
|
|
|
EXPORT_SYMBOL(add_efi_memmap);
|
|
|
|
|
|
|
|
static int __init setup_add_efi_memmap(char *arg)
|
|
|
|
{
|
|
|
|
add_efi_memmap = 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("add_efi_memmap", setup_add_efi_memmap);
|
|
|
|
|
2013-04-17 07:00:53 +08:00
|
|
|
static bool efi_no_storage_paranoia;
|
|
|
|
|
|
|
|
static int __init setup_storage_paranoia(char *arg)
|
|
|
|
{
|
|
|
|
efi_no_storage_paranoia = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
early_param("efi_no_storage_paranoia", setup_storage_paranoia);
|
|
|
|
|
2008-06-25 20:44:46 +08:00
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
|
|
|
|
{
|
2011-07-19 18:53:07 +08:00
|
|
|
unsigned long flags;
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
status = efi_call_virt2(get_time, tm, tc);
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
return status;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_time(efi_time_t *tm)
|
|
|
|
{
|
2011-07-19 18:53:07 +08:00
|
|
|
unsigned long flags;
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
status = efi_call_virt1(set_time, tm);
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
return status;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
|
|
|
|
efi_bool_t *pending,
|
|
|
|
efi_time_t *tm)
|
|
|
|
{
|
2011-07-19 18:53:07 +08:00
|
|
|
unsigned long flags;
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
status = efi_call_virt3(get_wakeup_time,
|
|
|
|
enabled, pending, tm);
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
return status;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
|
|
|
|
{
|
2011-07-19 18:53:07 +08:00
|
|
|
unsigned long flags;
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
status = efi_call_virt2(set_wakeup_time,
|
|
|
|
enabled, tm);
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
return status;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_variable(efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor,
|
|
|
|
u32 *attr,
|
|
|
|
unsigned long *data_size,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
return efi_call_virt5(get_variable,
|
|
|
|
name, vendor, attr,
|
|
|
|
data_size, data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
|
|
|
|
efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor)
|
|
|
|
{
|
2013-06-02 04:06:20 +08:00
|
|
|
return efi_call_virt3(get_next_variable,
|
|
|
|
name_size, name, vendor);
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_variable(efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor,
|
2011-06-07 03:36:24 +08:00
|
|
|
u32 attr,
|
2008-01-30 20:31:19 +08:00
|
|
|
unsigned long data_size,
|
|
|
|
void *data)
|
|
|
|
{
|
2013-06-02 04:06:20 +08:00
|
|
|
return efi_call_virt5(set_variable,
|
|
|
|
name, vendor, attr,
|
|
|
|
data_size, data);
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
2011-06-07 03:36:25 +08:00
|
|
|
static efi_status_t virt_efi_query_variable_info(u32 attr,
|
|
|
|
u64 *storage_space,
|
|
|
|
u64 *remaining_space,
|
|
|
|
u64 *max_variable_size)
|
|
|
|
{
|
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
|
|
|
return efi_call_virt4(query_variable_info, attr, storage_space,
|
|
|
|
remaining_space, max_variable_size);
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
|
|
|
|
{
|
|
|
|
return efi_call_virt1(get_next_high_mono_count, count);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void virt_efi_reset_system(int reset_type,
|
|
|
|
efi_status_t status,
|
|
|
|
unsigned long data_size,
|
|
|
|
efi_char16_t *data)
|
|
|
|
{
|
|
|
|
efi_call_virt4(reset_system, reset_type, status,
|
|
|
|
data_size, data);
|
|
|
|
}
|
|
|
|
|
2011-06-07 03:36:25 +08:00
|
|
|
static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
unsigned long sg_list)
|
|
|
|
{
|
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
|
|
|
return efi_call_virt3(update_capsule, capsules, count, sg_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
u64 *max_size,
|
|
|
|
int *reset_type)
|
|
|
|
{
|
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
|
|
|
return efi_call_virt4(query_capsule_caps, capsules, count, max_size,
|
|
|
|
reset_type);
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
static efi_status_t __init phys_efi_set_virtual_address_map(
|
|
|
|
unsigned long memory_map_size,
|
|
|
|
unsigned long descriptor_size,
|
|
|
|
u32 descriptor_version,
|
|
|
|
efi_memory_desc_t *virtual_map)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
efi_call_phys_prelog();
|
|
|
|
status = efi_call_phys4(efi_phys.set_virtual_address_map,
|
|
|
|
memory_map_size, descriptor_size,
|
|
|
|
descriptor_version, virtual_map);
|
|
|
|
efi_call_phys_epilog();
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2012-12-16 07:15:24 +08:00
|
|
|
static efi_status_t __init phys_efi_get_time(efi_time_t *tm,
|
|
|
|
efi_time_cap_t *tc)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&rtc_lock, flags);
|
|
|
|
efi_call_phys_prelog();
|
|
|
|
status = efi_call_phys2(efi_phys.get_time, virt_to_phys(tm),
|
|
|
|
virt_to_phys(tc));
|
|
|
|
efi_call_phys_epilog();
|
|
|
|
spin_unlock_irqrestore(&rtc_lock, flags);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2013-05-14 01:56:06 +08:00
|
|
|
int efi_set_rtc_mmss(const struct timespec *now)
|
2008-01-30 20:31:19 +08:00
|
|
|
{
|
2013-05-14 01:56:06 +08:00
|
|
|
unsigned long nowtime = now->tv_sec;
|
2008-01-30 20:31:19 +08:00
|
|
|
efi_status_t status;
|
|
|
|
efi_time_t eft;
|
|
|
|
efi_time_cap_t cap;
|
x86: Do full rtc synchronization with ntp
Every 11 minutes ntp attempts to update the x86 rtc with the current
system time. Currently, the x86 code only updates the rtc if the system
time is within +/-15 minutes of the current value of the rtc. This
was done originally to avoid setting the RTC if the RTC was in localtime
mode (common with Windows dualbooting). Other architectures do a full
synchronization and now that we have better infrastructure to detect
when the RTC is in localtime, there is no reason that x86 should be
software limited to a 30 minute window.
This patch changes the behavior of the kernel to do a full synchronization
(year, month, day, hour, minute, and second) of the rtc when ntp requests
a synchronization between the system time and the rtc.
I've used the RTC library functions in this patchset as they do all the
required bounds checking.
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: John Stultz <john.stultz@linaro.org>
Cc: x86@kernel.org
Cc: Matt Fleming <matt.fleming@intel.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: linux-efi@vger.kernel.org
Signed-off-by: Prarit Bhargava <prarit@redhat.com>
[jstultz: Tweak commit message, fold in build fix found by fengguang
Also add select RTC_LIB to X86, per new dependency, as found by prarit]
Signed-off-by: John Stultz <john.stultz@linaro.org>
2013-02-15 01:02:54 +08:00
|
|
|
struct rtc_time tm;
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
status = efi.get_time(&eft, &cap);
|
|
|
|
if (status != EFI_SUCCESS) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Oops: efitime: can't read time!\n");
|
2008-01-30 20:31:19 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
x86: Do full rtc synchronization with ntp
Every 11 minutes ntp attempts to update the x86 rtc with the current
system time. Currently, the x86 code only updates the rtc if the system
time is within +/-15 minutes of the current value of the rtc. This
was done originally to avoid setting the RTC if the RTC was in localtime
mode (common with Windows dualbooting). Other architectures do a full
synchronization and now that we have better infrastructure to detect
when the RTC is in localtime, there is no reason that x86 should be
software limited to a 30 minute window.
This patch changes the behavior of the kernel to do a full synchronization
(year, month, day, hour, minute, and second) of the rtc when ntp requests
a synchronization between the system time and the rtc.
I've used the RTC library functions in this patchset as they do all the
required bounds checking.
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: John Stultz <john.stultz@linaro.org>
Cc: x86@kernel.org
Cc: Matt Fleming <matt.fleming@intel.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: linux-efi@vger.kernel.org
Signed-off-by: Prarit Bhargava <prarit@redhat.com>
[jstultz: Tweak commit message, fold in build fix found by fengguang
Also add select RTC_LIB to X86, per new dependency, as found by prarit]
Signed-off-by: John Stultz <john.stultz@linaro.org>
2013-02-15 01:02:54 +08:00
|
|
|
rtc_time_to_tm(nowtime, &tm);
|
|
|
|
if (!rtc_valid_tm(&tm)) {
|
|
|
|
eft.year = tm.tm_year + 1900;
|
|
|
|
eft.month = tm.tm_mon + 1;
|
|
|
|
eft.day = tm.tm_mday;
|
|
|
|
eft.minute = tm.tm_min;
|
|
|
|
eft.second = tm.tm_sec;
|
|
|
|
eft.nanosecond = 0;
|
|
|
|
} else {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"%s: Invalid EFI RTC value: write of %lx to EFI RTC failed\n",
|
|
|
|
__FUNCTION__, nowtime);
|
|
|
|
return -1;
|
|
|
|
}
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
status = efi.set_time(&eft);
|
|
|
|
if (status != EFI_SUCCESS) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Oops: efitime: can't write time!\n");
|
2008-01-30 20:31:19 +08:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-05-14 01:56:06 +08:00
|
|
|
void efi_get_time(struct timespec *now)
|
2008-01-30 20:31:19 +08:00
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
efi_time_t eft;
|
|
|
|
efi_time_cap_t cap;
|
|
|
|
|
|
|
|
status = efi.get_time(&eft, &cap);
|
|
|
|
if (status != EFI_SUCCESS)
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Oops: efitime: can't read time!\n");
|
2008-01-30 20:31:19 +08:00
|
|
|
|
2013-05-14 01:56:06 +08:00
|
|
|
now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
|
|
|
|
eft.minute, eft.second);
|
|
|
|
now->tv_nsec = 0;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
2008-05-14 23:15:58 +08:00
|
|
|
/*
|
|
|
|
* Tell the kernel about the EFI memory map. This might include
|
|
|
|
* more than the max 128 entries that can fit in the e820 legacy
|
|
|
|
* (zeropage) memory map.
|
|
|
|
*/
|
|
|
|
|
2008-06-25 20:44:46 +08:00
|
|
|
static void __init do_add_efi_memmap(void)
|
2008-05-14 23:15:58 +08:00
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
efi_memory_desc_t *md = p;
|
|
|
|
unsigned long long start = md->phys_addr;
|
|
|
|
unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
|
|
|
|
int e820_type;
|
|
|
|
|
2009-06-17 05:43:40 +08:00
|
|
|
switch (md->type) {
|
|
|
|
case EFI_LOADER_CODE:
|
|
|
|
case EFI_LOADER_DATA:
|
|
|
|
case EFI_BOOT_SERVICES_CODE:
|
|
|
|
case EFI_BOOT_SERVICES_DATA:
|
|
|
|
case EFI_CONVENTIONAL_MEMORY:
|
|
|
|
if (md->attribute & EFI_MEMORY_WB)
|
|
|
|
e820_type = E820_RAM;
|
|
|
|
else
|
|
|
|
e820_type = E820_RESERVED;
|
|
|
|
break;
|
|
|
|
case EFI_ACPI_RECLAIM_MEMORY:
|
|
|
|
e820_type = E820_ACPI;
|
|
|
|
break;
|
|
|
|
case EFI_ACPI_MEMORY_NVS:
|
|
|
|
e820_type = E820_NVS;
|
|
|
|
break;
|
|
|
|
case EFI_UNUSABLE_MEMORY:
|
|
|
|
e820_type = E820_UNUSABLE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/*
|
|
|
|
* EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
|
|
|
|
* EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
|
|
|
|
* EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
|
|
|
|
*/
|
2008-05-14 23:15:58 +08:00
|
|
|
e820_type = E820_RESERVED;
|
2009-06-17 05:43:40 +08:00
|
|
|
break;
|
|
|
|
}
|
2008-06-16 09:58:51 +08:00
|
|
|
e820_add_region(start, size, e820_type);
|
2008-05-14 23:15:58 +08:00
|
|
|
}
|
|
|
|
sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
|
|
|
|
}
|
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
int __init efi_memblock_x86_reserve_range(void)
|
2008-06-02 14:26:21 +08:00
|
|
|
{
|
2013-03-02 00:07:44 +08:00
|
|
|
struct efi_info *e = &boot_params.efi_info;
|
2008-06-02 14:26:21 +08:00
|
|
|
unsigned long pmap;
|
|
|
|
|
2008-06-22 22:22:02 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
2012-02-13 05:24:29 +08:00
|
|
|
/* Can't handle data above 4GB at this time */
|
2013-03-02 00:07:44 +08:00
|
|
|
if (e->efi_memmap_hi) {
|
2012-02-13 05:24:29 +08:00
|
|
|
pr_err("Memory map is above 4GB, disabling EFI.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2013-03-02 00:07:44 +08:00
|
|
|
pmap = e->efi_memmap;
|
2008-06-22 22:22:02 +08:00
|
|
|
#else
|
2013-03-02 00:07:44 +08:00
|
|
|
pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
|
2008-06-02 14:26:21 +08:00
|
|
|
#endif
|
2013-03-02 00:07:44 +08:00
|
|
|
memmap.phys_map = (void *)pmap;
|
|
|
|
memmap.nr_map = e->efi_memmap_size /
|
|
|
|
e->efi_memdesc_size;
|
|
|
|
memmap.desc_size = e->efi_memdesc_size;
|
|
|
|
memmap.desc_version = e->efi_memdesc_version;
|
|
|
|
|
2011-07-12 17:16:06 +08:00
|
|
|
memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
|
2012-02-13 05:24:29 +08:00
|
|
|
|
2013-09-05 18:34:55 +08:00
|
|
|
efi.memmap = &memmap;
|
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
return 0;
|
2008-06-02 14:26:21 +08:00
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
#if EFI_DEBUG
|
|
|
|
static void __init print_efi_memmap(void)
|
|
|
|
{
|
|
|
|
efi_memory_desc_t *md;
|
|
|
|
void *p;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (p = memmap.map, i = 0;
|
|
|
|
p < memmap.map_end;
|
|
|
|
p += memmap.desc_size, i++) {
|
|
|
|
md = p;
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_info("mem%02u: type=%u, attr=0x%llx, "
|
2008-01-30 20:31:19 +08:00
|
|
|
"range=[0x%016llx-0x%016llx) (%lluMB)\n",
|
|
|
|
i, md->type, md->attribute, md->phys_addr,
|
|
|
|
md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
|
|
|
|
(md->num_pages >> (20 - EFI_PAGE_SHIFT)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* EFI_DEBUG */
|
|
|
|
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
void __init efi_reserve_boot_services(void)
|
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
efi_memory_desc_t *md = p;
|
2011-06-15 01:53:09 +08:00
|
|
|
u64 start = md->phys_addr;
|
|
|
|
u64 size = md->num_pages << EFI_PAGE_SHIFT;
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
|
|
|
|
if (md->type != EFI_BOOT_SERVICES_CODE &&
|
|
|
|
md->type != EFI_BOOT_SERVICES_DATA)
|
|
|
|
continue;
|
2011-06-15 01:53:09 +08:00
|
|
|
/* Only reserve where possible:
|
|
|
|
* - Not within any already allocated areas
|
|
|
|
* - Not over any memory area (really needed, if above?)
|
|
|
|
* - Not within any part of the kernel
|
|
|
|
* - Not the bios reserved area
|
|
|
|
*/
|
2012-11-17 05:57:13 +08:00
|
|
|
if ((start+size >= __pa_symbol(_text)
|
|
|
|
&& start <= __pa_symbol(_end)) ||
|
2011-06-15 01:53:09 +08:00
|
|
|
!e820_all_mapped(start, start+size, E820_RAM) ||
|
2011-07-12 15:58:05 +08:00
|
|
|
memblock_is_region_reserved(start, size)) {
|
2011-06-15 01:53:09 +08:00
|
|
|
/* Could not reserve, skip it */
|
|
|
|
md->num_pages = 0;
|
2012-02-13 05:24:26 +08:00
|
|
|
memblock_dbg("Could not reserve boot range "
|
2011-06-15 01:53:09 +08:00
|
|
|
"[0x%010llx-0x%010llx]\n",
|
|
|
|
start, start+size-1);
|
|
|
|
} else
|
2011-07-12 17:16:06 +08:00
|
|
|
memblock_reserve(start, size);
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-25 01:00:44 +08:00
|
|
|
void __init efi_unmap_memmap(void)
|
2012-09-29 08:55:44 +08:00
|
|
|
{
|
2012-11-14 17:42:35 +08:00
|
|
|
clear_bit(EFI_MEMMAP, &x86_efi_facility);
|
2012-09-29 08:55:44 +08:00
|
|
|
if (memmap.map) {
|
|
|
|
early_iounmap(memmap.map, memmap.nr_map * memmap.desc_size);
|
|
|
|
memmap.map = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void __init efi_free_boot_services(void)
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
{
|
|
|
|
void *p;
|
|
|
|
|
2012-10-25 01:00:44 +08:00
|
|
|
if (!efi_is_native())
|
2012-09-29 08:55:44 +08:00
|
|
|
return;
|
|
|
|
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
efi_memory_desc_t *md = p;
|
|
|
|
unsigned long long start = md->phys_addr;
|
|
|
|
unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (md->type != EFI_BOOT_SERVICES_CODE &&
|
|
|
|
md->type != EFI_BOOT_SERVICES_DATA)
|
|
|
|
continue;
|
|
|
|
|
2011-06-15 01:53:09 +08:00
|
|
|
/* Could not reserve boot area */
|
|
|
|
if (!size)
|
|
|
|
continue;
|
|
|
|
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
free_bootmem_late(start, size);
|
|
|
|
}
|
2012-09-29 08:55:44 +08:00
|
|
|
|
|
|
|
efi_unmap_memmap();
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
}
|
|
|
|
|
2012-02-13 05:24:28 +08:00
|
|
|
static int __init efi_systab_init(void *phys)
|
2008-01-30 20:31:19 +08:00
|
|
|
{
|
2012-11-14 17:42:35 +08:00
|
|
|
if (efi_enabled(EFI_64BIT)) {
|
2012-02-13 05:24:29 +08:00
|
|
|
efi_system_table_64_t *systab64;
|
|
|
|
u64 tmp = 0;
|
|
|
|
|
|
|
|
systab64 = early_ioremap((unsigned long)phys,
|
|
|
|
sizeof(*systab64));
|
|
|
|
if (systab64 == NULL) {
|
|
|
|
pr_err("Couldn't map the system table!\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
efi_systab.hdr = systab64->hdr;
|
|
|
|
efi_systab.fw_vendor = systab64->fw_vendor;
|
|
|
|
tmp |= systab64->fw_vendor;
|
|
|
|
efi_systab.fw_revision = systab64->fw_revision;
|
|
|
|
efi_systab.con_in_handle = systab64->con_in_handle;
|
|
|
|
tmp |= systab64->con_in_handle;
|
|
|
|
efi_systab.con_in = systab64->con_in;
|
|
|
|
tmp |= systab64->con_in;
|
|
|
|
efi_systab.con_out_handle = systab64->con_out_handle;
|
|
|
|
tmp |= systab64->con_out_handle;
|
|
|
|
efi_systab.con_out = systab64->con_out;
|
|
|
|
tmp |= systab64->con_out;
|
|
|
|
efi_systab.stderr_handle = systab64->stderr_handle;
|
|
|
|
tmp |= systab64->stderr_handle;
|
|
|
|
efi_systab.stderr = systab64->stderr;
|
|
|
|
tmp |= systab64->stderr;
|
|
|
|
efi_systab.runtime = (void *)(unsigned long)systab64->runtime;
|
|
|
|
tmp |= systab64->runtime;
|
|
|
|
efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
|
|
|
|
tmp |= systab64->boottime;
|
|
|
|
efi_systab.nr_tables = systab64->nr_tables;
|
|
|
|
efi_systab.tables = systab64->tables;
|
|
|
|
tmp |= systab64->tables;
|
|
|
|
|
|
|
|
early_iounmap(systab64, sizeof(*systab64));
|
|
|
|
#ifdef CONFIG_X86_32
|
|
|
|
if (tmp >> 32) {
|
|
|
|
pr_err("EFI data located above 4GB, disabling EFI.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
} else {
|
|
|
|
efi_system_table_32_t *systab32;
|
|
|
|
|
|
|
|
systab32 = early_ioremap((unsigned long)phys,
|
|
|
|
sizeof(*systab32));
|
|
|
|
if (systab32 == NULL) {
|
|
|
|
pr_err("Couldn't map the system table!\n");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
efi_systab.hdr = systab32->hdr;
|
|
|
|
efi_systab.fw_vendor = systab32->fw_vendor;
|
|
|
|
efi_systab.fw_revision = systab32->fw_revision;
|
|
|
|
efi_systab.con_in_handle = systab32->con_in_handle;
|
|
|
|
efi_systab.con_in = systab32->con_in;
|
|
|
|
efi_systab.con_out_handle = systab32->con_out_handle;
|
|
|
|
efi_systab.con_out = systab32->con_out;
|
|
|
|
efi_systab.stderr_handle = systab32->stderr_handle;
|
|
|
|
efi_systab.stderr = systab32->stderr;
|
|
|
|
efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
|
|
|
|
efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
|
|
|
|
efi_systab.nr_tables = systab32->nr_tables;
|
|
|
|
efi_systab.tables = systab32->tables;
|
|
|
|
|
|
|
|
early_iounmap(systab32, sizeof(*systab32));
|
2012-02-13 05:24:28 +08:00
|
|
|
}
|
2012-02-13 05:24:29 +08:00
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
efi.systab = &efi_systab;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Verify the EFI Table
|
|
|
|
*/
|
2012-02-13 05:24:28 +08:00
|
|
|
if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("System table signature incorrect!\n");
|
2012-02-13 05:24:28 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
2008-01-30 20:31:19 +08:00
|
|
|
if ((efi.systab->hdr.revision >> 16) == 0)
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Warning: System table version "
|
2008-01-30 20:31:19 +08:00
|
|
|
"%d.%02d, expected 1.00 or greater!\n",
|
|
|
|
efi.systab->hdr.revision >> 16,
|
|
|
|
efi.systab->hdr.revision & 0xffff);
|
2012-02-13 05:24:28 +08:00
|
|
|
|
|
|
|
return 0;
|
2012-02-13 05:24:25 +08:00
|
|
|
}
|
2008-01-30 20:31:19 +08:00
|
|
|
|
2012-02-13 05:24:28 +08:00
|
|
|
static int __init efi_runtime_init(void)
|
2012-02-13 05:24:25 +08:00
|
|
|
{
|
|
|
|
efi_runtime_services_t *runtime;
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check out the runtime services table. We need to map
|
|
|
|
* the runtime services table so that we can grab the physical
|
|
|
|
* address of several of the EFI runtime functions, needed to
|
|
|
|
* set the firmware into virtual mode.
|
|
|
|
*/
|
2008-01-30 20:33:44 +08:00
|
|
|
runtime = early_ioremap((unsigned long)efi.systab->runtime,
|
|
|
|
sizeof(efi_runtime_services_t));
|
2012-02-13 05:24:28 +08:00
|
|
|
if (!runtime) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Could not map the runtime service table!\n");
|
2012-02-13 05:24:28 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* We will only need *early* access to the following
|
2012-12-16 07:15:24 +08:00
|
|
|
* two EFI runtime services before set_virtual_address_map
|
2012-02-13 05:24:28 +08:00
|
|
|
* is invoked.
|
|
|
|
*/
|
2012-12-16 07:15:24 +08:00
|
|
|
efi_phys.get_time = (efi_get_time_t *)runtime->get_time;
|
2012-02-13 05:24:28 +08:00
|
|
|
efi_phys.set_virtual_address_map =
|
|
|
|
(efi_set_virtual_address_map_t *)
|
|
|
|
runtime->set_virtual_address_map;
|
2012-12-16 07:15:24 +08:00
|
|
|
/*
|
|
|
|
* Make efi_get_time can be called before entering
|
|
|
|
* virtual mode.
|
|
|
|
*/
|
|
|
|
efi.get_time = phys_efi_get_time;
|
2008-01-30 20:33:44 +08:00
|
|
|
early_iounmap(runtime, sizeof(efi_runtime_services_t));
|
2012-02-13 05:24:28 +08:00
|
|
|
|
|
|
|
return 0;
|
2012-02-13 05:24:25 +08:00
|
|
|
}
|
2008-01-30 20:31:19 +08:00
|
|
|
|
2012-02-13 05:24:28 +08:00
|
|
|
static int __init efi_memmap_init(void)
|
2012-02-13 05:24:25 +08:00
|
|
|
{
|
2008-01-30 20:31:19 +08:00
|
|
|
/* Map the EFI memory map */
|
2008-01-30 20:33:44 +08:00
|
|
|
memmap.map = early_ioremap((unsigned long)memmap.phys_map,
|
|
|
|
memmap.nr_map * memmap.desc_size);
|
2012-02-13 05:24:28 +08:00
|
|
|
if (memmap.map == NULL) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Could not map the memory map!\n");
|
2012-02-13 05:24:28 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2008-01-30 20:31:19 +08:00
|
|
|
memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
|
2008-10-03 06:32:06 +08:00
|
|
|
|
2008-06-25 20:44:46 +08:00
|
|
|
if (add_efi_memmap)
|
|
|
|
do_add_efi_memmap();
|
2012-02-13 05:24:28 +08:00
|
|
|
|
|
|
|
return 0;
|
2012-02-13 05:24:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void __init efi_init(void)
|
|
|
|
{
|
|
|
|
efi_char16_t *c16;
|
|
|
|
char vendor[100] = "unknown";
|
|
|
|
int i = 0;
|
|
|
|
void *tmp;
|
|
|
|
|
|
|
|
#ifdef CONFIG_X86_32
|
2012-02-13 05:24:29 +08:00
|
|
|
if (boot_params.efi_info.efi_systab_hi ||
|
|
|
|
boot_params.efi_info.efi_memmap_hi) {
|
|
|
|
pr_info("Table located above 4GB, disabling EFI.\n");
|
|
|
|
return;
|
|
|
|
}
|
2012-02-13 05:24:25 +08:00
|
|
|
efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
|
|
|
|
#else
|
|
|
|
efi_phys.systab = (efi_system_table_t *)
|
2012-02-13 05:24:29 +08:00
|
|
|
(boot_params.efi_info.efi_systab |
|
|
|
|
((__u64)boot_params.efi_info.efi_systab_hi<<32));
|
2012-02-13 05:24:25 +08:00
|
|
|
#endif
|
|
|
|
|
2012-11-14 17:42:35 +08:00
|
|
|
if (efi_systab_init(efi_phys.systab))
|
2012-02-13 05:24:28 +08:00
|
|
|
return;
|
2012-11-14 17:42:35 +08:00
|
|
|
|
|
|
|
set_bit(EFI_SYSTEM_TABLES, &x86_efi_facility);
|
2012-02-13 05:24:25 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Show what we know for posterity
|
|
|
|
*/
|
|
|
|
c16 = tmp = early_ioremap(efi.systab->fw_vendor, 2);
|
|
|
|
if (c16) {
|
|
|
|
for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
|
|
|
|
vendor[i] = *c16++;
|
|
|
|
vendor[i] = '\0';
|
|
|
|
} else
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("Could not map the firmware vendor!\n");
|
2012-02-13 05:24:25 +08:00
|
|
|
early_iounmap(tmp, 2);
|
|
|
|
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_info("EFI v%u.%.02u by %s\n",
|
|
|
|
efi.systab->hdr.revision >> 16,
|
|
|
|
efi.systab->hdr.revision & 0xffff, vendor);
|
2012-02-13 05:24:25 +08:00
|
|
|
|
2013-09-05 18:34:54 +08:00
|
|
|
if (efi_config_init(arch_tables))
|
2012-02-13 05:24:28 +08:00
|
|
|
return;
|
2012-11-14 17:42:35 +08:00
|
|
|
|
|
|
|
set_bit(EFI_CONFIG_TABLES, &x86_efi_facility);
|
2012-02-13 05:24:25 +08:00
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
/*
|
|
|
|
* Note: We currently don't support runtime services on an EFI
|
|
|
|
* that doesn't match the kernel 32/64-bit mode.
|
|
|
|
*/
|
|
|
|
|
2012-10-25 01:00:44 +08:00
|
|
|
if (!efi_is_native())
|
2012-02-13 05:24:29 +08:00
|
|
|
pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
|
2012-11-14 17:42:35 +08:00
|
|
|
else {
|
2013-02-21 04:36:12 +08:00
|
|
|
if (disable_runtime || efi_runtime_init())
|
2012-11-14 17:42:35 +08:00
|
|
|
return;
|
|
|
|
set_bit(EFI_RUNTIME_SERVICES, &x86_efi_facility);
|
2012-02-13 05:24:28 +08:00
|
|
|
}
|
2012-02-13 05:24:25 +08:00
|
|
|
|
2012-11-14 17:42:35 +08:00
|
|
|
if (efi_memmap_init())
|
2012-02-13 05:24:28 +08:00
|
|
|
return;
|
2012-11-14 17:42:35 +08:00
|
|
|
|
|
|
|
set_bit(EFI_MEMMAP, &x86_efi_facility);
|
|
|
|
|
2012-12-16 07:15:24 +08:00
|
|
|
#ifdef CONFIG_X86_32
|
2012-10-25 01:00:44 +08:00
|
|
|
if (efi_is_native()) {
|
2012-02-13 05:24:29 +08:00
|
|
|
x86_platform.get_wallclock = efi_get_time;
|
|
|
|
x86_platform.set_wallclock = efi_set_rtc_mmss;
|
|
|
|
}
|
2012-12-16 07:15:24 +08:00
|
|
|
#endif
|
2009-09-10 10:48:56 +08:00
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
#if EFI_DEBUG
|
|
|
|
print_efi_memmap();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-09-29 08:57:05 +08:00
|
|
|
void __init efi_late_init(void)
|
|
|
|
{
|
|
|
|
efi_bgrt_init();
|
|
|
|
}
|
|
|
|
|
2011-05-06 03:19:43 +08:00
|
|
|
void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
|
|
|
|
{
|
|
|
|
u64 addr, npages;
|
|
|
|
|
|
|
|
addr = md->virt_addr;
|
|
|
|
npages = md->num_pages;
|
|
|
|
|
|
|
|
memrange_efi_to_native(&addr, &npages);
|
|
|
|
|
|
|
|
if (executable)
|
|
|
|
set_memory_x(addr, npages);
|
|
|
|
else
|
|
|
|
set_memory_nx(addr, npages);
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:33:55 +08:00
|
|
|
static void __init runtime_code_page_mkexec(void)
|
|
|
|
{
|
|
|
|
efi_memory_desc_t *md;
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
/* Make EFI runtime service code area executable */
|
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
md = p;
|
2008-02-04 23:48:06 +08:00
|
|
|
|
|
|
|
if (md->type != EFI_RUNTIME_SERVICES_CODE)
|
|
|
|
continue;
|
|
|
|
|
2011-05-06 03:19:43 +08:00
|
|
|
efi_set_executable(md, true);
|
2008-01-30 20:33:55 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-19 20:25:46 +08:00
|
|
|
void efi_memory_uc(u64 addr, unsigned long size)
|
|
|
|
{
|
|
|
|
unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
|
|
|
|
u64 npages;
|
|
|
|
|
|
|
|
npages = round_up(size, page_shift) / page_shift;
|
|
|
|
memrange_efi_to_native(&addr, &npages);
|
|
|
|
set_memory_uc(addr, npages);
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
/*
|
|
|
|
* This function will switch the EFI runtime services to virtual mode.
|
|
|
|
* Essentially, look through the EFI memmap and map every region that
|
|
|
|
* has the runtime attribute bit set in its memory descriptor and update
|
|
|
|
* that memory descriptor with the virtual address obtained from ioremap().
|
|
|
|
* This enables the runtime services to be called without having to
|
|
|
|
* thunk back into physical mode for every invocation.
|
|
|
|
*/
|
|
|
|
void __init efi_enter_virtual_mode(void)
|
|
|
|
{
|
2011-05-06 03:19:44 +08:00
|
|
|
efi_memory_desc_t *md, *prev_md = NULL;
|
2008-01-30 20:31:19 +08:00
|
|
|
efi_status_t status;
|
2008-02-04 23:48:06 +08:00
|
|
|
unsigned long size;
|
2012-11-17 11:38:48 +08:00
|
|
|
u64 end, systab, start_pfn, end_pfn;
|
2011-05-06 03:19:45 +08:00
|
|
|
void *p, *va, *new_memmap = NULL;
|
|
|
|
int count = 0;
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
efi.systab = NULL;
|
2011-05-06 03:19:44 +08:00
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
/*
|
|
|
|
* We don't do virtual mode, since we don't do runtime services, on
|
|
|
|
* non-native EFI
|
|
|
|
*/
|
|
|
|
|
2012-10-25 01:00:44 +08:00
|
|
|
if (!efi_is_native()) {
|
2012-09-29 08:55:44 +08:00
|
|
|
efi_unmap_memmap();
|
|
|
|
return;
|
|
|
|
}
|
2012-02-13 05:24:29 +08:00
|
|
|
|
2011-05-06 03:19:44 +08:00
|
|
|
/* Merge contiguous regions of the same type and attribute */
|
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
u64 prev_size;
|
|
|
|
md = p;
|
|
|
|
|
|
|
|
if (!prev_md) {
|
|
|
|
prev_md = md;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (prev_md->type != md->type ||
|
|
|
|
prev_md->attribute != md->attribute) {
|
|
|
|
prev_md = md;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
|
|
|
|
|
|
|
|
if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
|
|
|
|
prev_md->num_pages += md->num_pages;
|
|
|
|
md->type = EFI_RESERVED_TYPE;
|
|
|
|
md->attribute = 0;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
prev_md = md;
|
|
|
|
}
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
md = p;
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 21:53:13 +08:00
|
|
|
if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
|
|
|
|
md->type != EFI_BOOT_SERVICES_CODE &&
|
|
|
|
md->type != EFI_BOOT_SERVICES_DATA)
|
2008-01-30 20:31:19 +08:00
|
|
|
continue;
|
2008-02-04 23:48:06 +08:00
|
|
|
|
|
|
|
size = md->num_pages << EFI_PAGE_SHIFT;
|
|
|
|
end = md->phys_addr + size;
|
|
|
|
|
2012-11-17 11:38:48 +08:00
|
|
|
start_pfn = PFN_DOWN(md->phys_addr);
|
2009-03-04 10:58:33 +08:00
|
|
|
end_pfn = PFN_UP(end);
|
2012-11-17 11:38:48 +08:00
|
|
|
if (pfn_range_is_mapped(start_pfn, end_pfn)) {
|
2008-02-04 23:48:06 +08:00
|
|
|
va = __va(md->phys_addr);
|
2012-10-19 20:25:46 +08:00
|
|
|
|
|
|
|
if (!(md->attribute & EFI_MEMORY_WB))
|
|
|
|
efi_memory_uc((u64)(unsigned long)va, size);
|
|
|
|
} else
|
|
|
|
va = efi_ioremap(md->phys_addr, size,
|
|
|
|
md->type, md->attribute);
|
2008-02-04 23:48:06 +08:00
|
|
|
|
|
|
|
md->virt_addr = (u64) (unsigned long) va;
|
|
|
|
|
|
|
|
if (!va) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_err("ioremap of 0x%llX failed!\n",
|
2008-01-30 20:31:19 +08:00
|
|
|
(unsigned long long)md->phys_addr);
|
2008-02-04 23:48:06 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
systab = (u64) (unsigned long) efi_phys.systab;
|
|
|
|
if (md->phys_addr <= systab && systab < end) {
|
|
|
|
systab += md->virt_addr - md->phys_addr;
|
|
|
|
efi.systab = (efi_system_table_t *) (unsigned long) systab;
|
|
|
|
}
|
2011-05-06 03:19:45 +08:00
|
|
|
new_memmap = krealloc(new_memmap,
|
|
|
|
(count + 1) * memmap.desc_size,
|
|
|
|
GFP_KERNEL);
|
|
|
|
memcpy(new_memmap + (count * memmap.desc_size), md,
|
|
|
|
memmap.desc_size);
|
|
|
|
count++;
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
BUG_ON(!efi.systab);
|
|
|
|
|
|
|
|
status = phys_efi_set_virtual_address_map(
|
2011-05-06 03:19:45 +08:00
|
|
|
memmap.desc_size * count,
|
2008-01-30 20:31:19 +08:00
|
|
|
memmap.desc_size,
|
|
|
|
memmap.desc_version,
|
2011-05-06 03:19:45 +08:00
|
|
|
(efi_memory_desc_t *)__pa(new_memmap));
|
2008-01-30 20:31:19 +08:00
|
|
|
|
|
|
|
if (status != EFI_SUCCESS) {
|
2012-02-13 05:24:26 +08:00
|
|
|
pr_alert("Unable to switch EFI into virtual mode "
|
|
|
|
"(status=%lx)!\n", status);
|
2008-01-30 20:31:19 +08:00
|
|
|
panic("EFI call to SetVirtualAddressMap() failed!");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now that EFI is in virtual mode, update the function
|
|
|
|
* pointers in the runtime service table to the new virtual addresses.
|
|
|
|
*
|
|
|
|
* Call EFI services through wrapper functions.
|
|
|
|
*/
|
2013-01-25 18:07:25 +08:00
|
|
|
efi.runtime_version = efi_systab.hdr.revision;
|
2008-01-30 20:31:19 +08:00
|
|
|
efi.get_time = virt_efi_get_time;
|
|
|
|
efi.set_time = virt_efi_set_time;
|
|
|
|
efi.get_wakeup_time = virt_efi_get_wakeup_time;
|
|
|
|
efi.set_wakeup_time = virt_efi_set_wakeup_time;
|
|
|
|
efi.get_variable = virt_efi_get_variable;
|
|
|
|
efi.get_next_variable = virt_efi_get_next_variable;
|
|
|
|
efi.set_variable = virt_efi_set_variable;
|
|
|
|
efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
|
|
|
|
efi.reset_system = virt_efi_reset_system;
|
2011-05-06 03:19:42 +08:00
|
|
|
efi.set_virtual_address_map = NULL;
|
2011-06-07 03:36:25 +08:00
|
|
|
efi.query_variable_info = virt_efi_query_variable_info;
|
|
|
|
efi.update_capsule = virt_efi_update_capsule;
|
|
|
|
efi.query_capsule_caps = virt_efi_query_capsule_caps;
|
2008-02-13 17:22:41 +08:00
|
|
|
if (__supported_pte_mask & _PAGE_NX)
|
|
|
|
runtime_code_page_mkexec();
|
2012-02-13 05:24:29 +08:00
|
|
|
|
2011-05-06 03:19:45 +08:00
|
|
|
kfree(new_memmap);
|
2013-06-02 04:06:20 +08:00
|
|
|
|
|
|
|
/* clean DUMMY object */
|
|
|
|
efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
|
|
|
|
EFI_VARIABLE_NON_VOLATILE |
|
|
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS |
|
|
|
|
EFI_VARIABLE_RUNTIME_ACCESS,
|
|
|
|
0, NULL);
|
2008-01-30 20:31:19 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convenience functions to obtain memory types and attributes
|
|
|
|
*/
|
|
|
|
u32 efi_mem_type(unsigned long phys_addr)
|
|
|
|
{
|
|
|
|
efi_memory_desc_t *md;
|
|
|
|
void *p;
|
|
|
|
|
2012-11-14 17:42:35 +08:00
|
|
|
if (!efi_enabled(EFI_MEMMAP))
|
|
|
|
return 0;
|
|
|
|
|
2008-01-30 20:31:19 +08:00
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
md = p;
|
|
|
|
if ((md->phys_addr <= phys_addr) &&
|
|
|
|
(phys_addr < (md->phys_addr +
|
|
|
|
(md->num_pages << EFI_PAGE_SHIFT))))
|
|
|
|
return md->type;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 efi_mem_attributes(unsigned long phys_addr)
|
|
|
|
{
|
|
|
|
efi_memory_desc_t *md;
|
|
|
|
void *p;
|
|
|
|
|
|
|
|
for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
|
|
|
|
md = p;
|
|
|
|
if ((md->phys_addr <= phys_addr) &&
|
|
|
|
(phys_addr < (md->phys_addr +
|
|
|
|
(md->num_pages << EFI_PAGE_SHIFT))))
|
|
|
|
return md->attribute;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2013-03-25 17:14:30 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some firmware has serious problems when using more than 50% of the EFI
|
|
|
|
* variable store, i.e. it triggers bugs that can brick machines. Ensure that
|
|
|
|
* we never use more than this safe limit.
|
|
|
|
*
|
|
|
|
* Return EFI_SUCCESS if it is safe to write 'size' bytes to the variable
|
|
|
|
* store.
|
|
|
|
*/
|
|
|
|
efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
u64 storage_size, remaining_size, max_size;
|
|
|
|
|
2013-06-02 04:06:20 +08:00
|
|
|
if (!(attributes & EFI_VARIABLE_NON_VOLATILE))
|
|
|
|
return 0;
|
|
|
|
|
2013-03-25 17:14:30 +08:00
|
|
|
status = efi.query_variable_info(attributes, &storage_size,
|
|
|
|
&remaining_size, &max_size);
|
|
|
|
if (status != EFI_SUCCESS)
|
|
|
|
return status;
|
|
|
|
|
2013-04-16 04:09:47 +08:00
|
|
|
/*
|
|
|
|
* Some firmware implementations refuse to boot if there's insufficient
|
|
|
|
* space in the variable store. We account for that by refusing the
|
|
|
|
* write if permitting it would reduce the available space to under
|
2013-06-02 04:06:20 +08:00
|
|
|
* 5KB. This figure was provided by Samsung, so should be safe.
|
2013-04-16 04:09:47 +08:00
|
|
|
*/
|
2013-06-02 04:06:20 +08:00
|
|
|
if ((remaining_size - size < EFI_MIN_RESERVE) &&
|
|
|
|
!efi_no_storage_paranoia) {
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Triggering garbage collection may require that the firmware
|
|
|
|
* generate a real EFI_OUT_OF_RESOURCES error. We can force
|
|
|
|
* that by attempting to use more space than is available.
|
|
|
|
*/
|
|
|
|
unsigned long dummy_size = remaining_size + 1024;
|
2013-06-17 04:27:12 +08:00
|
|
|
void *dummy = kzalloc(dummy_size, GFP_ATOMIC);
|
|
|
|
|
|
|
|
if (!dummy)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
2013-06-02 04:06:20 +08:00
|
|
|
|
|
|
|
status = efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
|
|
|
|
EFI_VARIABLE_NON_VOLATILE |
|
|
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS |
|
|
|
|
EFI_VARIABLE_RUNTIME_ACCESS,
|
|
|
|
dummy_size, dummy);
|
|
|
|
|
|
|
|
if (status == EFI_SUCCESS) {
|
|
|
|
/*
|
|
|
|
* This should have failed, so if it didn't make sure
|
|
|
|
* that we delete it...
|
|
|
|
*/
|
|
|
|
efi.set_variable(efi_dummy_name, &EFI_DUMMY_GUID,
|
|
|
|
EFI_VARIABLE_NON_VOLATILE |
|
|
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS |
|
|
|
|
EFI_VARIABLE_RUNTIME_ACCESS,
|
|
|
|
0, dummy);
|
|
|
|
}
|
2013-04-10 16:59:34 +08:00
|
|
|
|
2013-06-17 04:27:12 +08:00
|
|
|
kfree(dummy);
|
|
|
|
|
2013-06-02 04:06:20 +08:00
|
|
|
/*
|
|
|
|
* The runtime code may now have triggered a garbage collection
|
|
|
|
* run, so check the variable info again
|
|
|
|
*/
|
|
|
|
status = efi.query_variable_info(attributes, &storage_size,
|
|
|
|
&remaining_size, &max_size);
|
2013-04-17 07:00:53 +08:00
|
|
|
|
2013-06-02 04:06:20 +08:00
|
|
|
if (status != EFI_SUCCESS)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* There still isn't enough room, so return an error
|
|
|
|
*/
|
|
|
|
if (remaining_size - size < EFI_MIN_RESERVE)
|
|
|
|
return EFI_OUT_OF_RESOURCES;
|
|
|
|
}
|
2013-03-25 17:14:30 +08:00
|
|
|
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
2013-04-16 22:31:09 +08:00
|
|
|
EXPORT_SYMBOL_GPL(efi_query_variable_store);
|