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