1
2#define pr_fmt(fmt) "efi: " fmt
3
4#include <linux/init.h>
5#include <linux/kernel.h>
6#include <linux/string.h>
7#include <linux/time.h>
8#include <linux/types.h>
9#include <linux/efi.h>
10#include <linux/slab.h>
11#include <linux/memblock.h>
12#include <linux/acpi.h>
13#include <linux/dmi.h>
14
15#include <asm/e820/api.h>
16#include <asm/efi.h>
17#include <asm/uv/uv.h>
18#include <asm/cpu_device_id.h>
19#include <asm/realmode.h>
20#include <asm/reboot.h>
21
22#define EFI_MIN_RESERVE 5120
23
24#define EFI_DUMMY_GUID \
25 EFI_GUID(0x4424ac57, 0xbe4b, 0x47dd, 0x9e, 0x97, 0xed, 0x50, 0xf0, 0x9f, 0x92, 0xa9)
26
27#define QUARK_CSH_SIGNATURE 0x5f435348
28#define QUARK_SECURITY_HEADER_SIZE 0x400
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62struct quark_security_header {
63 u32 csh_signature;
64 u32 version;
65 u32 modulesize;
66 u32 security_version_number_index;
67 u32 security_version_number;
68 u32 rsvd_module_id;
69 u32 rsvd_module_vendor;
70 u32 rsvd_date;
71 u32 headersize;
72 u32 hash_algo;
73 u32 cryp_algo;
74 u32 keysize;
75 u32 signaturesize;
76 u32 rsvd_next_header;
77 u32 rsvd[2];
78};
79
80static const efi_char16_t efi_dummy_name[] = L"DUMMY";
81
82static bool efi_no_storage_paranoia;
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98static int __init setup_storage_paranoia(char *arg)
99{
100 efi_no_storage_paranoia = true;
101 return 0;
102}
103early_param("efi_no_storage_paranoia", setup_storage_paranoia);
104
105
106
107
108void efi_delete_dummy_variable(void)
109{
110 efi.set_variable_nonblocking((efi_char16_t *)efi_dummy_name,
111 &EFI_DUMMY_GUID,
112 EFI_VARIABLE_NON_VOLATILE |
113 EFI_VARIABLE_BOOTSERVICE_ACCESS |
114 EFI_VARIABLE_RUNTIME_ACCESS, 0, NULL);
115}
116
117
118
119
120
121
122
123
124
125
126static efi_status_t
127query_variable_store_nonblocking(u32 attributes, unsigned long size)
128{
129 efi_status_t status;
130 u64 storage_size, remaining_size, max_size;
131
132 status = efi.query_variable_info_nonblocking(attributes, &storage_size,
133 &remaining_size,
134 &max_size);
135 if (status != EFI_SUCCESS)
136 return status;
137
138 if (remaining_size - size < EFI_MIN_RESERVE)
139 return EFI_OUT_OF_RESOURCES;
140
141 return EFI_SUCCESS;
142}
143
144
145
146
147
148
149
150
151efi_status_t efi_query_variable_store(u32 attributes, unsigned long size,
152 bool nonblocking)
153{
154 efi_status_t status;
155 u64 storage_size, remaining_size, max_size;
156
157 if (!(attributes & EFI_VARIABLE_NON_VOLATILE))
158 return 0;
159
160 if (nonblocking)
161 return query_variable_store_nonblocking(attributes, size);
162
163 status = efi.query_variable_info(attributes, &storage_size,
164 &remaining_size, &max_size);
165 if (status != EFI_SUCCESS)
166 return status;
167
168
169
170
171
172
173 if ((remaining_size - size < EFI_MIN_RESERVE) &&
174 !efi_no_storage_paranoia) {
175
176
177
178
179
180
181 unsigned long dummy_size = remaining_size + 1024;
182 void *dummy = kzalloc(dummy_size, GFP_KERNEL);
183
184 if (!dummy)
185 return EFI_OUT_OF_RESOURCES;
186
187 status = efi.set_variable((efi_char16_t *)efi_dummy_name,
188 &EFI_DUMMY_GUID,
189 EFI_VARIABLE_NON_VOLATILE |
190 EFI_VARIABLE_BOOTSERVICE_ACCESS |
191 EFI_VARIABLE_RUNTIME_ACCESS,
192 dummy_size, dummy);
193
194 if (status == EFI_SUCCESS) {
195
196
197
198
199 efi_delete_dummy_variable();
200 }
201
202 kfree(dummy);
203
204
205
206
207
208 status = efi.query_variable_info(attributes, &storage_size,
209 &remaining_size, &max_size);
210
211 if (status != EFI_SUCCESS)
212 return status;
213
214
215
216
217 if (remaining_size - size < EFI_MIN_RESERVE)
218 return EFI_OUT_OF_RESOURCES;
219 }
220
221 return EFI_SUCCESS;
222}
223EXPORT_SYMBOL_GPL(efi_query_variable_store);
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size)
246{
247 struct efi_memory_map_data data = { 0 };
248 struct efi_mem_range mr;
249 efi_memory_desc_t md;
250 int num_entries;
251 void *new;
252
253 if (efi_mem_desc_lookup(addr, &md) ||
254 md.type != EFI_BOOT_SERVICES_DATA) {
255 pr_err("Failed to lookup EFI memory descriptor for %pa\n", &addr);
256 return;
257 }
258
259 if (addr + size > md.phys_addr + (md.num_pages << EFI_PAGE_SHIFT)) {
260 pr_err("Region spans EFI memory descriptors, %pa\n", &addr);
261 return;
262 }
263
264 size += addr % EFI_PAGE_SIZE;
265 size = round_up(size, EFI_PAGE_SIZE);
266 addr = round_down(addr, EFI_PAGE_SIZE);
267
268 mr.range.start = addr;
269 mr.range.end = addr + size - 1;
270 mr.attribute = md.attribute | EFI_MEMORY_RUNTIME;
271
272 num_entries = efi_memmap_split_count(&md, &mr.range);
273 num_entries += efi.memmap.nr_map;
274
275 if (efi_memmap_alloc(num_entries, &data) != 0) {
276 pr_err("Could not allocate boot services memmap\n");
277 return;
278 }
279
280 new = early_memremap(data.phys_map, data.size);
281 if (!new) {
282 pr_err("Failed to map new boot services memmap\n");
283 return;
284 }
285
286 efi_memmap_insert(&efi.memmap, new, &mr);
287 early_memunmap(new, data.size);
288
289 efi_memmap_install(&data);
290 e820__range_update(addr, size, E820_TYPE_RAM, E820_TYPE_RESERVED);
291 e820__update_table(e820_table);
292}
293
294
295
296
297
298
299
300
301
302
303
304static __init bool can_free_region(u64 start, u64 size)
305{
306 if (start + size > __pa_symbol(_text) && start <= __pa_symbol(_end))
307 return false;
308
309 if (!e820__mapped_all(start, start+size, E820_TYPE_RAM))
310 return false;
311
312 return true;
313}
314
315void __init efi_reserve_boot_services(void)
316{
317 efi_memory_desc_t *md;
318
319 if (!efi_enabled(EFI_MEMMAP))
320 return;
321
322 for_each_efi_memory_desc(md) {
323 u64 start = md->phys_addr;
324 u64 size = md->num_pages << EFI_PAGE_SHIFT;
325 bool already_reserved;
326
327 if (md->type != EFI_BOOT_SERVICES_CODE &&
328 md->type != EFI_BOOT_SERVICES_DATA)
329 continue;
330
331 already_reserved = memblock_is_region_reserved(start, size);
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347 if (!already_reserved) {
348 memblock_reserve(start, size);
349
350
351
352
353
354
355 if (can_free_region(start, size))
356 continue;
357 }
358
359
360
361
362
363
364
365
366
367
368 md->attribute |= EFI_MEMORY_RUNTIME;
369 }
370}
371
372
373
374
375
376
377static void __init efi_unmap_pages(efi_memory_desc_t *md)
378{
379 pgd_t *pgd = efi_mm.pgd;
380 u64 pa = md->phys_addr;
381 u64 va = md->virt_addr;
382
383
384
385
386
387
388 if (efi_is_mixed())
389 return;
390
391 if (kernel_unmap_pages_in_pgd(pgd, pa, md->num_pages))
392 pr_err("Failed to unmap 1:1 mapping for 0x%llx\n", pa);
393
394 if (kernel_unmap_pages_in_pgd(pgd, va, md->num_pages))
395 pr_err("Failed to unmap VA mapping for 0x%llx\n", va);
396}
397
398void __init efi_free_boot_services(void)
399{
400 struct efi_memory_map_data data = { 0 };
401 efi_memory_desc_t *md;
402 int num_entries = 0;
403 void *new, *new_md;
404
405
406 if (efi_enabled(EFI_DBG))
407 return;
408
409 for_each_efi_memory_desc(md) {
410 unsigned long long start = md->phys_addr;
411 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
412 size_t rm_size;
413
414 if (md->type != EFI_BOOT_SERVICES_CODE &&
415 md->type != EFI_BOOT_SERVICES_DATA) {
416 num_entries++;
417 continue;
418 }
419
420
421 if (md->attribute & EFI_MEMORY_RUNTIME) {
422 num_entries++;
423 continue;
424 }
425
426
427
428
429
430
431 efi_unmap_pages(md);
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446 rm_size = real_mode_size_needed();
447 if (rm_size && (start + rm_size) < (1<<20) && size >= rm_size) {
448 set_real_mode_mem(start);
449 start += rm_size;
450 size -= rm_size;
451 }
452
453
454
455
456
457
458 if (start + size < SZ_1M)
459 continue;
460 if (start < SZ_1M) {
461 size -= (SZ_1M - start);
462 start = SZ_1M;
463 }
464
465 memblock_free_late(start, size);
466 }
467
468 if (!num_entries)
469 return;
470
471 if (efi_memmap_alloc(num_entries, &data) != 0) {
472 pr_err("Failed to allocate new EFI memmap\n");
473 return;
474 }
475
476 new = memremap(data.phys_map, data.size, MEMREMAP_WB);
477 if (!new) {
478 pr_err("Failed to map new EFI memmap\n");
479 return;
480 }
481
482
483
484
485
486
487 new_md = new;
488 for_each_efi_memory_desc(md) {
489 if (!(md->attribute & EFI_MEMORY_RUNTIME) &&
490 (md->type == EFI_BOOT_SERVICES_CODE ||
491 md->type == EFI_BOOT_SERVICES_DATA))
492 continue;
493
494 memcpy(new_md, md, efi.memmap.desc_size);
495 new_md += efi.memmap.desc_size;
496 }
497
498 memunmap(new);
499
500 if (efi_memmap_install(&data) != 0) {
501 pr_err("Could not install new EFI memmap\n");
502 return;
503 }
504}
505
506
507
508
509
510
511
512
513
514
515int __init efi_reuse_config(u64 tables, int nr_tables)
516{
517 int i, sz, ret = 0;
518 void *p, *tablep;
519 struct efi_setup_data *data;
520
521 if (nr_tables == 0)
522 return 0;
523
524 if (!efi_setup)
525 return 0;
526
527 if (!efi_enabled(EFI_64BIT))
528 return 0;
529
530 data = early_memremap(efi_setup, sizeof(*data));
531 if (!data) {
532 ret = -ENOMEM;
533 goto out;
534 }
535
536 if (!data->smbios)
537 goto out_memremap;
538
539 sz = sizeof(efi_config_table_64_t);
540
541 p = tablep = early_memremap(tables, nr_tables * sz);
542 if (!p) {
543 pr_err("Could not map Configuration table!\n");
544 ret = -ENOMEM;
545 goto out_memremap;
546 }
547
548 for (i = 0; i < nr_tables; i++) {
549 efi_guid_t guid;
550
551 guid = ((efi_config_table_64_t *)p)->guid;
552
553 if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID))
554 ((efi_config_table_64_t *)p)->table = data->smbios;
555 p += sz;
556 }
557 early_memunmap(tablep, nr_tables * sz);
558
559out_memremap:
560 early_memunmap(data, sizeof(*data));
561out:
562 return ret;
563}
564
565void __init efi_apply_memmap_quirks(void)
566{
567
568
569
570
571
572 if (!efi_runtime_supported()) {
573 pr_info("Setup done, disabling due to 32/64-bit mismatch\n");
574 efi_memmap_unmap();
575 }
576}
577
578
579
580
581
582
583
584
585
586bool efi_reboot_required(void)
587{
588 if (!acpi_gbl_reduced_hardware)
589 return false;
590
591 efi_reboot_quirk_mode = EFI_RESET_WARM;
592 return true;
593}
594
595bool efi_poweroff_required(void)
596{
597 return acpi_gbl_reduced_hardware || acpi_no_s5;
598}
599
600#ifdef CONFIG_EFI_CAPSULE_QUIRK_QUARK_CSH
601
602static int qrk_capsule_setup_info(struct capsule_info *cap_info, void **pkbuff,
603 size_t hdr_bytes)
604{
605 struct quark_security_header *csh = *pkbuff;
606
607
608 if (hdr_bytes < sizeof(struct quark_security_header))
609 return 0;
610
611 if (csh->csh_signature != QUARK_CSH_SIGNATURE ||
612 csh->headersize != QUARK_SECURITY_HEADER_SIZE)
613 return 1;
614
615
616 if (hdr_bytes < QUARK_SECURITY_HEADER_SIZE +
617 sizeof(efi_capsule_header_t))
618 return 0;
619
620 pr_debug("Quark security header detected\n");
621
622 if (csh->rsvd_next_header != 0) {
623 pr_err("multiple Quark security headers not supported\n");
624 return -EINVAL;
625 }
626
627 *pkbuff += csh->headersize;
628 cap_info->total_size = csh->headersize;
629
630
631
632
633 cap_info->phys[0] += csh->headersize;
634
635
636
637
638
639
640
641
642
643
644 cap_info->capsule = &cap_info->header;
645
646 return 1;
647}
648
649static const struct x86_cpu_id efi_capsule_quirk_ids[] = {
650 X86_MATCH_VENDOR_FAM_MODEL(INTEL, 5, INTEL_FAM5_QUARK_X1000,
651 &qrk_capsule_setup_info),
652 { }
653};
654
655int efi_capsule_setup_info(struct capsule_info *cap_info, void *kbuff,
656 size_t hdr_bytes)
657{
658 int (*quirk_handler)(struct capsule_info *, void **, size_t);
659 const struct x86_cpu_id *id;
660 int ret;
661
662 if (hdr_bytes < sizeof(efi_capsule_header_t))
663 return 0;
664
665 cap_info->total_size = 0;
666
667 id = x86_match_cpu(efi_capsule_quirk_ids);
668 if (id) {
669
670
671
672
673
674
675
676 quirk_handler = (typeof(quirk_handler))id->driver_data;
677 ret = quirk_handler(cap_info, &kbuff, hdr_bytes);
678 if (ret <= 0)
679 return ret;
680 }
681
682 memcpy(&cap_info->header, kbuff, sizeof(cap_info->header));
683
684 cap_info->total_size += cap_info->header.imagesize;
685
686 return __efi_capsule_setup_info(cap_info);
687}
688
689#endif
690
691
692
693
694
695
696
697
698
699
700
701
702void efi_crash_gracefully_on_page_fault(unsigned long phys_addr)
703{
704 if (!IS_ENABLED(CONFIG_X86_64))
705 return;
706
707
708
709
710
711 if (in_interrupt())
712 return;
713
714
715
716
717
718
719 if (READ_ONCE(efi_rts_work.efi_rts_id) == EFI_NONE ||
720 current_work() != &efi_rts_work.work)
721 return;
722
723
724
725
726
727 if (phys_addr <= 0x0fff)
728 return;
729
730
731
732
733
734 WARN(1, FW_BUG "Page fault caused by firmware at PA: 0x%lx\n",
735 phys_addr);
736
737
738
739
740
741
742
743
744
745 if (efi_rts_work.efi_rts_id == EFI_RESET_SYSTEM) {
746 pr_info("efi_reset_system() buggy! Reboot through BIOS\n");
747 machine_real_restart(MRR_BIOS);
748 return;
749 }
750
751
752
753
754
755 arch_efi_call_virt_teardown();
756
757
758 efi_rts_work.status = EFI_ABORTED;
759 complete(&efi_rts_work.efi_rts_comp);
760
761 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
762 pr_info("Froze efi_rts_wq and disabled EFI Runtime Services\n");
763
764
765
766
767
768 for (;;) {
769 set_current_state(TASK_IDLE);
770 schedule();
771 }
772}
773