1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * runtime-wrappers.c - Runtime Services function call wrappers
4  *
5  * Implementation summary:
6  * -----------------------
7  * 1. When user/kernel thread requests to execute efi_runtime_service(),
8  * enqueue work to efi_rts_wq.
9  * 2. Caller thread waits for completion until the work is finished
10  * because it's dependent on the return status and execution of
11  * efi_runtime_service().
12  * For instance, get_variable() and get_next_variable().
13  *
14  * Copyright (C) 2014 Linaro Ltd. <ard.biesheuvel@linaro.org>
15  *
16  * Split off from arch/x86/platform/efi/efi.c
17  *
18  * Copyright (C) 1999 VA Linux Systems
19  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
20  * Copyright (C) 1999-2002 Hewlett-Packard Co.
21  * Copyright (C) 2005-2008 Intel Co.
22  * Copyright (C) 2013 SuSE Labs
23  */
24 
25 #define pr_fmt(fmt)	"efi: " fmt
26 
27 #include <linux/bug.h>
28 #include <linux/efi.h>
29 #include <linux/irqflags.h>
30 #include <linux/mutex.h>
31 #include <linux/semaphore.h>
32 #include <linux/stringify.h>
33 #include <linux/workqueue.h>
34 #include <linux/completion.h>
35 
36 #include <asm/efi.h>
37 
38 /*
39  * Wrap around the new efi_call_virt_generic() macros so that the
40  * code doesn't get too cluttered:
41  */
42 #define efi_call_virt(f, args...)   \
43 	efi_call_virt_pointer(efi.runtime, f, args)
44 #define __efi_call_virt(f, args...) \
45 	__efi_call_virt_pointer(efi.runtime, f, args)
46 
47 struct efi_runtime_work efi_rts_work;
48 
49 /*
50  * efi_queue_work:	Queue efi_runtime_service() and wait until it's done
51  * @rts:		efi_runtime_service() function identifier
52  * @rts_arg<1-5>:	efi_runtime_service() function arguments
53  *
54  * Accesses to efi_runtime_services() are serialized by a binary
55  * semaphore (efi_runtime_lock) and caller waits until the work is
56  * finished, hence _only_ one work is queued at a time and the caller
57  * thread waits for completion.
58  */
59 #define efi_queue_work(_rts, _arg1, _arg2, _arg3, _arg4, _arg5)		\
60 ({									\
61 	efi_rts_work.status = EFI_ABORTED;				\
62 									\
63 	if (!efi_enabled(EFI_RUNTIME_SERVICES)) {			\
64 		pr_warn_once("EFI Runtime Services are disabled!\n");	\
65 		efi_rts_work.status = EFI_DEVICE_ERROR;			\
66 		goto exit;						\
67 	}								\
68 									\
69 	init_completion(&efi_rts_work.efi_rts_comp);			\
70 	INIT_WORK(&efi_rts_work.work, efi_call_rts);			\
71 	efi_rts_work.arg1 = _arg1;					\
72 	efi_rts_work.arg2 = _arg2;					\
73 	efi_rts_work.arg3 = _arg3;					\
74 	efi_rts_work.arg4 = _arg4;					\
75 	efi_rts_work.arg5 = _arg5;					\
76 	efi_rts_work.efi_rts_id = _rts;					\
77 									\
78 	/*								\
79 	 * queue_work() returns 0 if work was already on queue,         \
80 	 * _ideally_ this should never happen.                          \
81 	 */								\
82 	if (queue_work(efi_rts_wq, &efi_rts_work.work))			\
83 		wait_for_completion(&efi_rts_work.efi_rts_comp);	\
84 	else								\
85 		pr_err("Failed to queue work to efi_rts_wq.\n");	\
86 									\
87 	WARN_ON_ONCE(efi_rts_work.status == EFI_ABORTED);		\
88 exit:									\
89 	efi_rts_work.efi_rts_id = EFI_NONE;				\
90 	efi_rts_work.status;						\
91 })
92 
93 #ifndef arch_efi_save_flags
94 #define arch_efi_save_flags(state_flags)	local_save_flags(state_flags)
95 #define arch_efi_restore_flags(state_flags)	local_irq_restore(state_flags)
96 #endif
97 
98 unsigned long efi_call_virt_save_flags(void)
99 {
100 	unsigned long flags;
101 
102 	arch_efi_save_flags(flags);
103 	return flags;
104 }
105 
106 void efi_call_virt_check_flags(unsigned long flags, const char *call)
107 {
108 	unsigned long cur_flags, mismatch;
109 
110 	cur_flags = efi_call_virt_save_flags();
111 
112 	mismatch = flags ^ cur_flags;
113 	if (!WARN_ON_ONCE(mismatch & ARCH_EFI_IRQ_FLAGS_MASK))
114 		return;
115 
116 	add_taint(TAINT_FIRMWARE_WORKAROUND, LOCKDEP_NOW_UNRELIABLE);
117 	pr_err_ratelimited(FW_BUG "IRQ flags corrupted (0x%08lx=>0x%08lx) by EFI %s\n",
118 			   flags, cur_flags, call);
119 	arch_efi_restore_flags(flags);
120 }
121 
122 /*
123  * According to section 7.1 of the UEFI spec, Runtime Services are not fully
124  * reentrant, and there are particular combinations of calls that need to be
125  * serialized. (source: UEFI Specification v2.4A)
126  *
127  * Table 31. Rules for Reentry Into Runtime Services
128  * +------------------------------------+-------------------------------+
129  * | If previous call is busy in	| Forbidden to call		|
130  * +------------------------------------+-------------------------------+
131  * | Any				| SetVirtualAddressMap()	|
132  * +------------------------------------+-------------------------------+
133  * | ConvertPointer()			| ConvertPointer()		|
134  * +------------------------------------+-------------------------------+
135  * | SetVariable()			| ResetSystem()			|
136  * | UpdateCapsule()			|				|
137  * | SetTime()				|				|
138  * | SetWakeupTime()			|				|
139  * | GetNextHighMonotonicCount()	|				|
140  * +------------------------------------+-------------------------------+
141  * | GetVariable()			| GetVariable()			|
142  * | GetNextVariableName()		| GetNextVariableName()		|
143  * | SetVariable()			| SetVariable()			|
144  * | QueryVariableInfo()		| QueryVariableInfo()		|
145  * | UpdateCapsule()			| UpdateCapsule()		|
146  * | QueryCapsuleCapabilities()		| QueryCapsuleCapabilities()	|
147  * | GetNextHighMonotonicCount()	| GetNextHighMonotonicCount()	|
148  * +------------------------------------+-------------------------------+
149  * | GetTime()				| GetTime()			|
150  * | SetTime()				| SetTime()			|
151  * | GetWakeupTime()			| GetWakeupTime()		|
152  * | SetWakeupTime()			| SetWakeupTime()		|
153  * +------------------------------------+-------------------------------+
154  *
155  * Due to the fact that the EFI pstore may write to the variable store in
156  * interrupt context, we need to use a lock for at least the groups that
157  * contain SetVariable() and QueryVariableInfo(). That leaves little else, as
158  * none of the remaining functions are actually ever called at runtime.
159  * So let's just use a single lock to serialize all Runtime Services calls.
160  */
161 static DEFINE_SEMAPHORE(efi_runtime_lock);
162 
163 /*
164  * Expose the EFI runtime lock to the UV platform
165  */
166 #ifdef CONFIG_X86_UV
167 extern struct semaphore __efi_uv_runtime_lock __alias(efi_runtime_lock);
168 #endif
169 
170 /*
171  * Calls the appropriate efi_runtime_service() with the appropriate
172  * arguments.
173  *
174  * Semantics followed by efi_call_rts() to understand efi_runtime_work:
175  * 1. If argument was a pointer, recast it from void pointer to original
176  * pointer type.
177  * 2. If argument was a value, recast it from void pointer to original
178  * pointer type and dereference it.
179  */
180 static void efi_call_rts(struct work_struct *work)
181 {
182 	void *arg1, *arg2, *arg3, *arg4, *arg5;
183 	efi_status_t status = EFI_NOT_FOUND;
184 
185 	arg1 = efi_rts_work.arg1;
186 	arg2 = efi_rts_work.arg2;
187 	arg3 = efi_rts_work.arg3;
188 	arg4 = efi_rts_work.arg4;
189 	arg5 = efi_rts_work.arg5;
190 
191 	switch (efi_rts_work.efi_rts_id) {
192 	case EFI_GET_TIME:
193 		status = efi_call_virt(get_time, (efi_time_t *)arg1,
194 				       (efi_time_cap_t *)arg2);
195 		break;
196 	case EFI_SET_TIME:
197 		status = efi_call_virt(set_time, (efi_time_t *)arg1);
198 		break;
199 	case EFI_GET_WAKEUP_TIME:
200 		status = efi_call_virt(get_wakeup_time, (efi_bool_t *)arg1,
201 				       (efi_bool_t *)arg2, (efi_time_t *)arg3);
202 		break;
203 	case EFI_SET_WAKEUP_TIME:
204 		status = efi_call_virt(set_wakeup_time, *(efi_bool_t *)arg1,
205 				       (efi_time_t *)arg2);
206 		break;
207 	case EFI_GET_VARIABLE:
208 		status = efi_call_virt(get_variable, (efi_char16_t *)arg1,
209 				       (efi_guid_t *)arg2, (u32 *)arg3,
210 				       (unsigned long *)arg4, (void *)arg5);
211 		break;
212 	case EFI_GET_NEXT_VARIABLE:
213 		status = efi_call_virt(get_next_variable, (unsigned long *)arg1,
214 				       (efi_char16_t *)arg2,
215 				       (efi_guid_t *)arg3);
216 		break;
217 	case EFI_SET_VARIABLE:
218 		status = efi_call_virt(set_variable, (efi_char16_t *)arg1,
219 				       (efi_guid_t *)arg2, *(u32 *)arg3,
220 				       *(unsigned long *)arg4, (void *)arg5);
221 		break;
222 	case EFI_QUERY_VARIABLE_INFO:
223 		status = efi_call_virt(query_variable_info, *(u32 *)arg1,
224 				       (u64 *)arg2, (u64 *)arg3, (u64 *)arg4);
225 		break;
226 	case EFI_GET_NEXT_HIGH_MONO_COUNT:
227 		status = efi_call_virt(get_next_high_mono_count, (u32 *)arg1);
228 		break;
229 	case EFI_UPDATE_CAPSULE:
230 		status = efi_call_virt(update_capsule,
231 				       (efi_capsule_header_t **)arg1,
232 				       *(unsigned long *)arg2,
233 				       *(unsigned long *)arg3);
234 		break;
235 	case EFI_QUERY_CAPSULE_CAPS:
236 		status = efi_call_virt(query_capsule_caps,
237 				       (efi_capsule_header_t **)arg1,
238 				       *(unsigned long *)arg2, (u64 *)arg3,
239 				       (int *)arg4);
240 		break;
241 	default:
242 		/*
243 		 * Ideally, we should never reach here because a caller of this
244 		 * function should have put the right efi_runtime_service()
245 		 * function identifier into efi_rts_work->efi_rts_id
246 		 */
247 		pr_err("Requested executing invalid EFI Runtime Service.\n");
248 	}
249 	efi_rts_work.status = status;
250 	complete(&efi_rts_work.efi_rts_comp);
251 }
252 
253 static efi_status_t virt_efi_get_time(efi_time_t *tm, efi_time_cap_t *tc)
254 {
255 	efi_status_t status;
256 
257 	if (down_interruptible(&efi_runtime_lock))
258 		return EFI_ABORTED;
259 	status = efi_queue_work(EFI_GET_TIME, tm, tc, NULL, NULL, NULL);
260 	up(&efi_runtime_lock);
261 	return status;
262 }
263 
264 static efi_status_t virt_efi_set_time(efi_time_t *tm)
265 {
266 	efi_status_t status;
267 
268 	if (down_interruptible(&efi_runtime_lock))
269 		return EFI_ABORTED;
270 	status = efi_queue_work(EFI_SET_TIME, tm, NULL, NULL, NULL, NULL);
271 	up(&efi_runtime_lock);
272 	return status;
273 }
274 
275 static efi_status_t virt_efi_get_wakeup_time(efi_bool_t *enabled,
276 					     efi_bool_t *pending,
277 					     efi_time_t *tm)
278 {
279 	efi_status_t status;
280 
281 	if (down_interruptible(&efi_runtime_lock))
282 		return EFI_ABORTED;
283 	status = efi_queue_work(EFI_GET_WAKEUP_TIME, enabled, pending, tm, NULL,
284 				NULL);
285 	up(&efi_runtime_lock);
286 	return status;
287 }
288 
289 static efi_status_t virt_efi_set_wakeup_time(efi_bool_t enabled, efi_time_t *tm)
290 {
291 	efi_status_t status;
292 
293 	if (down_interruptible(&efi_runtime_lock))
294 		return EFI_ABORTED;
295 	status = efi_queue_work(EFI_SET_WAKEUP_TIME, &enabled, tm, NULL, NULL,
296 				NULL);
297 	up(&efi_runtime_lock);
298 	return status;
299 }
300 
301 static efi_status_t virt_efi_get_variable(efi_char16_t *name,
302 					  efi_guid_t *vendor,
303 					  u32 *attr,
304 					  unsigned long *data_size,
305 					  void *data)
306 {
307 	efi_status_t status;
308 
309 	if (down_interruptible(&efi_runtime_lock))
310 		return EFI_ABORTED;
311 	status = efi_queue_work(EFI_GET_VARIABLE, name, vendor, attr, data_size,
312 				data);
313 	up(&efi_runtime_lock);
314 	return status;
315 }
316 
317 static efi_status_t virt_efi_get_next_variable(unsigned long *name_size,
318 					       efi_char16_t *name,
319 					       efi_guid_t *vendor)
320 {
321 	efi_status_t status;
322 
323 	if (down_interruptible(&efi_runtime_lock))
324 		return EFI_ABORTED;
325 	status = efi_queue_work(EFI_GET_NEXT_VARIABLE, name_size, name, vendor,
326 				NULL, NULL);
327 	up(&efi_runtime_lock);
328 	return status;
329 }
330 
331 static efi_status_t virt_efi_set_variable(efi_char16_t *name,
332 					  efi_guid_t *vendor,
333 					  u32 attr,
334 					  unsigned long data_size,
335 					  void *data)
336 {
337 	efi_status_t status;
338 
339 	if (down_interruptible(&efi_runtime_lock))
340 		return EFI_ABORTED;
341 	status = efi_queue_work(EFI_SET_VARIABLE, name, vendor, &attr, &data_size,
342 				data);
343 	up(&efi_runtime_lock);
344 	return status;
345 }
346 
347 static efi_status_t
348 virt_efi_set_variable_nonblocking(efi_char16_t *name, efi_guid_t *vendor,
349 				  u32 attr, unsigned long data_size,
350 				  void *data)
351 {
352 	efi_status_t status;
353 
354 	if (down_trylock(&efi_runtime_lock))
355 		return EFI_NOT_READY;
356 
357 	status = efi_call_virt(set_variable, name, vendor, attr, data_size,
358 			       data);
359 	up(&efi_runtime_lock);
360 	return status;
361 }
362 
363 
364 static efi_status_t virt_efi_query_variable_info(u32 attr,
365 						 u64 *storage_space,
366 						 u64 *remaining_space,
367 						 u64 *max_variable_size)
368 {
369 	efi_status_t status;
370 
371 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
372 		return EFI_UNSUPPORTED;
373 
374 	if (down_interruptible(&efi_runtime_lock))
375 		return EFI_ABORTED;
376 	status = efi_queue_work(EFI_QUERY_VARIABLE_INFO, &attr, storage_space,
377 				remaining_space, max_variable_size, NULL);
378 	up(&efi_runtime_lock);
379 	return status;
380 }
381 
382 static efi_status_t
383 virt_efi_query_variable_info_nonblocking(u32 attr,
384 					 u64 *storage_space,
385 					 u64 *remaining_space,
386 					 u64 *max_variable_size)
387 {
388 	efi_status_t status;
389 
390 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
391 		return EFI_UNSUPPORTED;
392 
393 	if (down_trylock(&efi_runtime_lock))
394 		return EFI_NOT_READY;
395 
396 	status = efi_call_virt(query_variable_info, attr, storage_space,
397 			       remaining_space, max_variable_size);
398 	up(&efi_runtime_lock);
399 	return status;
400 }
401 
402 static efi_status_t virt_efi_get_next_high_mono_count(u32 *count)
403 {
404 	efi_status_t status;
405 
406 	if (down_interruptible(&efi_runtime_lock))
407 		return EFI_ABORTED;
408 	status = efi_queue_work(EFI_GET_NEXT_HIGH_MONO_COUNT, count, NULL, NULL,
409 				NULL, NULL);
410 	up(&efi_runtime_lock);
411 	return status;
412 }
413 
414 static void virt_efi_reset_system(int reset_type,
415 				  efi_status_t status,
416 				  unsigned long data_size,
417 				  efi_char16_t *data)
418 {
419 	if (down_trylock(&efi_runtime_lock)) {
420 		pr_warn("failed to invoke the reset_system() runtime service:\n"
421 			"could not get exclusive access to the firmware\n");
422 		return;
423 	}
424 	efi_rts_work.efi_rts_id = EFI_RESET_SYSTEM;
425 	__efi_call_virt(reset_system, reset_type, status, data_size, data);
426 	up(&efi_runtime_lock);
427 }
428 
429 static efi_status_t virt_efi_update_capsule(efi_capsule_header_t **capsules,
430 					    unsigned long count,
431 					    unsigned long sg_list)
432 {
433 	efi_status_t status;
434 
435 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
436 		return EFI_UNSUPPORTED;
437 
438 	if (down_interruptible(&efi_runtime_lock))
439 		return EFI_ABORTED;
440 	status = efi_queue_work(EFI_UPDATE_CAPSULE, capsules, &count, &sg_list,
441 				NULL, NULL);
442 	up(&efi_runtime_lock);
443 	return status;
444 }
445 
446 static efi_status_t virt_efi_query_capsule_caps(efi_capsule_header_t **capsules,
447 						unsigned long count,
448 						u64 *max_size,
449 						int *reset_type)
450 {
451 	efi_status_t status;
452 
453 	if (efi.runtime_version < EFI_2_00_SYSTEM_TABLE_REVISION)
454 		return EFI_UNSUPPORTED;
455 
456 	if (down_interruptible(&efi_runtime_lock))
457 		return EFI_ABORTED;
458 	status = efi_queue_work(EFI_QUERY_CAPSULE_CAPS, capsules, &count,
459 				max_size, reset_type, NULL);
460 	up(&efi_runtime_lock);
461 	return status;
462 }
463 
464 void efi_native_runtime_setup(void)
465 {
466 	efi.get_time = virt_efi_get_time;
467 	efi.set_time = virt_efi_set_time;
468 	efi.get_wakeup_time = virt_efi_get_wakeup_time;
469 	efi.set_wakeup_time = virt_efi_set_wakeup_time;
470 	efi.get_variable = virt_efi_get_variable;
471 	efi.get_next_variable = virt_efi_get_next_variable;
472 	efi.set_variable = virt_efi_set_variable;
473 	efi.set_variable_nonblocking = virt_efi_set_variable_nonblocking;
474 	efi.get_next_high_mono_count = virt_efi_get_next_high_mono_count;
475 	efi.reset_system = virt_efi_reset_system;
476 	efi.query_variable_info = virt_efi_query_variable_info;
477 	efi.query_variable_info_nonblocking = virt_efi_query_variable_info_nonblocking;
478 	efi.update_capsule = virt_efi_update_capsule;
479 	efi.query_capsule_caps = virt_efi_query_capsule_caps;
480 }
481