2 * runtime-wrappers.c - Runtime Services function call wrappers
4 * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org>
6 * Split off from arch/x86/platform/efi/efi.c
8 * Copyright (C) 1999 VA Linux Systems
9 * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
10 * Copyright (C) 1999-2002 Hewlett-Packard Co.
11 * Copyright (C) 2005-2008 Intel Co.
12 * Copyright (C) 2013 SuSE Labs
14 * This file is released under the GPLv2.
17 #include <linux/bug.h>
18 #include <linux/efi.h>
19 #include <linux/mutex.h>
20 #include <linux/spinlock.h>
24 * According to section 7.1 of the UEFI spec, Runtime Services are not fully
25 * reentrant, and there are particular combinations of calls that need to be
26 * serialized. (source: UEFI Specification v2.4A)
28 * Table 31. Rules for Reentry Into Runtime Services
29 * +------------------------------------+-------------------------------+
30 * | If previous call is busy in | Forbidden to call |
31 * +------------------------------------+-------------------------------+
32 * | Any | SetVirtualAddressMap() |
33 * +------------------------------------+-------------------------------+
34 * | ConvertPointer() | ConvertPointer() |
35 * +------------------------------------+-------------------------------+
36 * | SetVariable() | ResetSystem() |
37 * | UpdateCapsule() | |
39 * | SetWakeupTime() | |
40 * | GetNextHighMonotonicCount() | |
41 * +------------------------------------+-------------------------------+
42 * | GetVariable() | GetVariable() |
43 * | GetNextVariableName() | GetNextVariableName() |
44 * | SetVariable() | SetVariable() |
45 * | QueryVariableInfo() | QueryVariableInfo() |
46 * | UpdateCapsule() | UpdateCapsule() |
47 * | QueryCapsuleCapabilities() | QueryCapsuleCapabilities() |
48 * | GetNextHighMonotonicCount() | GetNextHighMonotonicCount() |
49 * +------------------------------------+-------------------------------+
50 * | GetTime() | GetTime() |
51 * | SetTime() | SetTime() |
52 * | GetWakeupTime() | GetWakeupTime() |
53 * | SetWakeupTime() | SetWakeupTime() |
54 * +------------------------------------+-------------------------------+
56 * Due to the fact that the EFI pstore may write to the variable store in
57 * interrupt context, we need to use a spinlock for at least the groups that
58 * contain SetVariable() and QueryVariableInfo(). That leaves little else, as
59 * none of the remaining functions are actually ever called at runtime.
60 * So let's just use a single spinlock to serialize all Runtime Services calls.
62 static DEFINE_SPINLOCK(efi_runtime_lock
);
65 * Some runtime services calls can be reentrant under NMI, even if the table
66 * above says they are not. (source: UEFI Specification v2.4A)
68 * Table 32. Functions that may be called after Machine Check, INIT and NMI
69 * +----------------------------+------------------------------------------+
70 * | Function | Called after Machine Check, INIT and NMI |
71 * +----------------------------+------------------------------------------+
72 * | GetTime() | Yes, even if previously busy. |
73 * | GetVariable() | Yes, even if previously busy |
74 * | GetNextVariableName() | Yes, even if previously busy |
75 * | QueryVariableInfo() | Yes, even if previously busy |
76 * | SetVariable() | Yes, even if previously busy |
77 * | UpdateCapsule() | Yes, even if previously busy |
78 * | QueryCapsuleCapabilities() | Yes, even if previously busy |
79 * | ResetSystem() | Yes, even if previously busy |
80 * +----------------------------+------------------------------------------+
82 * In order to prevent deadlocks under NMI, the wrappers for these functions
83 * may only grab the efi_runtime_lock or rtc_lock spinlocks if !efi_in_nmi().
84 * However, not all of the services listed are reachable through NMI code paths,
85 * so the the special handling as suggested by the UEFI spec is only implemented
86 * for QueryVariableInfo() and SetVariable(), as these can be reached in NMI
87 * context through efi_pstore_write().
91 * As per commit ef68c8f87ed1 ("x86: Serialize EFI time accesses on rtc_lock"),
92 * the EFI specification requires that callers of the time related runtime
93 * functions serialize with other CMOS accesses in the kernel, as the EFI time
94 * functions may choose to also use the legacy CMOS RTC.
96 __weak
DEFINE_SPINLOCK(rtc_lock
);
98 static efi_status_t
virt_efi_get_time(efi_time_t
*tm
, efi_time_cap_t
*tc
)
103 spin_lock_irqsave(&rtc_lock
, flags
);
104 spin_lock(&efi_runtime_lock
);
105 status
= efi_call_virt(get_time
, tm
, tc
);
106 spin_unlock(&efi_runtime_lock
);
107 spin_unlock_irqrestore(&rtc_lock
, flags
);
111 static efi_status_t
virt_efi_set_time(efi_time_t
*tm
)
116 spin_lock_irqsave(&rtc_lock
, flags
);
117 spin_lock(&efi_runtime_lock
);
118 status
= efi_call_virt(set_time
, tm
);
119 spin_unlock(&efi_runtime_lock
);
120 spin_unlock_irqrestore(&rtc_lock
, flags
);
124 static efi_status_t
virt_efi_get_wakeup_time(efi_bool_t
*enabled
,
131 spin_lock_irqsave(&rtc_lock
, flags
);
132 spin_lock(&efi_runtime_lock
);
133 status
= efi_call_virt(get_wakeup_time
, enabled
, pending
, tm
);
134 spin_unlock(&efi_runtime_lock
);
135 spin_unlock_irqrestore(&rtc_lock
, flags
);
139 static efi_status_t
virt_efi_set_wakeup_time(efi_bool_t enabled
, efi_time_t
*tm
)
144 spin_lock_irqsave(&rtc_lock
, flags
);
145 spin_lock(&efi_runtime_lock
);
146 status
= efi_call_virt(set_wakeup_time
, enabled
, tm
);
147 spin_unlock(&efi_runtime_lock
);
148 spin_unlock_irqrestore(&rtc_lock
, flags
);
152 static efi_status_t
virt_efi_get_variable(efi_char16_t
*name
,
155 unsigned long *data_size
,
161 spin_lock_irqsave(&efi_runtime_lock
, flags
);
162 status
= efi_call_virt(get_variable
, name
, vendor
, attr
, data_size
,
164 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
168 static efi_status_t
virt_efi_get_next_variable(unsigned long *name_size
,
175 spin_lock_irqsave(&efi_runtime_lock
, flags
);
176 status
= efi_call_virt(get_next_variable
, name_size
, name
, vendor
);
177 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
181 static efi_status_t
virt_efi_set_variable(efi_char16_t
*name
,
184 unsigned long data_size
,
190 spin_lock_irqsave(&efi_runtime_lock
, flags
);
191 status
= efi_call_virt(set_variable
, name
, vendor
, attr
, data_size
,
193 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
198 virt_efi_set_variable_nonblocking(efi_char16_t
*name
, efi_guid_t
*vendor
,
199 u32 attr
, unsigned long data_size
,
205 if (!spin_trylock_irqsave(&efi_runtime_lock
, flags
))
206 return EFI_NOT_READY
;
208 status
= efi_call_virt(set_variable
, name
, vendor
, attr
, data_size
,
210 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
215 static efi_status_t
virt_efi_query_variable_info(u32 attr
,
217 u64
*remaining_space
,
218 u64
*max_variable_size
)
223 if (efi
.runtime_version
< EFI_2_00_SYSTEM_TABLE_REVISION
)
224 return EFI_UNSUPPORTED
;
226 spin_lock_irqsave(&efi_runtime_lock
, flags
);
227 status
= efi_call_virt(query_variable_info
, attr
, storage_space
,
228 remaining_space
, max_variable_size
);
229 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
233 static efi_status_t
virt_efi_get_next_high_mono_count(u32
*count
)
238 spin_lock_irqsave(&efi_runtime_lock
, flags
);
239 status
= efi_call_virt(get_next_high_mono_count
, count
);
240 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
244 static void virt_efi_reset_system(int reset_type
,
246 unsigned long data_size
,
251 spin_lock_irqsave(&efi_runtime_lock
, flags
);
252 __efi_call_virt(reset_system
, reset_type
, status
, data_size
, data
);
253 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
256 static efi_status_t
virt_efi_update_capsule(efi_capsule_header_t
**capsules
,
258 unsigned long sg_list
)
263 if (efi
.runtime_version
< EFI_2_00_SYSTEM_TABLE_REVISION
)
264 return EFI_UNSUPPORTED
;
266 spin_lock_irqsave(&efi_runtime_lock
, flags
);
267 status
= efi_call_virt(update_capsule
, capsules
, count
, sg_list
);
268 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
272 static efi_status_t
virt_efi_query_capsule_caps(efi_capsule_header_t
**capsules
,
280 if (efi
.runtime_version
< EFI_2_00_SYSTEM_TABLE_REVISION
)
281 return EFI_UNSUPPORTED
;
283 spin_lock_irqsave(&efi_runtime_lock
, flags
);
284 status
= efi_call_virt(query_capsule_caps
, capsules
, count
, max_size
,
286 spin_unlock_irqrestore(&efi_runtime_lock
, flags
);
290 void efi_native_runtime_setup(void)
292 efi
.get_time
= virt_efi_get_time
;
293 efi
.set_time
= virt_efi_set_time
;
294 efi
.get_wakeup_time
= virt_efi_get_wakeup_time
;
295 efi
.set_wakeup_time
= virt_efi_set_wakeup_time
;
296 efi
.get_variable
= virt_efi_get_variable
;
297 efi
.get_next_variable
= virt_efi_get_next_variable
;
298 efi
.set_variable
= virt_efi_set_variable
;
299 efi
.set_variable_nonblocking
= virt_efi_set_variable_nonblocking
;
300 efi
.get_next_high_mono_count
= virt_efi_get_next_high_mono_count
;
301 efi
.reset_system
= virt_efi_reset_system
;
302 efi
.query_variable_info
= virt_efi_query_variable_info
;
303 efi
.update_capsule
= virt_efi_update_capsule
;
304 efi
.query_capsule_caps
= virt_efi_query_capsule_caps
;