2014-06-26 12:09:05 +02:00
|
|
|
/*
|
|
|
|
* runtime-wrappers.c - Runtime Services function call wrappers
|
|
|
|
*
|
|
|
|
* Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org>
|
|
|
|
*
|
|
|
|
* Split off from arch/x86/platform/efi/efi.c
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
|
|
|
|
* Copyright (C) 1999-2002 Hewlett-Packard Co.
|
|
|
|
* Copyright (C) 2005-2008 Intel Co.
|
|
|
|
* Copyright (C) 2013 SuSE Labs
|
|
|
|
*
|
|
|
|
* This file is released under the GPLv2.
|
|
|
|
*/
|
|
|
|
|
2014-08-04 18:16:00 +02:00
|
|
|
#include <linux/bug.h>
|
2014-06-26 12:09:05 +02:00
|
|
|
#include <linux/efi.h>
|
efi/runtime-wrappers: Detect firmware IRQ flag corruption
The UEFI spec allows runtime services to be called with interrupts
masked or unmasked, and if a runtime service function needs to mask
interrupts, it must restore the mask to its original state before
returning (i.e. from the PoV of the OS, this does not change across a
call). Firmware should never unmask exceptions, as these may then be
taken by the OS unexpectedly.
Unfortunately, some firmware has been seen to unmask IRQs (and
potentially other maskable exceptions) across runtime services calls,
leaving IRQ flags corrupted after returning from a runtime services
function call. This may be detected by the IRQ tracing code, but often
goes unnoticed, leaving a potentially disastrous bug hidden.
This patch detects when the IRQ flags are corrupted by an EFI runtime
services call, logging the call and specific corruption to the console.
While restoring the expected value of the flags is insufficient to avoid
problems, we do so to avoid redundant warnings from elsewhere (e.g. IRQ
tracing).
The set of bits in flags which we want to check is architecture-specific
(e.g. we want to check FIQ on arm64, but not the zero flag on x86), so
each arch must provide ARCH_EFI_IRQ_FLAGS_MASK to describe those. In the
absence of this mask, the check is a no-op, and we redundantly save the
flags twice, but that will be short-lived as subsequent patches
will implement this and remove the scaffolding.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Leif Lindholm <leif.lindholm@linaro.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Robin Murphy <robin.murphy@arm.com>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-efi@vger.kernel.org
Link: http://lkml.kernel.org/r/1461614832-17633-37-git-send-email-matt@codeblueprint.co.uk
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-04-25 22:07:08 +02:00
|
|
|
#include <linux/irqflags.h>
|
2014-08-04 18:16:00 +02:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/spinlock.h>
|
efi/runtime-wrappers: Detect firmware IRQ flag corruption
The UEFI spec allows runtime services to be called with interrupts
masked or unmasked, and if a runtime service function needs to mask
interrupts, it must restore the mask to its original state before
returning (i.e. from the PoV of the OS, this does not change across a
call). Firmware should never unmask exceptions, as these may then be
taken by the OS unexpectedly.
Unfortunately, some firmware has been seen to unmask IRQs (and
potentially other maskable exceptions) across runtime services calls,
leaving IRQ flags corrupted after returning from a runtime services
function call. This may be detected by the IRQ tracing code, but often
goes unnoticed, leaving a potentially disastrous bug hidden.
This patch detects when the IRQ flags are corrupted by an EFI runtime
services call, logging the call and specific corruption to the console.
While restoring the expected value of the flags is insufficient to avoid
problems, we do so to avoid redundant warnings from elsewhere (e.g. IRQ
tracing).
The set of bits in flags which we want to check is architecture-specific
(e.g. we want to check FIQ on arm64, but not the zero flag on x86), so
each arch must provide ARCH_EFI_IRQ_FLAGS_MASK to describe those. In the
absence of this mask, the check is a no-op, and we redundantly save the
flags twice, but that will be short-lived as subsequent patches
will implement this and remove the scaffolding.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Leif Lindholm <leif.lindholm@linaro.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Robin Murphy <robin.murphy@arm.com>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-efi@vger.kernel.org
Link: http://lkml.kernel.org/r/1461614832-17633-37-git-send-email-matt@codeblueprint.co.uk
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-04-25 22:07:08 +02:00
|
|
|
#include <linux/stringify.h>
|
2014-06-26 12:09:05 +02:00
|
|
|
#include <asm/efi.h>
|
|
|
|
|
2016-06-25 09:20:27 +02:00
|
|
|
/*
|
|
|
|
* Wrap around the new efi_call_virt_generic() macros so that the
|
|
|
|
* code doesn't get too cluttered:
|
|
|
|
*/
|
|
|
|
#define efi_call_virt(f, args...) \
|
|
|
|
efi_call_virt_pointer(efi.systab->runtime, f, args)
|
|
|
|
#define __efi_call_virt(f, args...) \
|
|
|
|
__efi_call_virt_pointer(efi.systab->runtime, f, args)
|
|
|
|
|
|
|
|
void efi_call_virt_check_flags(unsigned long flags, const char *call)
|
efi/runtime-wrappers: Detect firmware IRQ flag corruption
The UEFI spec allows runtime services to be called with interrupts
masked or unmasked, and if a runtime service function needs to mask
interrupts, it must restore the mask to its original state before
returning (i.e. from the PoV of the OS, this does not change across a
call). Firmware should never unmask exceptions, as these may then be
taken by the OS unexpectedly.
Unfortunately, some firmware has been seen to unmask IRQs (and
potentially other maskable exceptions) across runtime services calls,
leaving IRQ flags corrupted after returning from a runtime services
function call. This may be detected by the IRQ tracing code, but often
goes unnoticed, leaving a potentially disastrous bug hidden.
This patch detects when the IRQ flags are corrupted by an EFI runtime
services call, logging the call and specific corruption to the console.
While restoring the expected value of the flags is insufficient to avoid
problems, we do so to avoid redundant warnings from elsewhere (e.g. IRQ
tracing).
The set of bits in flags which we want to check is architecture-specific
(e.g. we want to check FIQ on arm64, but not the zero flag on x86), so
each arch must provide ARCH_EFI_IRQ_FLAGS_MASK to describe those. In the
absence of this mask, the check is a no-op, and we redundantly save the
flags twice, but that will be short-lived as subsequent patches
will implement this and remove the scaffolding.
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Leif Lindholm <leif.lindholm@linaro.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Robin Murphy <robin.murphy@arm.com>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Will Deacon <will.deacon@arm.com>
Cc: linux-efi@vger.kernel.org
Link: http://lkml.kernel.org/r/1461614832-17633-37-git-send-email-matt@codeblueprint.co.uk
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-04-25 22:07:08 +02:00
|
|
|
{
|
|
|
|
unsigned long cur_flags, mismatch;
|
|
|
|
|
|
|
|
local_save_flags(cur_flags);
|
|
|
|
|
|
|
|
mismatch = flags ^ cur_flags;
|
|
|
|
if (!WARN_ON_ONCE(mismatch & ARCH_EFI_IRQ_FLAGS_MASK))
|
|
|
|
return;
|
|
|
|
|
|
|
|
add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_NOW_UNRELIABLE);
|
|
|
|
pr_err_ratelimited(FW_BUG "IRQ flags corrupted (0x%08lx=>0x%08lx) by EFI %s\n",
|
|
|
|
flags, cur_flags, call);
|
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
2014-08-04 18:16:00 +02:00
|
|
|
/*
|
|
|
|
* According to section 7.1 of the UEFI spec, Runtime Services are not fully
|
|
|
|
* reentrant, and there are particular combinations of calls that need to be
|
|
|
|
* serialized. (source: UEFI Specification v2.4A)
|
|
|
|
*
|
|
|
|
* Table 31. Rules for Reentry Into Runtime Services
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | If previous call is busy in | Forbidden to call |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | Any | SetVirtualAddressMap() |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | ConvertPointer() | ConvertPointer() |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | SetVariable() | ResetSystem() |
|
|
|
|
* | UpdateCapsule() | |
|
|
|
|
* | SetTime() | |
|
|
|
|
* | SetWakeupTime() | |
|
|
|
|
* | GetNextHighMonotonicCount() | |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | GetVariable() | GetVariable() |
|
|
|
|
* | GetNextVariableName() | GetNextVariableName() |
|
|
|
|
* | SetVariable() | SetVariable() |
|
|
|
|
* | QueryVariableInfo() | QueryVariableInfo() |
|
|
|
|
* | UpdateCapsule() | UpdateCapsule() |
|
|
|
|
* | QueryCapsuleCapabilities() | QueryCapsuleCapabilities() |
|
|
|
|
* | GetNextHighMonotonicCount() | GetNextHighMonotonicCount() |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
* | GetTime() | GetTime() |
|
|
|
|
* | SetTime() | SetTime() |
|
|
|
|
* | GetWakeupTime() | GetWakeupTime() |
|
|
|
|
* | SetWakeupTime() | SetWakeupTime() |
|
|
|
|
* +------------------------------------+-------------------------------+
|
|
|
|
*
|
|
|
|
* Due to the fact that the EFI pstore may write to the variable store in
|
|
|
|
* interrupt context, we need to use a spinlock for at least the groups that
|
|
|
|
* contain SetVariable() and QueryVariableInfo(). That leaves little else, as
|
|
|
|
* none of the remaining functions are actually ever called at runtime.
|
|
|
|
* So let's just use a single spinlock to serialize all Runtime Services calls.
|
|
|
|
*/
|
|
|
|
static DEFINE_SPINLOCK(efi_runtime_lock);
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
status = efi_call_virt(get_time, tm, tc);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_time(efi_time_t *tm)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
status = efi_call_virt(set_time, tm);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
|
|
|
|
efi_bool_t *pending,
|
|
|
|
efi_time_t *tm)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
status = efi_call_virt(get_wakeup_time, enabled, pending, tm);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
status = efi_call_virt(set_wakeup_time, enabled, tm);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_variable(efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor,
|
|
|
|
u32 *attr,
|
|
|
|
unsigned long *data_size,
|
|
|
|
void *data)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(get_variable, name, vendor, attr, data_size,
|
|
|
|
data);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
|
|
|
|
efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(get_next_variable, name_size, name, vendor);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_set_variable(efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor,
|
|
|
|
u32 attr,
|
|
|
|
unsigned long data_size,
|
|
|
|
void *data)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(set_variable, name, vendor, attr, data_size,
|
|
|
|
data);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
2014-09-30 22:58:52 +02:00
|
|
|
static efi_status_t
|
|
|
|
virt_efi_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor,
|
|
|
|
u32 attr, unsigned long data_size,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
if (!spin_trylock(&efi_runtime_lock))
|
2014-09-30 22:58:52 +02:00
|
|
|
return EFI_NOT_READY;
|
|
|
|
|
|
|
|
status = efi_call_virt(set_variable, name, vendor, attr, data_size,
|
|
|
|
data);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-09-30 22:58:52 +02:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
static efi_status_t virt_efi_query_variable_info(u32 attr,
|
|
|
|
u64 *storage_space,
|
|
|
|
u64 *remaining_space,
|
|
|
|
u64 *max_variable_size)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(query_variable_info, attr, storage_space,
|
|
|
|
remaining_space, max_variable_size);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
2016-02-01 23:06:57 +01:00
|
|
|
static efi_status_t
|
|
|
|
virt_efi_query_variable_info_nonblocking(u32 attr,
|
|
|
|
u64 *storage_space,
|
|
|
|
u64 *remaining_space,
|
|
|
|
u64 *max_variable_size)
|
|
|
|
{
|
|
|
|
efi_status_t status;
|
|
|
|
|
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
if (!spin_trylock(&efi_runtime_lock))
|
2016-02-01 23:06:57 +01:00
|
|
|
return EFI_NOT_READY;
|
|
|
|
|
|
|
|
status = efi_call_virt(query_variable_info, attr, storage_space,
|
|
|
|
remaining_space, max_variable_size);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2016-02-01 23:06:57 +01:00
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(get_next_high_mono_count, count);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void virt_efi_reset_system(int reset_type,
|
|
|
|
efi_status_t status,
|
|
|
|
unsigned long data_size,
|
|
|
|
efi_char16_t *data)
|
|
|
|
{
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
__efi_call_virt(reset_system, reset_type, status, data_size, data);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
unsigned long sg_list)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(update_capsule, capsules, count, sg_list);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
u64 *max_size,
|
|
|
|
int *reset_type)
|
|
|
|
{
|
2014-08-04 18:16:00 +02:00
|
|
|
efi_status_t status;
|
|
|
|
|
2014-06-26 12:09:05 +02:00
|
|
|
if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
|
|
|
|
return EFI_UNSUPPORTED;
|
|
|
|
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_lock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
status = efi_call_virt(query_capsule_caps, capsules, count, max_size,
|
|
|
|
reset_type);
|
2016-02-17 13:35:55 +01:00
|
|
|
spin_unlock(&efi_runtime_lock);
|
2014-08-04 18:16:00 +02:00
|
|
|
return status;
|
2014-06-26 12:09:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void efi_native_runtime_setup(void)
|
|
|
|
{
|
|
|
|
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;
|
2014-09-30 22:58:52 +02:00
|
|
|
efi.set_variable_nonblocking = virt_efi_set_variable_nonblocking;
|
2014-06-26 12:09:05 +02:00
|
|
|
efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
|
|
|
|
efi.reset_system = virt_efi_reset_system;
|
|
|
|
efi.query_variable_info = virt_efi_query_variable_info;
|
2016-02-01 23:06:57 +01:00
|
|
|
efi.query_variable_info_nonblocking = virt_efi_query_variable_info_nonblocking;
|
2014-06-26 12:09:05 +02:00
|
|
|
efi.update_capsule = virt_efi_update_capsule;
|
|
|
|
efi.query_capsule_caps = virt_efi_query_capsule_caps;
|
|
|
|
}
|