]>
Commit | Line | Data |
---|---|---|
55716d26 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
a9499fa7 TG |
2 | /* |
3 | * efi.c - EFI subsystem | |
4 | * | |
5 | * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com> | |
6 | * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com> | |
7 | * Copyright (C) 2013 Tom Gundersen <teg@jklm.no> | |
8 | * | |
9 | * This code registers /sys/firmware/efi{,/efivars} when EFI is supported, | |
10 | * allowing the efivarfs to be mounted or the efivars module to be loaded. | |
11 | * The existance of /sys/firmware/efi may also be used by userspace to | |
12 | * determine that the system supports EFI. | |
a9499fa7 TG |
13 | */ |
14 | ||
272686bf LL |
15 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
16 | ||
a9499fa7 TG |
17 | #include <linux/kobject.h> |
18 | #include <linux/module.h> | |
19 | #include <linux/init.h> | |
0e72a6a3 | 20 | #include <linux/debugfs.h> |
a9499fa7 TG |
21 | #include <linux/device.h> |
22 | #include <linux/efi.h> | |
0302f71c | 23 | #include <linux/of.h> |
272686bf | 24 | #include <linux/io.h> |
63625988 | 25 | #include <linux/kexec.h> |
28d54022 | 26 | #include <linux/platform_device.h> |
63625988 AB |
27 | #include <linux/random.h> |
28 | #include <linux/reboot.h> | |
475fb4e8 OP |
29 | #include <linux/slab.h> |
30 | #include <linux/acpi.h> | |
31 | #include <linux/ucs2_string.h> | |
816e7612 | 32 | #include <linux/memblock.h> |
1957a85b | 33 | #include <linux/security.h> |
272686bf | 34 | |
0f7f2f0c | 35 | #include <asm/early_ioremap.h> |
f7d92489 | 36 | |
272686bf | 37 | struct efi __read_mostly efi = { |
96a3dd3d | 38 | .runtime_supported_mask = EFI_RT_SUPPORTED_ALL, |
bf924863 AB |
39 | .acpi = EFI_INVALID_TABLE_ADDR, |
40 | .acpi20 = EFI_INVALID_TABLE_ADDR, | |
41 | .smbios = EFI_INVALID_TABLE_ADDR, | |
42 | .smbios3 = EFI_INVALID_TABLE_ADDR, | |
bf924863 | 43 | .esrt = EFI_INVALID_TABLE_ADDR, |
71e0940d | 44 | .tpm_log = EFI_INVALID_TABLE_ADDR, |
c46f3405 | 45 | .tpm_final_log = EFI_INVALID_TABLE_ADDR, |
272686bf LL |
46 | }; |
47 | EXPORT_SYMBOL(efi); | |
a9499fa7 | 48 | |
badc6198 | 49 | unsigned long __ro_after_init efi_rng_seed = EFI_INVALID_TABLE_ADDR; |
b7846e6b | 50 | static unsigned long __initdata mem_reserve = EFI_INVALID_TABLE_ADDR; |
fe4db90a | 51 | static unsigned long __initdata rt_prop = EFI_INVALID_TABLE_ADDR; |
5d288dbd | 52 | |
7e904a91 SP |
53 | struct mm_struct efi_mm = { |
54 | .mm_rb = RB_ROOT, | |
55 | .mm_users = ATOMIC_INIT(2), | |
56 | .mm_count = ATOMIC_INIT(1), | |
57 | .mmap_sem = __RWSEM_INITIALIZER(efi_mm.mmap_sem), | |
58 | .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock), | |
59 | .mmlist = LIST_HEAD_INIT(efi_mm.mmlist), | |
c1a2f7f0 | 60 | .cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0}, |
7e904a91 SP |
61 | }; |
62 | ||
3eb420e7 SP |
63 | struct workqueue_struct *efi_rts_wq; |
64 | ||
b2e0a54a DY |
65 | static bool disable_runtime; |
66 | static int __init setup_noefi(char *arg) | |
67 | { | |
68 | disable_runtime = true; | |
69 | return 0; | |
70 | } | |
71 | early_param("noefi", setup_noefi); | |
72 | ||
73 | bool efi_runtime_disabled(void) | |
74 | { | |
75 | return disable_runtime; | |
76 | } | |
77 | ||
b617c526 DW |
78 | bool __pure __efi_soft_reserve_enabled(void) |
79 | { | |
80 | return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE); | |
81 | } | |
82 | ||
5ae3683c DY |
83 | static int __init parse_efi_cmdline(char *str) |
84 | { | |
9115c758 RN |
85 | if (!str) { |
86 | pr_warn("need at least one option\n"); | |
87 | return -EINVAL; | |
88 | } | |
89 | ||
12dd00e8 LL |
90 | if (parse_option_str(str, "debug")) |
91 | set_bit(EFI_DBG, &efi.flags); | |
92 | ||
5ae3683c DY |
93 | if (parse_option_str(str, "noruntime")) |
94 | disable_runtime = true; | |
95 | ||
b617c526 DW |
96 | if (parse_option_str(str, "nosoftreserve")) |
97 | set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags); | |
5ae3683c DY |
98 | |
99 | return 0; | |
100 | } | |
101 | early_param("efi", parse_efi_cmdline); | |
102 | ||
0bb54905 | 103 | struct kobject *efi_kobj; |
a9499fa7 TG |
104 | |
105 | /* | |
106 | * Let's not leave out systab information that snuck into | |
107 | * the efivars driver | |
0b02e448 DY |
108 | * Note, do not add more fields in systab sysfs file as it breaks sysfs |
109 | * one value per file rule! | |
a9499fa7 TG |
110 | */ |
111 | static ssize_t systab_show(struct kobject *kobj, | |
112 | struct kobj_attribute *attr, char *buf) | |
113 | { | |
114 | char *str = buf; | |
115 | ||
116 | if (!kobj || !buf) | |
117 | return -EINVAL; | |
118 | ||
a9499fa7 TG |
119 | if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) |
120 | str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20); | |
121 | if (efi.acpi != EFI_INVALID_TABLE_ADDR) | |
122 | str += sprintf(str, "ACPI=0x%lx\n", efi.acpi); | |
b119fe08 JD |
123 | /* |
124 | * If both SMBIOS and SMBIOS3 entry points are implemented, the | |
125 | * SMBIOS3 entry point shall be preferred, so we list it first to | |
126 | * let applications stop parsing after the first match. | |
127 | */ | |
e1ccbbc9 AB |
128 | if (efi.smbios3 != EFI_INVALID_TABLE_ADDR) |
129 | str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3); | |
b119fe08 JD |
130 | if (efi.smbios != EFI_INVALID_TABLE_ADDR) |
131 | str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios); | |
a9499fa7 | 132 | |
e8da08a0 | 133 | if (IS_ENABLED(CONFIG_IA64) || IS_ENABLED(CONFIG_X86)) |
120540f2 | 134 | str = efi_systab_show_arch(str); |
120540f2 | 135 | |
a9499fa7 TG |
136 | return str - buf; |
137 | } | |
138 | ||
af97a77b | 139 | static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400); |
a9499fa7 | 140 | |
2859dff9 SM |
141 | static ssize_t fw_platform_size_show(struct kobject *kobj, |
142 | struct kobj_attribute *attr, char *buf) | |
143 | { | |
144 | return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32); | |
145 | } | |
146 | ||
9cd437ac AB |
147 | extern __weak struct kobj_attribute efi_attr_fw_vendor; |
148 | extern __weak struct kobj_attribute efi_attr_runtime; | |
149 | extern __weak struct kobj_attribute efi_attr_config_table; | |
2859dff9 SM |
150 | static struct kobj_attribute efi_attr_fw_platform_size = |
151 | __ATTR_RO(fw_platform_size); | |
a0998eb1 | 152 | |
a9499fa7 TG |
153 | static struct attribute *efi_subsys_attrs[] = { |
154 | &efi_attr_systab.attr, | |
9cd437ac | 155 | &efi_attr_fw_platform_size.attr, |
a0998eb1 DY |
156 | &efi_attr_fw_vendor.attr, |
157 | &efi_attr_runtime.attr, | |
158 | &efi_attr_config_table.attr, | |
159 | NULL, | |
a9499fa7 TG |
160 | }; |
161 | ||
9cd437ac AB |
162 | umode_t __weak efi_attr_is_visible(struct kobject *kobj, struct attribute *attr, |
163 | int n) | |
a0998eb1 | 164 | { |
9f27bc54 | 165 | return attr->mode; |
a0998eb1 DY |
166 | } |
167 | ||
3ad6bd7c | 168 | static const struct attribute_group efi_subsys_attr_group = { |
a9499fa7 | 169 | .attrs = efi_subsys_attrs, |
a0998eb1 | 170 | .is_visible = efi_attr_is_visible, |
a9499fa7 TG |
171 | }; |
172 | ||
173 | static struct efivars generic_efivars; | |
174 | static struct efivar_operations generic_ops; | |
175 | ||
176 | static int generic_ops_register(void) | |
177 | { | |
178 | generic_ops.get_variable = efi.get_variable; | |
179 | generic_ops.set_variable = efi.set_variable; | |
9c6672ac | 180 | generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking; |
a9499fa7 | 181 | generic_ops.get_next_variable = efi.get_next_variable; |
a614e192 | 182 | generic_ops.query_variable_store = efi_query_variable_store; |
a9499fa7 TG |
183 | |
184 | return efivars_register(&generic_efivars, &generic_ops, efi_kobj); | |
185 | } | |
186 | ||
187 | static void generic_ops_unregister(void) | |
188 | { | |
189 | efivars_unregister(&generic_efivars); | |
190 | } | |
191 | ||
475fb4e8 OP |
192 | #if IS_ENABLED(CONFIG_ACPI) |
193 | #define EFIVAR_SSDT_NAME_MAX 16 | |
194 | static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata; | |
195 | static int __init efivar_ssdt_setup(char *str) | |
196 | { | |
1957a85b MG |
197 | int ret = security_locked_down(LOCKDOWN_ACPI_TABLES); |
198 | ||
199 | if (ret) | |
200 | return ret; | |
201 | ||
475fb4e8 OP |
202 | if (strlen(str) < sizeof(efivar_ssdt)) |
203 | memcpy(efivar_ssdt, str, strlen(str)); | |
204 | else | |
205 | pr_warn("efivar_ssdt: name too long: %s\n", str); | |
206 | return 0; | |
207 | } | |
208 | __setup("efivar_ssdt=", efivar_ssdt_setup); | |
209 | ||
210 | static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor, | |
211 | unsigned long name_size, void *data) | |
212 | { | |
213 | struct efivar_entry *entry; | |
214 | struct list_head *list = data; | |
215 | char utf8_name[EFIVAR_SSDT_NAME_MAX]; | |
216 | int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size); | |
217 | ||
218 | ucs2_as_utf8(utf8_name, name, limit - 1); | |
219 | if (strncmp(utf8_name, efivar_ssdt, limit) != 0) | |
220 | return 0; | |
221 | ||
222 | entry = kmalloc(sizeof(*entry), GFP_KERNEL); | |
223 | if (!entry) | |
224 | return 0; | |
225 | ||
226 | memcpy(entry->var.VariableName, name, name_size); | |
227 | memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t)); | |
228 | ||
229 | efivar_entry_add(entry, list); | |
230 | ||
231 | return 0; | |
232 | } | |
233 | ||
234 | static __init int efivar_ssdt_load(void) | |
235 | { | |
236 | LIST_HEAD(entries); | |
237 | struct efivar_entry *entry, *aux; | |
238 | unsigned long size; | |
239 | void *data; | |
240 | int ret; | |
241 | ||
c05f8f92 AB |
242 | if (!efivar_ssdt[0]) |
243 | return 0; | |
244 | ||
475fb4e8 OP |
245 | ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries); |
246 | ||
247 | list_for_each_entry_safe(entry, aux, &entries, list) { | |
248 | pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt, | |
249 | &entry->var.VendorGuid); | |
250 | ||
251 | list_del(&entry->list); | |
252 | ||
253 | ret = efivar_entry_size(entry, &size); | |
254 | if (ret) { | |
255 | pr_err("failed to get var size\n"); | |
256 | goto free_entry; | |
257 | } | |
258 | ||
259 | data = kmalloc(size, GFP_KERNEL); | |
a75dcb58 DC |
260 | if (!data) { |
261 | ret = -ENOMEM; | |
475fb4e8 | 262 | goto free_entry; |
a75dcb58 | 263 | } |
475fb4e8 OP |
264 | |
265 | ret = efivar_entry_get(entry, NULL, &size, data); | |
266 | if (ret) { | |
267 | pr_err("failed to get var data\n"); | |
268 | goto free_data; | |
269 | } | |
270 | ||
1770093c | 271 | ret = acpi_load_table(data, NULL); |
475fb4e8 OP |
272 | if (ret) { |
273 | pr_err("failed to load table: %d\n", ret); | |
274 | goto free_data; | |
275 | } | |
276 | ||
277 | goto free_entry; | |
278 | ||
279 | free_data: | |
280 | kfree(data); | |
281 | ||
282 | free_entry: | |
283 | kfree(entry); | |
284 | } | |
285 | ||
286 | return ret; | |
287 | } | |
288 | #else | |
289 | static inline int efivar_ssdt_load(void) { return 0; } | |
290 | #endif | |
291 | ||
0e72a6a3 HG |
292 | #ifdef CONFIG_DEBUG_FS |
293 | ||
294 | #define EFI_DEBUGFS_MAX_BLOBS 32 | |
295 | ||
296 | static struct debugfs_blob_wrapper debugfs_blob[EFI_DEBUGFS_MAX_BLOBS]; | |
297 | ||
298 | static void __init efi_debugfs_init(void) | |
299 | { | |
300 | struct dentry *efi_debugfs; | |
301 | efi_memory_desc_t *md; | |
302 | char name[32]; | |
303 | int type_count[EFI_BOOT_SERVICES_DATA + 1] = {}; | |
304 | int i = 0; | |
305 | ||
306 | efi_debugfs = debugfs_create_dir("efi", NULL); | |
307 | if (IS_ERR_OR_NULL(efi_debugfs)) | |
308 | return; | |
309 | ||
310 | for_each_efi_memory_desc(md) { | |
311 | switch (md->type) { | |
312 | case EFI_BOOT_SERVICES_CODE: | |
313 | snprintf(name, sizeof(name), "boot_services_code%d", | |
314 | type_count[md->type]++); | |
315 | break; | |
316 | case EFI_BOOT_SERVICES_DATA: | |
317 | snprintf(name, sizeof(name), "boot_services_data%d", | |
318 | type_count[md->type]++); | |
319 | break; | |
320 | default: | |
321 | continue; | |
322 | } | |
323 | ||
324 | if (i >= EFI_DEBUGFS_MAX_BLOBS) { | |
325 | pr_warn("More then %d EFI boot service segments, only showing first %d in debugfs\n", | |
326 | EFI_DEBUGFS_MAX_BLOBS, EFI_DEBUGFS_MAX_BLOBS); | |
327 | break; | |
328 | } | |
329 | ||
330 | debugfs_blob[i].size = md->num_pages << EFI_PAGE_SHIFT; | |
331 | debugfs_blob[i].data = memremap(md->phys_addr, | |
332 | debugfs_blob[i].size, | |
333 | MEMREMAP_WB); | |
334 | if (!debugfs_blob[i].data) | |
335 | continue; | |
336 | ||
337 | debugfs_create_blob(name, 0400, efi_debugfs, &debugfs_blob[i]); | |
338 | i++; | |
339 | } | |
340 | } | |
341 | #else | |
342 | static inline void efi_debugfs_init(void) {} | |
343 | #endif | |
344 | ||
a9499fa7 TG |
345 | /* |
346 | * We register the efi subsystem with the firmware subsystem and the | |
347 | * efivars subsystem with the efi subsystem, if the system was booted with | |
348 | * EFI. | |
349 | */ | |
350 | static int __init efisubsys_init(void) | |
351 | { | |
352 | int error; | |
353 | ||
96a3dd3d AB |
354 | if (!efi_enabled(EFI_RUNTIME_SERVICES)) |
355 | efi.runtime_supported_mask = 0; | |
356 | ||
3e03dca5 AB |
357 | if (!efi_enabled(EFI_BOOT)) |
358 | return 0; | |
359 | ||
96a3dd3d AB |
360 | if (efi.runtime_supported_mask) { |
361 | /* | |
362 | * Since we process only one efi_runtime_service() at a time, an | |
363 | * ordered workqueue (which creates only one execution context) | |
364 | * should suffice for all our needs. | |
365 | */ | |
366 | efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0); | |
367 | if (!efi_rts_wq) { | |
368 | pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n"); | |
369 | clear_bit(EFI_RUNTIME_SERVICES, &efi.flags); | |
370 | efi.runtime_supported_mask = 0; | |
371 | return 0; | |
372 | } | |
3eb420e7 SP |
373 | } |
374 | ||
e5c3b1cc AB |
375 | if (efi_rt_services_supported(EFI_RT_SUPPORTED_TIME_SERVICES)) |
376 | platform_device_register_simple("rtc-efi", 0, NULL, 0); | |
377 | ||
a9499fa7 TG |
378 | /* We register the efi directory at /sys/firmware/efi */ |
379 | efi_kobj = kobject_create_and_add("efi", firmware_kobj); | |
380 | if (!efi_kobj) { | |
381 | pr_err("efi: Firmware registration failed.\n"); | |
382 | return -ENOMEM; | |
383 | } | |
384 | ||
bf67fad1 | 385 | if (efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) { |
475fb4e8 | 386 | efivar_ssdt_load(); |
bf67fad1 AB |
387 | error = generic_ops_register(); |
388 | if (error) | |
389 | goto err_put; | |
390 | platform_device_register_simple("efivars", 0, NULL, 0); | |
391 | } | |
475fb4e8 | 392 | |
a9499fa7 TG |
393 | error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group); |
394 | if (error) { | |
395 | pr_err("efi: Sysfs attribute export failed with error %d.\n", | |
396 | error); | |
397 | goto err_unregister; | |
398 | } | |
399 | ||
926172d4 DY |
400 | error = efi_runtime_map_init(efi_kobj); |
401 | if (error) | |
402 | goto err_remove_group; | |
403 | ||
a9499fa7 | 404 | /* and the standard mountpoint for efivarfs */ |
f9bb4882 EB |
405 | error = sysfs_create_mount_point(efi_kobj, "efivars"); |
406 | if (error) { | |
a9499fa7 | 407 | pr_err("efivars: Subsystem registration failed.\n"); |
a9499fa7 TG |
408 | goto err_remove_group; |
409 | } | |
410 | ||
0e72a6a3 HG |
411 | if (efi_enabled(EFI_DBG) && efi_enabled(EFI_PRESERVE_BS_REGIONS)) |
412 | efi_debugfs_init(); | |
413 | ||
a9499fa7 TG |
414 | return 0; |
415 | ||
416 | err_remove_group: | |
417 | sysfs_remove_group(efi_kobj, &efi_subsys_attr_group); | |
418 | err_unregister: | |
bf67fad1 AB |
419 | if (efi_rt_services_supported(EFI_RT_SUPPORTED_VARIABLE_SERVICES)) |
420 | generic_ops_unregister(); | |
a9499fa7 TG |
421 | err_put: |
422 | kobject_put(efi_kobj); | |
423 | return error; | |
424 | } | |
425 | ||
426 | subsys_initcall(efisubsys_init); | |
272686bf | 427 | |
0bb54905 PJ |
428 | /* |
429 | * Find the efi memory descriptor for a given physical address. Given a | |
dca0f971 | 430 | * physical address, determine if it exists within an EFI Memory Map entry, |
0bb54905 PJ |
431 | * and if so, populate the supplied memory descriptor with the appropriate |
432 | * data. | |
433 | */ | |
7e1550b8 | 434 | int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md) |
0bb54905 | 435 | { |
dca0f971 | 436 | efi_memory_desc_t *md; |
0bb54905 PJ |
437 | |
438 | if (!efi_enabled(EFI_MEMMAP)) { | |
439 | pr_err_once("EFI_MEMMAP is not enabled.\n"); | |
440 | return -EINVAL; | |
441 | } | |
442 | ||
0bb54905 PJ |
443 | if (!out_md) { |
444 | pr_err_once("out_md is null.\n"); | |
445 | return -EINVAL; | |
446 | } | |
0bb54905 | 447 | |
dca0f971 | 448 | for_each_efi_memory_desc(md) { |
0bb54905 PJ |
449 | u64 size; |
450 | u64 end; | |
451 | ||
0bb54905 PJ |
452 | size = md->num_pages << EFI_PAGE_SHIFT; |
453 | end = md->phys_addr + size; | |
454 | if (phys_addr >= md->phys_addr && phys_addr < end) { | |
455 | memcpy(out_md, md, sizeof(*out_md)); | |
0bb54905 PJ |
456 | return 0; |
457 | } | |
0bb54905 | 458 | } |
0bb54905 PJ |
459 | return -ENOENT; |
460 | } | |
461 | ||
462 | /* | |
463 | * Calculate the highest address of an efi memory descriptor. | |
464 | */ | |
465 | u64 __init efi_mem_desc_end(efi_memory_desc_t *md) | |
466 | { | |
467 | u64 size = md->num_pages << EFI_PAGE_SHIFT; | |
468 | u64 end = md->phys_addr + size; | |
469 | return end; | |
470 | } | |
272686bf | 471 | |
816e7612 MF |
472 | void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {} |
473 | ||
474 | /** | |
475 | * efi_mem_reserve - Reserve an EFI memory region | |
476 | * @addr: Physical address to reserve | |
477 | * @size: Size of reservation | |
478 | * | |
479 | * Mark a region as reserved from general kernel allocation and | |
480 | * prevent it being released by efi_free_boot_services(). | |
481 | * | |
482 | * This function should be called drivers once they've parsed EFI | |
483 | * configuration tables to figure out where their data lives, e.g. | |
484 | * efi_esrt_init(). | |
485 | */ | |
486 | void __init efi_mem_reserve(phys_addr_t addr, u64 size) | |
487 | { | |
488 | if (!memblock_is_region_reserved(addr, size)) | |
489 | memblock_reserve(addr, size); | |
490 | ||
491 | /* | |
492 | * Some architectures (x86) reserve all boot services ranges | |
493 | * until efi_free_boot_services() because of buggy firmware | |
494 | * implementations. This means the above memblock_reserve() is | |
495 | * superfluous on x86 and instead what it needs to do is | |
496 | * ensure the @start, @size is not freed. | |
497 | */ | |
498 | efi_arch_mem_reserve(addr, size); | |
499 | } | |
500 | ||
06c0bd93 | 501 | static const efi_config_table_type_t common_tables[] __initconst = { |
4e9a0f73 AB |
502 | {ACPI_20_TABLE_GUID, &efi.acpi20, "ACPI 2.0" }, |
503 | {ACPI_TABLE_GUID, &efi.acpi, "ACPI" }, | |
504 | {SMBIOS_TABLE_GUID, &efi.smbios, "SMBIOS" }, | |
505 | {SMBIOS3_TABLE_GUID, &efi.smbios3, "SMBIOS 3.0" }, | |
506 | {EFI_SYSTEM_RESOURCE_TABLE_GUID, &efi.esrt, "ESRT" }, | |
507 | {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, &efi_mem_attr_table, "MEMATTR" }, | |
508 | {LINUX_EFI_RANDOM_SEED_TABLE_GUID, &efi_rng_seed, "RNG" }, | |
509 | {LINUX_EFI_TPM_EVENT_LOG_GUID, &efi.tpm_log, "TPMEventLog" }, | |
510 | {LINUX_EFI_TPM_FINAL_LOG_GUID, &efi.tpm_final_log, "TPMFinalLog" }, | |
511 | {LINUX_EFI_MEMRESERVE_TABLE_GUID, &mem_reserve, "MEMRESERVE" }, | |
512 | {EFI_RT_PROPERTIES_TABLE_GUID, &rt_prop, "RTPROP" }, | |
1c5fecb6 | 513 | #ifdef CONFIG_EFI_RCI2_TABLE |
4e9a0f73 | 514 | {DELLEMC_EFI_RCI2_TABLE_GUID, &rci2_table_phys }, |
1c5fecb6 | 515 | #endif |
4e9a0f73 | 516 | {}, |
272686bf LL |
517 | }; |
518 | ||
06c0bd93 | 519 | static __init int match_config_table(const efi_guid_t *guid, |
272686bf | 520 | unsigned long table, |
06c0bd93 | 521 | const efi_config_table_type_t *table_types) |
272686bf | 522 | { |
272686bf LL |
523 | int i; |
524 | ||
4eb8320b AB |
525 | for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) { |
526 | if (!efi_guidcmp(*guid, table_types[i].guid)) { | |
527 | *(table_types[i].ptr) = table; | |
528 | if (table_types[i].name[0]) | |
529 | pr_cont("%s=0x%lx ", | |
530 | table_types[i].name, table); | |
531 | return 1; | |
272686bf LL |
532 | } |
533 | } | |
534 | ||
535 | return 0; | |
536 | } | |
537 | ||
06c0bd93 AB |
538 | int __init efi_config_parse_tables(const efi_config_table_t *config_tables, |
539 | int count, | |
540 | const efi_config_table_type_t *arch_tables) | |
272686bf | 541 | { |
06c0bd93 AB |
542 | const efi_config_table_64_t *tbl64 = (void *)config_tables; |
543 | const efi_config_table_32_t *tbl32 = (void *)config_tables; | |
544 | const efi_guid_t *guid; | |
545 | unsigned long table; | |
7bb68410 | 546 | int i; |
272686bf | 547 | |
272686bf | 548 | pr_info(""); |
7bb68410 | 549 | for (i = 0; i < count; i++) { |
06c0bd93 AB |
550 | if (!IS_ENABLED(CONFIG_X86)) { |
551 | guid = &config_tables[i].guid; | |
552 | table = (unsigned long)config_tables[i].table; | |
553 | } else if (efi_enabled(EFI_64BIT)) { | |
554 | guid = &tbl64[i].guid; | |
555 | table = tbl64[i].table; | |
556 | ||
557 | if (IS_ENABLED(CONFIG_X86_32) && | |
558 | tbl64[i].table > U32_MAX) { | |
272686bf LL |
559 | pr_cont("\n"); |
560 | pr_err("Table located above 4GB, disabling EFI.\n"); | |
272686bf LL |
561 | return -EINVAL; |
562 | } | |
272686bf | 563 | } else { |
06c0bd93 AB |
564 | guid = &tbl32[i].guid; |
565 | table = tbl32[i].table; | |
272686bf LL |
566 | } |
567 | ||
4eb8320b | 568 | if (!match_config_table(guid, table, common_tables) && arch_tables) |
06c0bd93 | 569 | match_config_table(guid, table, arch_tables); |
272686bf LL |
570 | } |
571 | pr_cont("\n"); | |
0f8093a9 | 572 | set_bit(EFI_CONFIG_TABLES, &efi.flags); |
a1041713 | 573 | |
badc6198 | 574 | if (efi_rng_seed != EFI_INVALID_TABLE_ADDR) { |
63625988 AB |
575 | struct linux_efi_random_seed *seed; |
576 | u32 size = 0; | |
577 | ||
badc6198 | 578 | seed = early_memremap(efi_rng_seed, sizeof(*seed)); |
63625988 | 579 | if (seed != NULL) { |
be36f9e7 | 580 | size = READ_ONCE(seed->size); |
63625988 AB |
581 | early_memunmap(seed, sizeof(*seed)); |
582 | } else { | |
583 | pr_err("Could not map UEFI random seed!\n"); | |
584 | } | |
585 | if (size > 0) { | |
badc6198 TL |
586 | seed = early_memremap(efi_rng_seed, |
587 | sizeof(*seed) + size); | |
63625988 | 588 | if (seed != NULL) { |
5b4e4c3a | 589 | pr_notice("seeding entropy pool\n"); |
be36f9e7 | 590 | add_bootloader_randomness(seed->bits, size); |
63625988 AB |
591 | early_memunmap(seed, sizeof(*seed) + size); |
592 | } else { | |
593 | pr_err("Could not map UEFI random seed!\n"); | |
594 | } | |
595 | } | |
596 | } | |
597 | ||
dd09fad9 | 598 | if (!IS_ENABLED(CONFIG_X86_32) && efi_enabled(EFI_MEMMAP)) |
457ea3f7 | 599 | efi_memattr_init(); |
3a6b6c6f | 600 | |
33b6d034 TW |
601 | efi_tpm_eventlog_init(); |
602 | ||
b7846e6b AB |
603 | if (mem_reserve != EFI_INVALID_TABLE_ADDR) { |
604 | unsigned long prsv = mem_reserve; | |
71e0940d AB |
605 | |
606 | while (prsv) { | |
607 | struct linux_efi_memreserve *rsv; | |
5f0b0ecf | 608 | u8 *p; |
5f0b0ecf AB |
609 | |
610 | /* | |
611 | * Just map a full page: that is what we will get | |
612 | * anyway, and it permits us to map the entire entry | |
613 | * before knowing its size. | |
614 | */ | |
615 | p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE), | |
616 | PAGE_SIZE); | |
617 | if (p == NULL) { | |
71e0940d AB |
618 | pr_err("Could not map UEFI memreserve entry!\n"); |
619 | return -ENOMEM; | |
620 | } | |
621 | ||
5f0b0ecf AB |
622 | rsv = (void *)(p + prsv % PAGE_SIZE); |
623 | ||
624 | /* reserve the entry itself */ | |
625 | memblock_reserve(prsv, EFI_MEMRESERVE_SIZE(rsv->size)); | |
626 | ||
627 | for (i = 0; i < atomic_read(&rsv->count); i++) { | |
628 | memblock_reserve(rsv->entry[i].base, | |
629 | rsv->entry[i].size); | |
630 | } | |
71e0940d AB |
631 | |
632 | prsv = rsv->next; | |
5f0b0ecf | 633 | early_memunmap(p, PAGE_SIZE); |
71e0940d AB |
634 | } |
635 | } | |
636 | ||
fe4db90a AB |
637 | if (rt_prop != EFI_INVALID_TABLE_ADDR) { |
638 | efi_rt_properties_table_t *tbl; | |
639 | ||
640 | tbl = early_memremap(rt_prop, sizeof(*tbl)); | |
641 | if (tbl) { | |
642 | efi.runtime_supported_mask &= tbl->runtime_services_supported; | |
643 | early_memunmap(tbl, sizeof(*tbl)); | |
644 | } | |
645 | } | |
646 | ||
272686bf LL |
647 | return 0; |
648 | } | |
0302f71c | 649 | |
14fb4209 AB |
650 | int __init efi_systab_check_header(const efi_table_hdr_t *systab_hdr, |
651 | int min_major_version) | |
652 | { | |
653 | if (systab_hdr->signature != EFI_SYSTEM_TABLE_SIGNATURE) { | |
654 | pr_err("System table signature incorrect!\n"); | |
655 | return -EINVAL; | |
656 | } | |
657 | ||
658 | if ((systab_hdr->revision >> 16) < min_major_version) | |
659 | pr_err("Warning: System table version %d.%02d, expected %d.00 or greater!\n", | |
660 | systab_hdr->revision >> 16, | |
661 | systab_hdr->revision & 0xffff, | |
662 | min_major_version); | |
663 | ||
664 | return 0; | |
665 | } | |
666 | ||
667 | #ifndef CONFIG_IA64 | |
668 | static const efi_char16_t *__init map_fw_vendor(unsigned long fw_vendor, | |
669 | size_t size) | |
670 | { | |
671 | const efi_char16_t *ret; | |
672 | ||
673 | ret = early_memremap_ro(fw_vendor, size); | |
674 | if (!ret) | |
675 | pr_err("Could not map the firmware vendor!\n"); | |
676 | return ret; | |
677 | } | |
678 | ||
679 | static void __init unmap_fw_vendor(const void *fw_vendor, size_t size) | |
680 | { | |
681 | early_memunmap((void *)fw_vendor, size); | |
682 | } | |
683 | #else | |
684 | #define map_fw_vendor(p, s) __va(p) | |
685 | #define unmap_fw_vendor(v, s) | |
686 | #endif | |
687 | ||
688 | void __init efi_systab_report_header(const efi_table_hdr_t *systab_hdr, | |
689 | unsigned long fw_vendor) | |
690 | { | |
691 | char vendor[100] = "unknown"; | |
692 | const efi_char16_t *c16; | |
693 | size_t i; | |
694 | ||
695 | c16 = map_fw_vendor(fw_vendor, sizeof(vendor) * sizeof(efi_char16_t)); | |
696 | if (c16) { | |
697 | for (i = 0; i < sizeof(vendor) - 1 && c16[i]; ++i) | |
698 | vendor[i] = c16[i]; | |
699 | vendor[i] = '\0'; | |
700 | ||
701 | unmap_fw_vendor(c16, sizeof(vendor) * sizeof(efi_char16_t)); | |
702 | } | |
703 | ||
704 | pr_info("EFI v%u.%.02u by %s\n", | |
705 | systab_hdr->revision >> 16, | |
706 | systab_hdr->revision & 0xffff, | |
707 | vendor); | |
708 | } | |
709 | ||
98d2a6ca LE |
710 | static __initdata char memory_type_name[][20] = { |
711 | "Reserved", | |
712 | "Loader Code", | |
713 | "Loader Data", | |
714 | "Boot Code", | |
715 | "Boot Data", | |
716 | "Runtime Code", | |
717 | "Runtime Data", | |
718 | "Conventional Memory", | |
719 | "Unusable Memory", | |
720 | "ACPI Reclaim Memory", | |
721 | "ACPI Memory NVS", | |
722 | "Memory Mapped I/O", | |
723 | "MMIO Port Space", | |
35575e0e RE |
724 | "PAL Code", |
725 | "Persistent Memory", | |
98d2a6ca LE |
726 | }; |
727 | ||
728 | char * __init efi_md_typeattr_format(char *buf, size_t size, | |
729 | const efi_memory_desc_t *md) | |
730 | { | |
731 | char *pos; | |
732 | int type_len; | |
733 | u64 attr; | |
734 | ||
735 | pos = buf; | |
736 | if (md->type >= ARRAY_SIZE(memory_type_name)) | |
737 | type_len = snprintf(pos, size, "[type=%u", md->type); | |
738 | else | |
739 | type_len = snprintf(pos, size, "[%-*s", | |
740 | (int)(sizeof(memory_type_name[0]) - 1), | |
741 | memory_type_name[md->type]); | |
742 | if (type_len >= size) | |
743 | return buf; | |
744 | ||
745 | pos += type_len; | |
746 | size -= type_len; | |
747 | ||
748 | attr = md->attribute; | |
749 | if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT | | |
87db73ae AB |
750 | EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO | |
751 | EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP | | |
fe3e5e65 | 752 | EFI_MEMORY_NV | EFI_MEMORY_SP | |
8be4432e | 753 | EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE)) |
98d2a6ca LE |
754 | snprintf(pos, size, "|attr=0x%016llx]", |
755 | (unsigned long long)attr); | |
756 | else | |
c016ca08 | 757 | snprintf(pos, size, |
fe3e5e65 | 758 | "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]", |
98d2a6ca | 759 | attr & EFI_MEMORY_RUNTIME ? "RUN" : "", |
8be4432e | 760 | attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "", |
fe3e5e65 | 761 | attr & EFI_MEMORY_SP ? "SP" : "", |
c016ca08 | 762 | attr & EFI_MEMORY_NV ? "NV" : "", |
98d2a6ca LE |
763 | attr & EFI_MEMORY_XP ? "XP" : "", |
764 | attr & EFI_MEMORY_RP ? "RP" : "", | |
765 | attr & EFI_MEMORY_WP ? "WP" : "", | |
87db73ae | 766 | attr & EFI_MEMORY_RO ? "RO" : "", |
98d2a6ca LE |
767 | attr & EFI_MEMORY_UCE ? "UCE" : "", |
768 | attr & EFI_MEMORY_WB ? "WB" : "", | |
769 | attr & EFI_MEMORY_WT ? "WT" : "", | |
770 | attr & EFI_MEMORY_WC ? "WC" : "", | |
771 | attr & EFI_MEMORY_UC ? "UC" : ""); | |
772 | return buf; | |
773 | } | |
7bf79311 | 774 | |
23f0571c JB |
775 | /* |
776 | * IA64 has a funky EFI memory map that doesn't work the same way as | |
777 | * other architectures. | |
778 | */ | |
779 | #ifndef CONFIG_IA64 | |
7bf79311 JZZ |
780 | /* |
781 | * efi_mem_attributes - lookup memmap attributes for physical address | |
782 | * @phys_addr: the physical address to lookup | |
783 | * | |
784 | * Search in the EFI memory map for the region covering | |
785 | * @phys_addr. Returns the EFI memory attributes if the region | |
786 | * was found in the memory map, 0 otherwise. | |
7bf79311 | 787 | */ |
23f0571c | 788 | u64 efi_mem_attributes(unsigned long phys_addr) |
7bf79311 JZZ |
789 | { |
790 | efi_memory_desc_t *md; | |
7bf79311 JZZ |
791 | |
792 | if (!efi_enabled(EFI_MEMMAP)) | |
793 | return 0; | |
794 | ||
78ce248f | 795 | for_each_efi_memory_desc(md) { |
7bf79311 JZZ |
796 | if ((md->phys_addr <= phys_addr) && |
797 | (phys_addr < (md->phys_addr + | |
798 | (md->num_pages << EFI_PAGE_SHIFT)))) | |
799 | return md->attribute; | |
800 | } | |
801 | return 0; | |
802 | } | |
806b0351 | 803 | |
23f0571c JB |
804 | /* |
805 | * efi_mem_type - lookup memmap type for physical address | |
806 | * @phys_addr: the physical address to lookup | |
807 | * | |
808 | * Search in the EFI memory map for the region covering @phys_addr. | |
809 | * Returns the EFI memory type if the region was found in the memory | |
62b605b5 | 810 | * map, -EINVAL otherwise. |
23f0571c JB |
811 | */ |
812 | int efi_mem_type(unsigned long phys_addr) | |
813 | { | |
814 | const efi_memory_desc_t *md; | |
815 | ||
816 | if (!efi_enabled(EFI_MEMMAP)) | |
817 | return -ENOTSUPP; | |
818 | ||
819 | for_each_efi_memory_desc(md) { | |
820 | if ((md->phys_addr <= phys_addr) && | |
821 | (phys_addr < (md->phys_addr + | |
822 | (md->num_pages << EFI_PAGE_SHIFT)))) | |
823 | return md->type; | |
824 | } | |
825 | return -EINVAL; | |
826 | } | |
827 | #endif | |
828 | ||
806b0351 MF |
829 | int efi_status_to_err(efi_status_t status) |
830 | { | |
831 | int err; | |
832 | ||
833 | switch (status) { | |
834 | case EFI_SUCCESS: | |
835 | err = 0; | |
836 | break; | |
837 | case EFI_INVALID_PARAMETER: | |
838 | err = -EINVAL; | |
839 | break; | |
840 | case EFI_OUT_OF_RESOURCES: | |
841 | err = -ENOSPC; | |
842 | break; | |
843 | case EFI_DEVICE_ERROR: | |
844 | err = -EIO; | |
845 | break; | |
846 | case EFI_WRITE_PROTECTED: | |
847 | err = -EROFS; | |
848 | break; | |
849 | case EFI_SECURITY_VIOLATION: | |
850 | err = -EACCES; | |
851 | break; | |
852 | case EFI_NOT_FOUND: | |
853 | err = -ENOENT; | |
854 | break; | |
dce48e35 AB |
855 | case EFI_ABORTED: |
856 | err = -EINTR; | |
857 | break; | |
806b0351 MF |
858 | default: |
859 | err = -EINVAL; | |
860 | } | |
861 | ||
862 | return err; | |
a19d66c5 TL |
863 | } |
864 | ||
a23d3bb0 | 865 | static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock); |
63eb322d | 866 | static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init; |
a23d3bb0 | 867 | |
976b4891 AB |
868 | static int __init efi_memreserve_map_root(void) |
869 | { | |
b7846e6b | 870 | if (mem_reserve == EFI_INVALID_TABLE_ADDR) |
976b4891 AB |
871 | return -ENODEV; |
872 | ||
b7846e6b | 873 | efi_memreserve_root = memremap(mem_reserve, |
976b4891 AB |
874 | sizeof(*efi_memreserve_root), |
875 | MEMREMAP_WB); | |
876 | if (WARN_ON_ONCE(!efi_memreserve_root)) | |
877 | return -ENOMEM; | |
878 | return 0; | |
879 | } | |
880 | ||
ab0eb162 AB |
881 | static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size) |
882 | { | |
883 | struct resource *res, *parent; | |
884 | ||
885 | res = kzalloc(sizeof(struct resource), GFP_ATOMIC); | |
886 | if (!res) | |
887 | return -ENOMEM; | |
888 | ||
889 | res->name = "reserved"; | |
890 | res->flags = IORESOURCE_MEM; | |
891 | res->start = addr; | |
892 | res->end = addr + size - 1; | |
893 | ||
894 | /* we expect a conflict with a 'System RAM' region */ | |
895 | parent = request_resource_conflict(&iomem_resource, res); | |
896 | return parent ? request_resource(parent, res) : 0; | |
897 | } | |
898 | ||
976b4891 | 899 | int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size) |
a23d3bb0 | 900 | { |
63eb322d | 901 | struct linux_efi_memreserve *rsv; |
80424b02 AB |
902 | unsigned long prsv; |
903 | int rc, index; | |
a23d3bb0 | 904 | |
976b4891 | 905 | if (efi_memreserve_root == (void *)ULONG_MAX) |
a23d3bb0 AB |
906 | return -ENODEV; |
907 | ||
976b4891 AB |
908 | if (!efi_memreserve_root) { |
909 | rc = efi_memreserve_map_root(); | |
910 | if (rc) | |
911 | return rc; | |
912 | } | |
913 | ||
80424b02 AB |
914 | /* first try to find a slot in an existing linked list entry */ |
915 | for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) { | |
18df7577 | 916 | rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB); |
80424b02 AB |
917 | index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size); |
918 | if (index < rsv->size) { | |
919 | rsv->entry[index].base = addr; | |
920 | rsv->entry[index].size = size; | |
921 | ||
18df7577 | 922 | memunmap(rsv); |
ab0eb162 | 923 | return efi_mem_reserve_iomem(addr, size); |
80424b02 | 924 | } |
18df7577 | 925 | memunmap(rsv); |
80424b02 AB |
926 | } |
927 | ||
928 | /* no slot found - allocate a new linked list entry */ | |
929 | rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC); | |
a23d3bb0 AB |
930 | if (!rsv) |
931 | return -ENOMEM; | |
932 | ||
ab0eb162 AB |
933 | rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K); |
934 | if (rc) { | |
935 | free_page((unsigned long)rsv); | |
936 | return rc; | |
937 | } | |
938 | ||
18df7577 AB |
939 | /* |
940 | * The memremap() call above assumes that a linux_efi_memreserve entry | |
941 | * never crosses a page boundary, so let's ensure that this remains true | |
942 | * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by | |
943 | * using SZ_4K explicitly in the size calculation below. | |
944 | */ | |
945 | rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K); | |
5f0b0ecf AB |
946 | atomic_set(&rsv->count, 1); |
947 | rsv->entry[0].base = addr; | |
948 | rsv->entry[0].size = size; | |
a23d3bb0 AB |
949 | |
950 | spin_lock(&efi_mem_reserve_persistent_lock); | |
63eb322d AB |
951 | rsv->next = efi_memreserve_root->next; |
952 | efi_memreserve_root->next = __pa(rsv); | |
a23d3bb0 AB |
953 | spin_unlock(&efi_mem_reserve_persistent_lock); |
954 | ||
ab0eb162 | 955 | return efi_mem_reserve_iomem(addr, size); |
63eb322d | 956 | } |
a23d3bb0 | 957 | |
63eb322d AB |
958 | static int __init efi_memreserve_root_init(void) |
959 | { | |
976b4891 AB |
960 | if (efi_memreserve_root) |
961 | return 0; | |
962 | if (efi_memreserve_map_root()) | |
963 | efi_memreserve_root = (void *)ULONG_MAX; | |
a23d3bb0 AB |
964 | return 0; |
965 | } | |
63eb322d | 966 | early_initcall(efi_memreserve_root_init); |
a23d3bb0 | 967 | |
63625988 AB |
968 | #ifdef CONFIG_KEXEC |
969 | static int update_efi_random_seed(struct notifier_block *nb, | |
970 | unsigned long code, void *unused) | |
971 | { | |
972 | struct linux_efi_random_seed *seed; | |
973 | u32 size = 0; | |
974 | ||
975 | if (!kexec_in_progress) | |
976 | return NOTIFY_DONE; | |
977 | ||
badc6198 | 978 | seed = memremap(efi_rng_seed, sizeof(*seed), MEMREMAP_WB); |
63625988 | 979 | if (seed != NULL) { |
c2ceb5fd | 980 | size = min(seed->size, EFI_RANDOM_SEED_SIZE); |
63625988 AB |
981 | memunmap(seed); |
982 | } else { | |
983 | pr_err("Could not map UEFI random seed!\n"); | |
984 | } | |
985 | if (size > 0) { | |
badc6198 TL |
986 | seed = memremap(efi_rng_seed, sizeof(*seed) + size, |
987 | MEMREMAP_WB); | |
63625988 AB |
988 | if (seed != NULL) { |
989 | seed->size = size; | |
990 | get_random_bytes(seed->bits, seed->size); | |
991 | memunmap(seed); | |
992 | } else { | |
993 | pr_err("Could not map UEFI random seed!\n"); | |
994 | } | |
995 | } | |
996 | return NOTIFY_DONE; | |
997 | } | |
998 | ||
999 | static struct notifier_block efi_random_seed_nb = { | |
1000 | .notifier_call = update_efi_random_seed, | |
1001 | }; | |
1002 | ||
5d288dbd | 1003 | static int __init register_update_efi_random_seed(void) |
63625988 | 1004 | { |
badc6198 | 1005 | if (efi_rng_seed == EFI_INVALID_TABLE_ADDR) |
63625988 AB |
1006 | return 0; |
1007 | return register_reboot_notifier(&efi_random_seed_nb); | |
1008 | } | |
1009 | late_initcall(register_update_efi_random_seed); | |
1010 | #endif |