License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 22:07:57 +08:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifndef _LINUX_EFI_H
|
|
|
|
#define _LINUX_EFI_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extensible Firmware Interface
|
|
|
|
* Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
|
|
|
|
* Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
* Stephane Eranian <eranian@hpl.hp.com>
|
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/rtc.h>
|
|
|
|
#include <linux/ioport.h>
|
2008-02-25 15:18:37 +08:00
|
|
|
#include <linux/pfn.h>
|
2011-07-22 04:57:56 +08:00
|
|
|
#include <linux/pstore.h>
|
2016-03-01 04:30:39 +08:00
|
|
|
#include <linux/range.h>
|
2014-06-13 19:22:22 +08:00
|
|
|
#include <linux/reboot.h>
|
2016-05-21 08:01:18 +08:00
|
|
|
#include <linux/uuid.h>
|
2016-04-26 04:06:48 +08:00
|
|
|
#include <linux/screen_info.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
|
|
|
|
#define EFI_SUCCESS 0
|
2020-11-03 00:11:49 +08:00
|
|
|
#define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1)))
|
2020-11-03 00:11:49 +08:00
|
|
|
#define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1)))
|
2012-10-05 13:54:56 +08:00
|
|
|
#define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1)))
|
2020-05-19 03:07:11 +08:00
|
|
|
#define EFI_TIMEOUT (18 | (1UL << (BITS_PER_LONG-1)))
|
2016-07-16 03:36:31 +08:00
|
|
|
#define EFI_ABORTED (21 | (1UL << (BITS_PER_LONG-1)))
|
2012-10-05 13:54:56 +08:00
|
|
|
#define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
typedef unsigned long efi_status_t;
|
|
|
|
typedef u8 efi_bool_t;
|
|
|
|
typedef u16 efi_char16_t; /* UNICODE character */
|
2013-09-23 06:45:26 +08:00
|
|
|
typedef u64 efi_physical_addr_t;
|
|
|
|
typedef void *efi_handle_t;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-01-03 19:39:38 +08:00
|
|
|
#if defined(CONFIG_X86_64)
|
2019-12-24 23:10:12 +08:00
|
|
|
#define __efiapi __attribute__((ms_abi))
|
2020-01-03 19:39:38 +08:00
|
|
|
#elif defined(CONFIG_X86_32)
|
|
|
|
#define __efiapi __attribute__((regparm(0)))
|
2019-12-24 23:10:12 +08:00
|
|
|
#else
|
|
|
|
#define __efiapi
|
|
|
|
#endif
|
|
|
|
|
2019-02-02 17:41:13 +08:00
|
|
|
/*
|
|
|
|
* The UEFI spec and EDK2 reference implementation both define EFI_GUID as
|
|
|
|
* struct { u32 a; u16; b; u16 c; u8 d[8]; }; and so the implied alignment
|
|
|
|
* is 32 bits not 8 bits like our guid_t. In some cases (i.e., on 32-bit ARM),
|
|
|
|
* this means that firmware services invoked by the kernel may assume that
|
|
|
|
* efi_guid_t* arguments are 32-bit aligned, and use memory accessors that
|
|
|
|
* do not tolerate misalignment. So let's set the minimum alignment to 32 bits.
|
|
|
|
*
|
|
|
|
* Note that the UEFI spec as well as some comments in the EDK2 code base
|
|
|
|
* suggest that EFI_GUID should be 64-bit aligned, but this appears to be
|
|
|
|
* a mistake, given that no code seems to exist that actually enforces that
|
|
|
|
* or relies on it.
|
|
|
|
*/
|
|
|
|
typedef guid_t efi_guid_t __aligned(__alignof__(u32));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
efi: use 32-bit alignment for efi_guid_t literals
Commit 494c704f9af0 ("efi: Use 32-bit alignment for efi_guid_t") updated
the type definition of efi_guid_t to ensure that it always appears
sufficiently aligned (the UEFI spec is ambiguous about this, but given
the fact that its EFI_GUID type is defined in terms of a struct carrying
a uint32_t, the natural alignment is definitely >= 32 bits).
However, we missed the EFI_GUID() macro which is used to instantiate
efi_guid_t literals: that macro is still based on the guid_t type,
which does not have a minimum alignment at all. This results in warnings
such as
In file included from drivers/firmware/efi/mokvar-table.c:35:
include/linux/efi.h:1093:34: warning: passing 1-byte aligned argument to
4-byte aligned parameter 2 of 'get_var' may result in an unaligned pointer
access [-Walign-mismatch]
status = get_var(L"SecureBoot", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size,
^
include/linux/efi.h:1101:24: warning: passing 1-byte aligned argument to
4-byte aligned parameter 2 of 'get_var' may result in an unaligned pointer
access [-Walign-mismatch]
get_var(L"SetupMode", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size, &setupmode);
The distinction only matters on CPUs that do not support misaligned loads
fully, but 32-bit ARM's load-multiple instructions fall into that category,
and these are likely to be emitted by the compiler that built the firmware
for loading word-aligned 128-bit GUIDs from memory
So re-implement the initializer in terms of our own efi_guid_t type, so that
the alignment becomes a property of the literal's type.
Fixes: 494c704f9af0 ("efi: Use 32-bit alignment for efi_guid_t")
Reported-by: Nathan Chancellor <nathan@kernel.org>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
Reviewed-by: Nathan Chancellor <nathan@kernel.org>
Tested-by: Nathan Chancellor <nathan@kernel.org>
Link: https://github.com/ClangBuiltLinux/linux/issues/1327
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2021-03-10 15:33:19 +08:00
|
|
|
#define EFI_GUID(a, b, c, d...) (efi_guid_t){ { \
|
|
|
|
(a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
|
|
|
|
(b) & 0xff, ((b) >> 8) & 0xff, \
|
|
|
|
(c) & 0xff, ((c) >> 8) & 0xff, d } }
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic EFI table header
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
u64 signature;
|
|
|
|
u32 revision;
|
|
|
|
u32 headersize;
|
|
|
|
u32 crc32;
|
|
|
|
u32 reserved;
|
|
|
|
} efi_table_hdr_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory map descriptor:
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Memory types: */
|
|
|
|
#define EFI_RESERVED_TYPE 0
|
|
|
|
#define EFI_LOADER_CODE 1
|
|
|
|
#define EFI_LOADER_DATA 2
|
|
|
|
#define EFI_BOOT_SERVICES_CODE 3
|
|
|
|
#define EFI_BOOT_SERVICES_DATA 4
|
|
|
|
#define EFI_RUNTIME_SERVICES_CODE 5
|
|
|
|
#define EFI_RUNTIME_SERVICES_DATA 6
|
|
|
|
#define EFI_CONVENTIONAL_MEMORY 7
|
|
|
|
#define EFI_UNUSABLE_MEMORY 8
|
|
|
|
#define EFI_ACPI_RECLAIM_MEMORY 9
|
|
|
|
#define EFI_ACPI_MEMORY_NVS 10
|
|
|
|
#define EFI_MEMORY_MAPPED_IO 11
|
|
|
|
#define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
|
|
|
|
#define EFI_PAL_CODE 13
|
2015-04-04 00:05:28 +08:00
|
|
|
#define EFI_PERSISTENT_MEMORY 14
|
|
|
|
#define EFI_MAX_MEMORY_TYPE 15
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Attribute values: */
|
|
|
|
#define EFI_MEMORY_UC ((u64)0x0000000000000001ULL) /* uncached */
|
|
|
|
#define EFI_MEMORY_WC ((u64)0x0000000000000002ULL) /* write-coalescing */
|
|
|
|
#define EFI_MEMORY_WT ((u64)0x0000000000000004ULL) /* write-through */
|
|
|
|
#define EFI_MEMORY_WB ((u64)0x0000000000000008ULL) /* write-back */
|
2014-09-03 19:32:19 +08:00
|
|
|
#define EFI_MEMORY_UCE ((u64)0x0000000000000010ULL) /* uncached, exported */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_MEMORY_WP ((u64)0x0000000000001000ULL) /* write-protect */
|
|
|
|
#define EFI_MEMORY_RP ((u64)0x0000000000002000ULL) /* read-protect */
|
|
|
|
#define EFI_MEMORY_XP ((u64)0x0000000000004000ULL) /* execute-protect */
|
2016-02-02 06:07:06 +08:00
|
|
|
#define EFI_MEMORY_NV ((u64)0x0000000000008000ULL) /* non-volatile */
|
2015-06-25 07:58:15 +08:00
|
|
|
#define EFI_MEMORY_MORE_RELIABLE \
|
|
|
|
((u64)0x0000000000010000ULL) /* higher reliability */
|
2015-08-07 16:36:54 +08:00
|
|
|
#define EFI_MEMORY_RO ((u64)0x0000000000020000ULL) /* read-only */
|
2019-11-07 09:43:00 +08:00
|
|
|
#define EFI_MEMORY_SP ((u64)0x0000000000040000ULL) /* soft reserved */
|
2020-09-24 19:52:24 +08:00
|
|
|
#define EFI_MEMORY_CPU_CRYPTO ((u64)0x0000000000080000ULL) /* supports encryption */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_MEMORY_RUNTIME ((u64)0x8000000000000000ULL) /* range requires runtime mapping */
|
|
|
|
#define EFI_MEMORY_DESCRIPTOR_VERSION 1
|
|
|
|
|
|
|
|
#define EFI_PAGE_SHIFT 12
|
2013-09-23 06:45:26 +08:00
|
|
|
#define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)
|
efi/x86: Prune invalid memory map entries and fix boot regression
Some machines, such as the Lenovo ThinkPad W541 with firmware GNET80WW
(2.28), include memory map entries with phys_addr=0x0 and num_pages=0.
These machines fail to boot after the following commit,
commit 8e80632fb23f ("efi/esrt: Use efi_mem_reserve() and avoid a kmalloc()")
Fix this by removing such bogus entries from the memory map.
Furthermore, currently the log output for this case (with efi=debug)
looks like:
[ 0.000000] efi: mem45: [Reserved | | | | | | | | | | | | ] range=[0x0000000000000000-0xffffffffffffffff] (0MB)
This is clearly wrong, and also not as informative as it could be. This
patch changes it so that if we find obviously invalid memory map
entries, we print an error and skip those entries. It also detects the
display of the address range calculation overflow, so the new output is:
[ 0.000000] efi: [Firmware Bug]: Invalid EFI memory map entries:
[ 0.000000] efi: mem45: [Reserved | | | | | | | | | | | | ] range=[0x0000000000000000-0x0000000000000000] (invalid)
It also detects memory map sizes that would overflow the physical
address, for example phys_addr=0xfffffffffffff000 and
num_pages=0x0200000000000001, and prints:
[ 0.000000] efi: [Firmware Bug]: Invalid EFI memory map entries:
[ 0.000000] efi: mem45: [Reserved | | | | | | | | | | | | ] range=[phys_addr=0xfffffffffffff000-0x20ffffffffffffffff] (invalid)
It then removes these entries from the memory map.
Signed-off-by: Peter Jones <pjones@redhat.com>
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
[ardb: refactor for clarity with no functional changes, avoid PAGE_SHIFT]
Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
[Matt: Include bugzilla info in commit log]
Cc: <stable@vger.kernel.org> # v4.9+
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: https://bugzilla.kernel.org/show_bug.cgi?id=191121
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-12-13 07:42:28 +08:00
|
|
|
#define EFI_PAGES_MAX (U64_MAX >> EFI_PAGE_SHIFT)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 type;
|
|
|
|
u32 pad;
|
|
|
|
u64 phys_addr;
|
|
|
|
u64 virt_addr;
|
|
|
|
u64 num_pages;
|
|
|
|
u64 attribute;
|
|
|
|
} efi_memory_desc_t;
|
|
|
|
|
2011-06-07 03:36:25 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u32 headersize;
|
|
|
|
u32 flags;
|
|
|
|
u32 imagesize;
|
|
|
|
} efi_capsule_header_t;
|
|
|
|
|
efi: Introduce EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER and corresponding structures
Platform Firmware Runtime Update image starts with UEFI headers, and the
headers are defined in UEFI specification, but some of them have not been
defined in the kernel yet.
For example, the header layout of a capsule file looks like this:
EFI_CAPSULE_HEADER
EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER
EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER
EFI_FIRMWARE_IMAGE_AUTHENTICATION
These structures would be used by the Platform Firmware Runtime Update
driver to parse the format of capsule file to verify if the corresponding
version number is valid. In this way, if the user provides an invalid
capsule image, the kernel could be used as a guard to reject it, without
switching to the Management Mode (which might be costly).
EFI_CAPSULE_HEADER has been defined in the kernel, but the other
structures have not been defined yet, so do that. Besides,
EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER and
EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER are required to be packed
in the uefi specification. For this reason, use the __packed attribute
to indicate to the compiler that the entire structure can appear
misaligned in memory (as suggested by Ard) in case one of them follows
the other directly in a capsule header.
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Chen Yu <yu.c.chen@intel.com>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2021-12-22 12:31:03 +08:00
|
|
|
/* EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER */
|
|
|
|
struct efi_manage_capsule_header {
|
|
|
|
u32 ver;
|
|
|
|
u16 emb_drv_cnt;
|
|
|
|
u16 payload_cnt;
|
|
|
|
/*
|
|
|
|
* Variable-size array of the size given by the sum of
|
|
|
|
* emb_drv_cnt and payload_cnt.
|
|
|
|
*/
|
|
|
|
u64 offset_list[];
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER */
|
|
|
|
struct efi_manage_capsule_image_header {
|
|
|
|
u32 ver;
|
|
|
|
efi_guid_t image_type_id;
|
|
|
|
u8 image_index;
|
|
|
|
u8 reserved_bytes[3];
|
|
|
|
u32 image_size;
|
|
|
|
u32 vendor_code_size;
|
|
|
|
/* hw_ins was introduced in version 2 */
|
|
|
|
u64 hw_ins;
|
|
|
|
/* capsule_support was introduced in version 3 */
|
|
|
|
u64 capsule_support;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* WIN_CERTIFICATE */
|
|
|
|
struct win_cert {
|
|
|
|
u32 len;
|
|
|
|
u16 rev;
|
|
|
|
u16 cert_type;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* WIN_CERTIFICATE_UEFI_GUID */
|
|
|
|
struct win_cert_uefi_guid {
|
|
|
|
struct win_cert hdr;
|
|
|
|
efi_guid_t cert_type;
|
|
|
|
u8 cert_data[];
|
|
|
|
};
|
|
|
|
|
|
|
|
/* EFI_FIRMWARE_IMAGE_AUTHENTICATION */
|
|
|
|
struct efi_image_auth {
|
|
|
|
u64 mon_count;
|
|
|
|
struct win_cert_uefi_guid auth_info;
|
|
|
|
};
|
|
|
|
|
2016-04-26 04:06:59 +08:00
|
|
|
/*
|
|
|
|
* EFI capsule flags
|
|
|
|
*/
|
|
|
|
#define EFI_CAPSULE_PERSIST_ACROSS_RESET 0x00010000
|
|
|
|
#define EFI_CAPSULE_POPULATE_SYSTEM_TABLE 0x00020000
|
|
|
|
#define EFI_CAPSULE_INITIATE_RESET 0x00040000
|
|
|
|
|
2017-06-02 21:52:02 +08:00
|
|
|
struct capsule_info {
|
|
|
|
efi_capsule_header_t header;
|
efi/capsule-loader: Reinstate virtual capsule mapping
Commit:
82c3768b8d68 ("efi/capsule-loader: Use a cached copy of the capsule header")
... refactored the capsule loading code that maps the capsule header,
to avoid having to map it several times.
However, as it turns out, the vmap() call we ended up removing did not
just map the header, but the entire capsule image, and dropping this
virtual mapping breaks capsules that are processed by the firmware
immediately (i.e., without a reboot).
Unfortunately, that change was part of a larger refactor that allowed
a quirk to be implemented for Quark, which has a non-standard memory
layout for capsules, and we have slightly painted ourselves into a
corner by allowing quirk code to mangle the capsule header and memory
layout.
So we need to fix this without breaking Quark. Fortunately, Quark does
not appear to care about the virtual mapping, and so we can simply
do a partial revert of commit:
2a457fb31df6 ("efi/capsule-loader: Use page addresses rather than struct page pointers")
... and create a vmap() mapping of the entire capsule (including header)
based on the reinstated struct page array, unless running on Quark, in
which case we pass the capsule header copy as before.
Reported-by: Ge Song <ge.song@hxt-semitech.com>
Tested-by: Bryan O'Donoghue <pure.logic@nexus-software.ie>
Tested-by: Ge Song <ge.song@hxt-semitech.com>
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: <stable@vger.kernel.org>
Cc: Dave Young <dyoung@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-efi@vger.kernel.org
Fixes: 82c3768b8d68 ("efi/capsule-loader: Use a cached copy of the capsule header")
Link: http://lkml.kernel.org/r/20180102172110.17018-3-ard.biesheuvel@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-01-03 01:21:10 +08:00
|
|
|
efi_capsule_header_t *capsule;
|
2017-06-02 21:52:02 +08:00
|
|
|
int reset_type;
|
|
|
|
long index;
|
|
|
|
size_t count;
|
|
|
|
size_t total_size;
|
efi/capsule-loader: Reinstate virtual capsule mapping
Commit:
82c3768b8d68 ("efi/capsule-loader: Use a cached copy of the capsule header")
... refactored the capsule loading code that maps the capsule header,
to avoid having to map it several times.
However, as it turns out, the vmap() call we ended up removing did not
just map the header, but the entire capsule image, and dropping this
virtual mapping breaks capsules that are processed by the firmware
immediately (i.e., without a reboot).
Unfortunately, that change was part of a larger refactor that allowed
a quirk to be implemented for Quark, which has a non-standard memory
layout for capsules, and we have slightly painted ourselves into a
corner by allowing quirk code to mangle the capsule header and memory
layout.
So we need to fix this without breaking Quark. Fortunately, Quark does
not appear to care about the virtual mapping, and so we can simply
do a partial revert of commit:
2a457fb31df6 ("efi/capsule-loader: Use page addresses rather than struct page pointers")
... and create a vmap() mapping of the entire capsule (including header)
based on the reinstated struct page array, unless running on Quark, in
which case we pass the capsule header copy as before.
Reported-by: Ge Song <ge.song@hxt-semitech.com>
Tested-by: Bryan O'Donoghue <pure.logic@nexus-software.ie>
Tested-by: Ge Song <ge.song@hxt-semitech.com>
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: <stable@vger.kernel.org>
Cc: Dave Young <dyoung@redhat.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-efi@vger.kernel.org
Fixes: 82c3768b8d68 ("efi/capsule-loader: Use a cached copy of the capsule header")
Link: http://lkml.kernel.org/r/20180102172110.17018-3-ard.biesheuvel@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-01-03 01:21:10 +08:00
|
|
|
struct page **pages;
|
|
|
|
phys_addr_t *phys;
|
2017-06-02 21:52:02 +08:00
|
|
|
size_t page_bytes_remain;
|
|
|
|
};
|
|
|
|
|
2022-03-04 14:36:37 +08:00
|
|
|
int efi_capsule_setup_info(struct capsule_info *cap_info, void *kbuff,
|
|
|
|
size_t hdr_bytes);
|
2017-06-02 21:52:02 +08:00
|
|
|
int __efi_capsule_setup_info(struct capsule_info *cap_info);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Types and defines for Time Services
|
|
|
|
*/
|
|
|
|
#define EFI_TIME_ADJUST_DAYLIGHT 0x1
|
|
|
|
#define EFI_TIME_IN_DAYLIGHT 0x2
|
|
|
|
#define EFI_UNSPECIFIED_TIMEZONE 0x07ff
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u16 year;
|
|
|
|
u8 month;
|
|
|
|
u8 day;
|
|
|
|
u8 hour;
|
|
|
|
u8 minute;
|
|
|
|
u8 second;
|
|
|
|
u8 pad1;
|
|
|
|
u32 nanosecond;
|
|
|
|
s16 timezone;
|
|
|
|
u8 daylight;
|
|
|
|
u8 pad2;
|
|
|
|
} efi_time_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 resolution;
|
|
|
|
u32 accuracy;
|
|
|
|
u8 sets_to_zero;
|
|
|
|
} efi_time_cap_t;
|
|
|
|
|
2020-02-11 00:02:38 +08:00
|
|
|
typedef union efi_boot_services efi_boot_services_t;
|
2017-09-20 16:13:39 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Types and defines for EFI ResetSystem
|
|
|
|
*/
|
|
|
|
#define EFI_RESET_COLD 0
|
|
|
|
#define EFI_RESET_WARM 1
|
|
|
|
#define EFI_RESET_SHUTDOWN 2
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EFI Runtime Services table
|
|
|
|
*/
|
|
|
|
#define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)
|
|
|
|
#define EFI_RUNTIME_SERVICES_REVISION 0x00010000
|
|
|
|
|
2014-01-10 21:47:37 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u32 get_time;
|
|
|
|
u32 set_time;
|
|
|
|
u32 get_wakeup_time;
|
|
|
|
u32 set_wakeup_time;
|
|
|
|
u32 set_virtual_address_map;
|
|
|
|
u32 convert_pointer;
|
|
|
|
u32 get_variable;
|
|
|
|
u32 get_next_variable;
|
|
|
|
u32 set_variable;
|
|
|
|
u32 get_next_high_mono_count;
|
|
|
|
u32 reset_system;
|
|
|
|
u32 update_capsule;
|
|
|
|
u32 query_capsule_caps;
|
|
|
|
u32 query_variable_info;
|
|
|
|
} efi_runtime_services_32_t;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
|
|
|
|
typedef efi_status_t efi_set_time_t (efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
|
|
|
|
efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
|
|
|
|
unsigned long *data_size, void *data);
|
|
|
|
typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor);
|
|
|
|
typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor,
|
2011-06-07 03:36:24 +08:00
|
|
|
u32 attr, unsigned long data_size,
|
2005-04-17 06:20:36 +08:00
|
|
|
void *data);
|
|
|
|
typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
|
|
|
|
typedef void efi_reset_system_t (int reset_type, efi_status_t status,
|
|
|
|
unsigned long data_size, efi_char16_t *data);
|
|
|
|
typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
|
|
|
|
unsigned long descriptor_size,
|
|
|
|
u32 descriptor_version,
|
|
|
|
efi_memory_desc_t *virtual_map);
|
2011-06-07 03:36:25 +08:00
|
|
|
typedef efi_status_t efi_query_variable_info_t(u32 attr,
|
|
|
|
u64 *storage_space,
|
|
|
|
u64 *remaining_space,
|
|
|
|
u64 *max_variable_size);
|
|
|
|
typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
unsigned long sg_list);
|
|
|
|
typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
u64 *max_size,
|
|
|
|
int *reset_type);
|
2016-02-02 06:06:58 +08:00
|
|
|
typedef efi_status_t efi_query_variable_store_t(u32 attributes,
|
|
|
|
unsigned long size,
|
|
|
|
bool nonblocking);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2019-12-24 23:10:08 +08:00
|
|
|
typedef union {
|
|
|
|
struct {
|
2019-12-24 23:10:12 +08:00
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
efi_get_time_t __efiapi *get_time;
|
|
|
|
efi_set_time_t __efiapi *set_time;
|
|
|
|
efi_get_wakeup_time_t __efiapi *get_wakeup_time;
|
|
|
|
efi_set_wakeup_time_t __efiapi *set_wakeup_time;
|
|
|
|
efi_set_virtual_address_map_t __efiapi *set_virtual_address_map;
|
|
|
|
void *convert_pointer;
|
|
|
|
efi_get_variable_t __efiapi *get_variable;
|
|
|
|
efi_get_next_variable_t __efiapi *get_next_variable;
|
|
|
|
efi_set_variable_t __efiapi *set_variable;
|
|
|
|
efi_get_next_high_mono_count_t __efiapi *get_next_high_mono_count;
|
|
|
|
efi_reset_system_t __efiapi *reset_system;
|
|
|
|
efi_update_capsule_t __efiapi *update_capsule;
|
|
|
|
efi_query_capsule_caps_t __efiapi *query_capsule_caps;
|
|
|
|
efi_query_variable_info_t __efiapi *query_variable_info;
|
2019-12-24 23:10:08 +08:00
|
|
|
};
|
|
|
|
efi_runtime_services_32_t mixed_mode;
|
2017-01-31 21:21:39 +08:00
|
|
|
} efi_runtime_services_t;
|
|
|
|
|
2014-06-26 18:09:05 +08:00
|
|
|
void efi_native_runtime_setup(void);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2016-06-25 15:20:25 +08:00
|
|
|
* EFI Configuration Table and GUID definitions
|
|
|
|
*
|
2016-06-27 18:49:20 +08:00
|
|
|
* These are all defined in a single line to make them easier to
|
|
|
|
* grep for and to see them at a glance - while still having a
|
|
|
|
* similar structure to the definitions in the spec.
|
|
|
|
*
|
|
|
|
* Here's how they are structured:
|
2016-06-25 15:20:25 +08:00
|
|
|
*
|
|
|
|
* GUID: 12345678-1234-1234-1234-123456789012
|
|
|
|
* Spec:
|
|
|
|
* #define EFI_SOME_PROTOCOL_GUID \
|
|
|
|
* {0x12345678,0x1234,0x1234,\
|
|
|
|
* {0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x12}}
|
|
|
|
* Here:
|
2016-06-27 18:49:20 +08:00
|
|
|
* #define SOME_PROTOCOL_GUID EFI_GUID(0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12)
|
|
|
|
* ^ tabs ^extra space
|
|
|
|
*
|
|
|
|
* Note that the 'extra space' separates the values at the same place
|
|
|
|
* where the UEFI SPEC breaks the line.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2016-06-27 18:49:20 +08:00
|
|
|
#define NULL_GUID EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
|
|
|
|
#define MPS_TABLE_GUID EFI_GUID(0xeb9d2d2f, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
|
|
|
|
#define ACPI_TABLE_GUID EFI_GUID(0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
|
|
|
|
#define ACPI_20_TABLE_GUID EFI_GUID(0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81)
|
|
|
|
#define SMBIOS_TABLE_GUID EFI_GUID(0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
|
|
|
|
#define SMBIOS3_TABLE_GUID EFI_GUID(0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94)
|
|
|
|
#define SAL_SYSTEM_TABLE_GUID EFI_GUID(0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
|
|
|
|
#define HCDP_TABLE_GUID EFI_GUID(0xf951938d, 0x620b, 0x42ef, 0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98)
|
|
|
|
#define UGA_IO_PROTOCOL_GUID EFI_GUID(0x61a4d49e, 0x6f68, 0x4f1b, 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0x0b, 0x07, 0xa2)
|
|
|
|
#define EFI_GLOBAL_VARIABLE_GUID EFI_GUID(0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c)
|
|
|
|
#define UV_SYSTEM_TABLE_GUID EFI_GUID(0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93)
|
|
|
|
#define LINUX_EFI_CRASH_GUID EFI_GUID(0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0)
|
|
|
|
#define LOADED_IMAGE_PROTOCOL_GUID EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
|
|
|
|
#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID EFI_GUID(0x9042a9de, 0x23dc, 0x4a38, 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a)
|
|
|
|
#define EFI_UGA_PROTOCOL_GUID EFI_GUID(0x982c298b, 0xf4fa, 0x41cb, 0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39)
|
|
|
|
#define EFI_PCI_IO_PROTOCOL_GUID EFI_GUID(0x4cf5b200, 0x68b8, 0x4ca5, 0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a)
|
|
|
|
#define EFI_FILE_INFO_ID EFI_GUID(0x09576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
|
|
|
|
#define EFI_SYSTEM_RESOURCE_TABLE_GUID EFI_GUID(0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80)
|
|
|
|
#define EFI_FILE_SYSTEM_GUID EFI_GUID(0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
|
|
|
|
#define DEVICE_TREE_GUID EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5, 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0)
|
|
|
|
#define EFI_PROPERTIES_TABLE_GUID EFI_GUID(0x880aaca3, 0x4adc, 0x4a04, 0x90, 0x79, 0xb7, 0x47, 0x34, 0x08, 0x25, 0xe5)
|
|
|
|
#define EFI_RNG_PROTOCOL_GUID EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)
|
2016-11-13 05:32:33 +08:00
|
|
|
#define EFI_RNG_ALGORITHM_RAW EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61)
|
2016-06-27 18:49:20 +08:00
|
|
|
#define EFI_MEMORY_ATTRIBUTES_TABLE_GUID EFI_GUID(0xdcfa911d, 0x26eb, 0x469f, 0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20)
|
|
|
|
#define EFI_CONSOLE_OUT_DEVICE_GUID EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
|
x86/efi: Retrieve and assign Apple device properties
Apple's EFI drivers supply device properties which are needed to support
Macs optimally. They contain vital information which cannot be obtained
any other way (e.g. Thunderbolt Device ROM). They're also used to convey
the current device state so that OS drivers can pick up where EFI
drivers left (e.g. GPU mode setting).
There's an EFI driver dubbed "AAPL,PathProperties" which implements a
per-device key/value store. Other EFI drivers populate it using a custom
protocol. The macOS bootloader /System/Library/CoreServices/boot.efi
retrieves the properties with the same protocol. The kernel extension
AppleACPIPlatform.kext subsequently merges them into the I/O Kit
registry (see ioreg(8)) where they can be queried by other kernel
extensions and user space.
This commit extends the efistub to retrieve the device properties before
ExitBootServices is called. It assigns them to devices in an fs_initcall
so that they can be queried with the API in <linux/property.h>.
Note that the device properties will only be available if the kernel is
booted with the efistub. Distros should adjust their installers to
always use the efistub on Macs. grub with the "linux" directive will not
work unless the functionality of this commit is duplicated in grub.
(The "linuxefi" directive should work but is not included upstream as of
this writing.)
The custom protocol has GUID 91BD12FE-F6C3-44FB-A5B7-5122AB303AE0 and
looks like this:
typedef struct {
unsigned long version; /* 0x10000 */
efi_status_t (*get) (
IN struct apple_properties_protocol *this,
IN struct efi_dev_path *device,
IN efi_char16_t *property_name,
OUT void *buffer,
IN OUT u32 *buffer_len);
/* EFI_SUCCESS, EFI_NOT_FOUND, EFI_BUFFER_TOO_SMALL */
efi_status_t (*set) (
IN struct apple_properties_protocol *this,
IN struct efi_dev_path *device,
IN efi_char16_t *property_name,
IN void *property_value,
IN u32 property_value_len);
/* allocates copies of property name and value */
/* EFI_SUCCESS, EFI_OUT_OF_RESOURCES */
efi_status_t (*del) (
IN struct apple_properties_protocol *this,
IN struct efi_dev_path *device,
IN efi_char16_t *property_name);
/* EFI_SUCCESS, EFI_NOT_FOUND */
efi_status_t (*get_all) (
IN struct apple_properties_protocol *this,
OUT void *buffer,
IN OUT u32 *buffer_len);
/* EFI_SUCCESS, EFI_BUFFER_TOO_SMALL */
} apple_properties_protocol;
Thanks to Pedro Vilaça for this blog post which was helpful in reverse
engineering Apple's EFI drivers and bootloader:
https://reverse.put.as/2016/06/25/apple-efi-firmware-passwords-and-the-scbo-myth/
If someone at Apple is reading this, please note there's a memory leak
in your implementation of the del() function as the property struct is
freed but the name and value allocations are not.
Neither the macOS bootloader nor Apple's EFI drivers check the protocol
version, but we do to avoid breakage if it's ever changed. It's been the
same since at least OS X 10.6 (2009).
The get_all() function conveniently fills a buffer with all properties
in marshalled form which can be passed to the kernel as a setup_data
payload. The number of device properties is dynamic and can change
between a first invocation of get_all() (to determine the buffer size)
and a second invocation (to retrieve the actual buffer), hence the
peculiar loop which does not finish until the buffer size settles.
The macOS bootloader does the same.
The setup_data payload is later on unmarshalled in an fs_initcall. The
idea is that most buses instantiate devices in "subsys" initcall level
and drivers are usually bound to these devices in "device" initcall
level, so we assign the properties in-between, i.e. in "fs" initcall
level.
This assumes that devices to which properties pertain are instantiated
from a "subsys" initcall or earlier. That should always be the case
since on macOS, AppleACPIPlatformExpert::matchEFIDevicePath() only
supports ACPI and PCI nodes and we've fully scanned those buses during
"subsys" initcall level.
The second assumption is that properties are only needed from a "device"
initcall or later. Seems reasonable to me, but should this ever not work
out, an alternative approach would be to store the property sets e.g. in
a btree early during boot. Then whenever device_add() is called, an EFI
Device Path would have to be constructed for the newly added device,
and looked up in the btree. That way, the property set could be assigned
to the device immediately on instantiation. And this would also work for
devices instantiated in a deferred fashion. It seems like this approach
would be more complicated and require more code. That doesn't seem
justified without a specific use case.
For comparison, the strategy on macOS is to assign properties to objects
in the ACPI namespace (AppleACPIPlatformExpert::mergeEFIProperties()).
That approach is definitely wrong as it fails for devices not present in
the namespace: The NHI EFI driver supplies properties for attached
Thunderbolt devices, yet on Macs with Thunderbolt 1 only one device
level behind the host controller is described in the namespace.
Consequently macOS cannot assign properties for chained devices. With
Thunderbolt 2 they started to describe three device levels behind host
controllers in the namespace but this grossly inflates the SSDT and
still fails if the user daisy-chained more than three devices.
We copy the property names and values from the setup_data payload to
swappable virtual memory and afterwards make the payload available to
the page allocator. This is just for the sake of good housekeeping, it
wouldn't occupy a meaningful amount of physical memory (4444 bytes on my
machine). Only the payload is freed, not the setup_data header since
otherwise we'd break the list linkage and we cannot safely update the
predecessor's ->next link because there's no locking for the list.
The payload is currently not passed on to kexec'ed kernels, same for PCI
ROMs retrieved by setup_efi_pci(). This can be added later if there is
demand by amending setup_efi_state(). The payload can then no longer be
made available to the page allocator of course.
Tested-by: Lukas Wunner <lukas@wunner.de> [MacBookPro9,1]
Tested-by: Pierre Moreau <pierre.morrow@free.fr> [MacBookPro11,3]
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Matt Fleming <matt@codeblueprint.co.uk>
Cc: Andreas Noever <andreas.noever@gmail.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Pedro Vilaça <reverser@put.as>
Cc: Peter Jones <pjones@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: grub-devel@gnu.org
Cc: linux-efi@vger.kernel.org
Link: http://lkml.kernel.org/r/20161112213237.8804-9-matt@codeblueprint.co.uk
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-11-13 05:32:36 +08:00
|
|
|
#define APPLE_PROPERTIES_PROTOCOL_GUID EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb, 0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0)
|
2017-09-20 16:13:39 +08:00
|
|
|
#define EFI_TCG2_PROTOCOL_GUID EFI_GUID(0x607f766c, 0x7455, 0x42be, 0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
|
2020-02-11 00:02:48 +08:00
|
|
|
#define EFI_LOAD_FILE_PROTOCOL_GUID EFI_GUID(0x56ec3091, 0x954c, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
|
|
|
|
#define EFI_LOAD_FILE2_PROTOCOL_GUID EFI_GUID(0x4006c0c1, 0xfcb3, 0x403e, 0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d)
|
2020-01-23 20:10:25 +08:00
|
|
|
#define EFI_RT_PROPERTIES_TABLE_GUID EFI_GUID(0xeb66918a, 0x7eef, 0x402a, 0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)
|
2022-03-03 22:21:19 +08:00
|
|
|
#define EFI_DXE_SERVICES_TABLE_GUID EFI_GUID(0x05ad34ba, 0x6f02, 0x4214, 0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9)
|
2016-04-26 04:06:49 +08:00
|
|
|
|
2017-02-06 19:22:42 +08:00
|
|
|
#define EFI_IMAGE_SECURITY_DATABASE_GUID EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596, 0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f)
|
|
|
|
#define EFI_SHIM_LOCK_GUID EFI_GUID(0x605dab50, 0xe046, 0x4300, 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)
|
|
|
|
|
2018-12-09 04:27:01 +08:00
|
|
|
#define EFI_CERT_SHA256_GUID EFI_GUID(0xc1c41626, 0x504c, 0x4092, 0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28)
|
|
|
|
#define EFI_CERT_X509_GUID EFI_GUID(0xa5c059a1, 0x94e4, 0x4aa7, 0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72)
|
|
|
|
#define EFI_CERT_X509_SHA256_GUID EFI_GUID(0x3bd2a492, 0x96c0, 0x4079, 0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed)
|
2022-03-08 05:33:39 +08:00
|
|
|
#define EFI_CC_BLOB_GUID EFI_GUID(0x067b1f5f, 0xcf26, 0x44c5, 0x85, 0x54, 0x93, 0xd7, 0x77, 0x91, 0x2d, 0x42)
|
2018-12-09 04:27:01 +08:00
|
|
|
|
2016-04-26 04:06:53 +08:00
|
|
|
/*
|
|
|
|
* This GUID is used to pass to the kernel proper the struct screen_info
|
|
|
|
* structure that was populated by the stub based on the GOP protocol instance
|
|
|
|
* associated with ConOut
|
|
|
|
*/
|
2016-06-27 18:49:20 +08:00
|
|
|
#define LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID EFI_GUID(0xe03fc20a, 0x85dc, 0x406e, 0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95)
|
efi/libstub: arm: Print CPU boot mode and MMU state at boot
On 32-bit ARM, we may boot at HYP mode, or with the MMU and caches off
(or both), even though the EFI spec does not actually support this.
While booting at HYP mode is something we might tolerate, fiddling
with the caches is a more serious issue, as disabling the caches is
tricky to do safely from C code, and running without the Dcache makes
it impossible to support unaligned memory accesses, which is another
explicit requirement imposed by the EFI spec.
So take note of the CPU mode and MMU state in the EFI stub diagnostic
output so that we can easily diagnose any issues that may arise from
this. E.g.,
EFI stub: Entering in SVC mode with MMU enabled
Also, capture the CPSR and SCTLR system register values at EFI stub
entry, and after ExitBootServices() returns, and check whether the
MMU and Dcache were disabled at any point. If this is the case, a
diagnostic message like the following will be emitted:
efi: [Firmware Bug]: EFI stub was entered with MMU and Dcache disabled, please fix your firmware!
efi: CPSR at EFI stub entry : 0x600001d3
efi: SCTLR at EFI stub entry : 0x00c51838
efi: CPSR after ExitBootServices() : 0x600001d3
efi: SCTLR after ExitBootServices(): 0x00c50838
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Reviewed-by: Leif Lindholm <leif@nuviainc.com>
2020-06-07 21:41:35 +08:00
|
|
|
#define LINUX_EFI_ARM_CPU_STATE_TABLE_GUID EFI_GUID(0xef79e4aa, 0x3c3d, 0x4989, 0xb9, 0x02, 0x07, 0xa9, 0x43, 0xe5, 0x50, 0xd2)
|
2016-06-27 18:49:20 +08:00
|
|
|
#define LINUX_EFI_LOADER_ENTRY_GUID EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf, 0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)
|
2016-11-13 05:32:31 +08:00
|
|
|
#define LINUX_EFI_RANDOM_SEED_TABLE_GUID EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2, 0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)
|
2017-09-20 16:13:39 +08:00
|
|
|
#define LINUX_EFI_TPM_EVENT_LOG_GUID EFI_GUID(0xb7799cb0, 0xeca2, 0x4943, 0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)
|
2019-05-21 04:54:59 +08:00
|
|
|
#define LINUX_EFI_TPM_FINAL_LOG_GUID EFI_GUID(0x1e2ed096, 0x30e2, 0x4254, 0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)
|
2018-09-22 00:32:44 +08:00
|
|
|
#define LINUX_EFI_MEMRESERVE_TABLE_GUID EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5, 0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)
|
efi/libstub: Add support for loading the initrd from a device path
There are currently two ways to specify the initrd to be passed to the
Linux kernel when booting via the EFI stub:
- it can be passed as a initrd= command line option when doing a pure PE
boot (as opposed to the EFI handover protocol that exists for x86)
- otherwise, the bootloader or firmware can load the initrd into memory,
and pass the address and size via the bootparams struct (x86) or
device tree (ARM)
In the first case, we are limited to loading from the same file system
that the kernel was loaded from, and it is also problematic in a trusted
boot context, given that we cannot easily protect the command line from
tampering without either adding complicated white/blacklisting of boot
arguments or locking down the command line altogether.
In the second case, we force the bootloader to duplicate knowledge about
the boot protocol which is already encoded in the stub, and which may be
subject to change over time, e.g., bootparams struct definitions, memory
allocation/alignment requirements for the placement of the initrd etc etc.
In the ARM case, it also requires the bootloader to modify the hardware
description provided by the firmware, as it is passed in the same file.
On systems where the initrd is measured after loading, it creates a time
window where the initrd contents might be manipulated in memory before
handing over to the kernel.
Address these concerns by adding support for loading the initrd into
memory by invoking the EFI LoadFile2 protocol installed on a vendor
GUIDed device path that specifically designates a Linux initrd.
This addresses the above concerns, by putting the EFI stub in charge of
placement in memory and of passing the base and size to the kernel proper
(via whatever means it desires) while still leaving it up to the firmware
or bootloader to obtain the file contents, potentially from other file
systems than the one the kernel itself was loaded from. On platforms that
implement measured boot, it permits the firmware to take the measurement
right before the kernel actually consumes the contents.
Acked-by: Laszlo Ersek <lersek@redhat.com>
Tested-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
Acked-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2020-02-04 07:45:14 +08:00
|
|
|
#define LINUX_EFI_INITRD_MEDIA_GUID EFI_GUID(0x5568e427, 0x68fc, 0x4f3d, 0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68)
|
2020-09-05 09:31:05 +08:00
|
|
|
#define LINUX_EFI_MOK_VARIABLE_TABLE_GUID EFI_GUID(0xc451ed2b, 0x9694, 0x45d3, 0xba, 0xba, 0xed, 0x9f, 0x89, 0x88, 0xa3, 0x89)
|
2022-04-13 05:21:24 +08:00
|
|
|
#define LINUX_EFI_COCO_SECRET_AREA_GUID EFI_GUID(0xadf956ad, 0xe98c, 0x484c, 0xae, 0x11, 0xb5, 0x1c, 0x7d, 0x33, 0x64, 0x47)
|
2016-04-26 04:06:57 +08:00
|
|
|
|
2022-05-19 13:15:12 +08:00
|
|
|
#define RISCV_EFI_BOOT_PROTOCOL_GUID EFI_GUID(0xccd15fec, 0x6f73, 0x4eec, 0x83, 0x95, 0x3e, 0x69, 0xe4, 0xb9, 0x40, 0xbf)
|
|
|
|
|
2022-03-20 02:00:20 +08:00
|
|
|
/*
|
|
|
|
* This GUID may be installed onto the kernel image's handle as a NULL protocol
|
|
|
|
* to signal to the stub that the placement of the image should be respected,
|
|
|
|
* and moving the image in physical memory is undesirable. To ensure
|
|
|
|
* compatibility with 64k pages kernels with virtually mapped stacks, and to
|
|
|
|
* avoid defeating physical randomization, this protocol should only be
|
|
|
|
* installed if the image was placed at a randomized 128k aligned address in
|
|
|
|
* memory.
|
|
|
|
*/
|
|
|
|
#define LINUX_EFI_LOADED_IMAGE_FIXED_GUID EFI_GUID(0xf5a37b6d, 0x3344, 0x42a5, 0xb6, 0xbb, 0x97, 0x86, 0x48, 0xc1, 0x89, 0x0a)
|
|
|
|
|
2019-07-11 02:59:15 +08:00
|
|
|
/* OEM GUIDs */
|
|
|
|
#define DELLEMC_EFI_RCI2_TABLE_GUID EFI_GUID(0x2d9f28a2, 0xa886, 0x456a, 0x97, 0xa8, 0xf1, 0x1e, 0xf2, 0x4f, 0xf4, 0x55)
|
2021-08-24 19:06:40 +08:00
|
|
|
#define AMD_SEV_MEM_ENCRYPT_GUID EFI_GUID(0x0cf29b71, 0x9e51, 0x433a, 0xa3, 0xb7, 0x81, 0xf3, 0xab, 0x16, 0xb8, 0x75)
|
2019-07-11 02:59:15 +08:00
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u64 table;
|
|
|
|
} efi_config_table_64_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u32 table;
|
|
|
|
} efi_config_table_32_t;
|
|
|
|
|
2019-12-24 23:10:08 +08:00
|
|
|
typedef union {
|
|
|
|
struct {
|
|
|
|
efi_guid_t guid;
|
2019-12-24 23:10:09 +08:00
|
|
|
void *table;
|
2019-12-24 23:10:08 +08:00
|
|
|
};
|
|
|
|
efi_config_table_32_t mixed_mode;
|
2005-04-17 06:20:36 +08:00
|
|
|
} efi_config_table_t;
|
|
|
|
|
2013-09-05 18:34:54 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
unsigned long *ptr;
|
2020-03-26 16:24:14 +08:00
|
|
|
const char name[16];
|
2013-09-05 18:34:54 +08:00
|
|
|
} efi_config_table_type_t;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
|
2022-03-03 22:21:19 +08:00
|
|
|
#define EFI_DXE_SERVICES_TABLE_SIGNATURE ((u64)0x565245535f455844ULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-06-07 03:36:25 +08:00
|
|
|
#define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30))
|
|
|
|
#define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20))
|
|
|
|
#define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10))
|
|
|
|
#define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00))
|
|
|
|
#define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10))
|
|
|
|
#define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02))
|
|
|
|
|
2012-02-13 05:24:29 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u64 fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
u32 __pad1;
|
|
|
|
u64 con_in_handle;
|
|
|
|
u64 con_in;
|
|
|
|
u64 con_out_handle;
|
|
|
|
u64 con_out;
|
|
|
|
u64 stderr_handle;
|
|
|
|
u64 stderr;
|
|
|
|
u64 runtime;
|
|
|
|
u64 boottime;
|
|
|
|
u32 nr_tables;
|
|
|
|
u32 __pad2;
|
|
|
|
u64 tables;
|
|
|
|
} efi_system_table_64_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u32 fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
u32 con_in_handle;
|
|
|
|
u32 con_in;
|
|
|
|
u32 con_out_handle;
|
|
|
|
u32 con_out;
|
|
|
|
u32 stderr_handle;
|
|
|
|
u32 stderr;
|
|
|
|
u32 runtime;
|
|
|
|
u32 boottime;
|
|
|
|
u32 nr_tables;
|
|
|
|
u32 tables;
|
|
|
|
} efi_system_table_32_t;
|
|
|
|
|
2020-05-19 03:07:10 +08:00
|
|
|
typedef union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;
|
2019-12-24 23:10:11 +08:00
|
|
|
typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;
|
|
|
|
|
2019-12-24 23:10:08 +08:00
|
|
|
typedef union {
|
|
|
|
struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
unsigned long fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
unsigned long con_in_handle;
|
2020-05-19 03:07:10 +08:00
|
|
|
efi_simple_text_input_protocol_t *con_in;
|
2019-12-24 23:10:08 +08:00
|
|
|
unsigned long con_out_handle;
|
2019-12-24 23:10:11 +08:00
|
|
|
efi_simple_text_output_protocol_t *con_out;
|
2019-12-24 23:10:08 +08:00
|
|
|
unsigned long stderr_handle;
|
|
|
|
unsigned long stderr;
|
|
|
|
efi_runtime_services_t *runtime;
|
|
|
|
efi_boot_services_t *boottime;
|
|
|
|
unsigned long nr_tables;
|
|
|
|
unsigned long tables;
|
|
|
|
};
|
|
|
|
efi_system_table_32_t mixed_mode;
|
2005-04-17 06:20:36 +08:00
|
|
|
} efi_system_table_t;
|
|
|
|
|
2016-02-27 05:22:05 +08:00
|
|
|
/*
|
|
|
|
* Architecture independent structure for describing a memory map for the
|
2020-01-14 01:22:43 +08:00
|
|
|
* benefit of efi_memmap_init_early(), and for passing context between
|
|
|
|
* efi_memmap_alloc() and efi_memmap_install().
|
2016-02-27 05:22:05 +08:00
|
|
|
*/
|
|
|
|
struct efi_memory_map_data {
|
|
|
|
phys_addr_t phys_map;
|
|
|
|
unsigned long size;
|
|
|
|
unsigned long desc_version;
|
|
|
|
unsigned long desc_size;
|
2020-01-14 01:22:42 +08:00
|
|
|
unsigned long flags;
|
2016-02-27 05:22:05 +08:00
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
struct efi_memory_map {
|
2015-10-23 17:48:16 +08:00
|
|
|
phys_addr_t phys_map;
|
2005-09-04 06:56:27 +08:00
|
|
|
void *map;
|
|
|
|
void *map_end;
|
2005-04-17 06:20:36 +08:00
|
|
|
int nr_map;
|
|
|
|
unsigned long desc_version;
|
2005-09-04 06:56:27 +08:00
|
|
|
unsigned long desc_size;
|
2020-01-14 01:22:42 +08:00
|
|
|
#define EFI_MEMMAP_LATE (1UL << 0)
|
2020-01-14 01:22:43 +08:00
|
|
|
#define EFI_MEMMAP_MEMBLOCK (1UL << 1)
|
|
|
|
#define EFI_MEMMAP_SLAB (1UL << 2)
|
2020-01-14 01:22:42 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2016-03-01 04:30:39 +08:00
|
|
|
struct efi_mem_range {
|
|
|
|
struct range range;
|
|
|
|
u64 attribute;
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2015-09-09 16:08:15 +08:00
|
|
|
typedef struct {
|
|
|
|
u32 version;
|
|
|
|
u32 length;
|
|
|
|
u64 memory_protection_attribute;
|
|
|
|
} efi_properties_table_t;
|
|
|
|
|
|
|
|
#define EFI_PROPERTIES_TABLE_VERSION 0x00010000
|
|
|
|
#define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA 0x1
|
|
|
|
|
2020-01-23 20:10:25 +08:00
|
|
|
typedef struct {
|
|
|
|
u16 version;
|
|
|
|
u16 length;
|
|
|
|
u32 runtime_services_supported;
|
|
|
|
} efi_rt_properties_table_t;
|
|
|
|
|
|
|
|
#define EFI_RT_PROPERTIES_TABLE_VERSION 0x1
|
|
|
|
|
2006-03-26 17:37:08 +08:00
|
|
|
#define EFI_INVALID_TABLE_ADDR (~0UL)
|
|
|
|
|
2016-04-26 04:06:44 +08:00
|
|
|
typedef struct {
|
|
|
|
u32 version;
|
|
|
|
u32 num_entries;
|
|
|
|
u32 desc_size;
|
|
|
|
u32 reserved;
|
|
|
|
efi_memory_desc_t entry[0];
|
|
|
|
} efi_memory_attributes_table_t;
|
|
|
|
|
2018-12-09 04:27:01 +08:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t signature_owner;
|
|
|
|
u8 signature_data[];
|
|
|
|
} efi_signature_data_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_guid_t signature_type;
|
|
|
|
u32 signature_list_size;
|
|
|
|
u32 signature_header_size;
|
|
|
|
u32 signature_size;
|
|
|
|
u8 signature_header[];
|
|
|
|
/* efi_signature_data_t signatures[][] */
|
|
|
|
} efi_signature_list_t;
|
|
|
|
|
|
|
|
typedef u8 efi_sha256_hash_t[32];
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_sha256_hash_t to_be_signed_hash;
|
|
|
|
efi_time_t time_of_revocation;
|
|
|
|
} efi_cert_x509_sha256_t;
|
|
|
|
|
2020-02-28 20:14:04 +08:00
|
|
|
extern unsigned long __ro_after_init efi_rng_seed; /* RNG Seed table */
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* All runtime access to EFI goes through this structure:
|
|
|
|
*/
|
|
|
|
extern struct efi {
|
2020-01-21 16:44:43 +08:00
|
|
|
const efi_runtime_services_t *runtime; /* EFI runtime services table */
|
2020-01-21 17:16:32 +08:00
|
|
|
unsigned int runtime_version; /* Runtime services version */
|
2020-01-21 18:17:47 +08:00
|
|
|
unsigned int runtime_supported_mask;
|
2020-01-21 17:16:32 +08:00
|
|
|
|
|
|
|
unsigned long acpi; /* ACPI table (IA64 ext 0.71) */
|
|
|
|
unsigned long acpi20; /* ACPI table (ACPI 2.0) */
|
|
|
|
unsigned long smbios; /* SMBIOS table (32 bit entry point) */
|
|
|
|
unsigned long smbios3; /* SMBIOS table (64 bit entry point) */
|
|
|
|
unsigned long esrt; /* ESRT table */
|
|
|
|
unsigned long tpm_log; /* TPM2 Event Log table */
|
|
|
|
unsigned long tpm_final_log; /* TPM2 Final Events Log table */
|
2020-09-05 09:31:05 +08:00
|
|
|
unsigned long mokvar_table; /* MOK variable config table */
|
2022-04-13 05:21:24 +08:00
|
|
|
unsigned long coco_secret; /* Confidential computing secret table */
|
2020-01-21 17:16:32 +08:00
|
|
|
|
|
|
|
efi_get_time_t *get_time;
|
|
|
|
efi_set_time_t *set_time;
|
|
|
|
efi_get_wakeup_time_t *get_wakeup_time;
|
|
|
|
efi_set_wakeup_time_t *set_wakeup_time;
|
|
|
|
efi_get_variable_t *get_variable;
|
|
|
|
efi_get_next_variable_t *get_next_variable;
|
|
|
|
efi_set_variable_t *set_variable;
|
|
|
|
efi_set_variable_t *set_variable_nonblocking;
|
|
|
|
efi_query_variable_info_t *query_variable_info;
|
|
|
|
efi_query_variable_info_t *query_variable_info_nonblocking;
|
|
|
|
efi_update_capsule_t *update_capsule;
|
|
|
|
efi_query_capsule_caps_t *query_capsule_caps;
|
|
|
|
efi_get_next_high_mono_count_t *get_next_high_mono_count;
|
|
|
|
efi_reset_system_t *reset_system;
|
|
|
|
|
|
|
|
struct efi_memory_map memmap;
|
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
} efi;
|
|
|
|
|
2021-10-29 05:05:17 +08:00
|
|
|
#define EFI_RT_SUPPORTED_GET_TIME 0x0001
|
|
|
|
#define EFI_RT_SUPPORTED_SET_TIME 0x0002
|
2020-01-21 18:17:47 +08:00
|
|
|
#define EFI_RT_SUPPORTED_GET_WAKEUP_TIME 0x0004
|
|
|
|
#define EFI_RT_SUPPORTED_SET_WAKEUP_TIME 0x0008
|
|
|
|
#define EFI_RT_SUPPORTED_GET_VARIABLE 0x0010
|
|
|
|
#define EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME 0x0020
|
|
|
|
#define EFI_RT_SUPPORTED_SET_VARIABLE 0x0040
|
|
|
|
#define EFI_RT_SUPPORTED_SET_VIRTUAL_ADDRESS_MAP 0x0080
|
|
|
|
#define EFI_RT_SUPPORTED_CONVERT_POINTER 0x0100
|
|
|
|
#define EFI_RT_SUPPORTED_GET_NEXT_HIGH_MONOTONIC_COUNT 0x0200
|
|
|
|
#define EFI_RT_SUPPORTED_RESET_SYSTEM 0x0400
|
|
|
|
#define EFI_RT_SUPPORTED_UPDATE_CAPSULE 0x0800
|
|
|
|
#define EFI_RT_SUPPORTED_QUERY_CAPSULE_CAPABILITIES 0x1000
|
|
|
|
#define EFI_RT_SUPPORTED_QUERY_VARIABLE_INFO 0x2000
|
|
|
|
|
|
|
|
#define EFI_RT_SUPPORTED_ALL 0x3fff
|
|
|
|
|
|
|
|
#define EFI_RT_SUPPORTED_TIME_SERVICES 0x000f
|
|
|
|
#define EFI_RT_SUPPORTED_VARIABLE_SERVICES 0x0070
|
|
|
|
|
2018-03-12 16:44:56 +08:00
|
|
|
extern struct mm_struct efi_mm;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static inline int
|
|
|
|
efi_guidcmp (efi_guid_t left, efi_guid_t right)
|
|
|
|
{
|
|
|
|
return memcmp(&left, &right, sizeof (efi_guid_t));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline char *
|
2014-12-18 23:02:17 +08:00
|
|
|
efi_guid_to_str(efi_guid_t *guid, char *out)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-12-15 10:01:14 +08:00
|
|
|
sprintf(out, "%pUl", guid->b);
|
2005-04-17 06:20:36 +08:00
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void efi_init (void);
|
2020-08-07 14:25:01 +08:00
|
|
|
#ifdef CONFIG_EFI
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void efi_enter_virtual_mode (void); /* switch EFI to virtual mode, if possible */
|
2020-08-07 14:25:01 +08:00
|
|
|
#else
|
|
|
|
static inline void efi_enter_virtual_mode (void) {}
|
|
|
|
#endif
|
2012-09-29 08:55:44 +08:00
|
|
|
#ifdef CONFIG_X86
|
2016-02-02 06:06:58 +08:00
|
|
|
extern efi_status_t efi_query_variable_store(u32 attributes,
|
|
|
|
unsigned long size,
|
|
|
|
bool nonblocking);
|
2012-09-29 08:55:44 +08:00
|
|
|
#else
|
2013-03-25 17:14:30 +08:00
|
|
|
|
2016-02-02 06:06:58 +08:00
|
|
|
static inline efi_status_t efi_query_variable_store(u32 attributes,
|
|
|
|
unsigned long size,
|
|
|
|
bool nonblocking)
|
2013-03-25 17:14:30 +08:00
|
|
|
{
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
2012-09-29 08:55:44 +08:00
|
|
|
#endif
|
2012-09-29 08:56:08 +08:00
|
|
|
extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
|
2016-02-27 05:22:05 +08:00
|
|
|
|
2020-01-14 01:22:43 +08:00
|
|
|
extern int __init efi_memmap_alloc(unsigned int num_entries,
|
|
|
|
struct efi_memory_map_data *data);
|
2020-01-14 01:22:45 +08:00
|
|
|
extern void __efi_memmap_free(u64 phys, unsigned long size,
|
|
|
|
unsigned long flags);
|
2016-02-27 05:22:05 +08:00
|
|
|
extern int __init efi_memmap_init_early(struct efi_memory_map_data *data);
|
2016-02-27 23:52:50 +08:00
|
|
|
extern int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size);
|
2016-02-27 05:22:05 +08:00
|
|
|
extern void __init efi_memmap_unmap(void);
|
2020-01-14 01:22:43 +08:00
|
|
|
extern int __init efi_memmap_install(struct efi_memory_map_data *data);
|
2016-03-01 04:30:39 +08:00
|
|
|
extern int __init efi_memmap_split_count(efi_memory_desc_t *md,
|
|
|
|
struct range *range);
|
|
|
|
extern void __init efi_memmap_insert(struct efi_memory_map *old_memmap,
|
|
|
|
void *buf, struct efi_mem_range *mem);
|
2016-02-27 05:22:05 +08:00
|
|
|
|
efi: Work around ia64 build problem with ESRT driver
So, I'm told this problem exists in the world:
> Subject: Build error in -next due to 'efi: Add esrt support'
>
> Building ia64:defconfig ... failed
> --------------
> Error log:
>
> drivers/firmware/efi/esrt.c:28:31: fatal error: asm/early_ioremap.h: No such file or directory
>
I'm not really sure how it's okay that we have things in asm-generic on
some platforms but not others - is having it the same everywhere not the
whole point of asm-generic?
That said, ia64 doesn't have early_ioremap.h . So instead, since it's
difficult to imagine new IA64 machines with UEFI 2.5, just don't build
this code there.
To me this looks like a workaround - doing something like:
generic-y += early_ioremap.h
in arch/ia64/include/asm/Kbuild would appear to be more correct, but
ia64 has its own early_memremap() decl in arch/ia64/include/asm/io.h ,
and it's a macro. So adding the above /and/ requiring that asm/io.h be
included /after/ asm/early_ioremap.h in all cases would fix it, but
that's pretty ugly as well. Since I'm not going to spend the rest of my
life rectifying ia64 headers vs "generic" headers that aren't generic,
it's much simpler to just not build there.
Note that I've only actually tried to build this patch on x86_64, but
esrt.o still gets built there, and that would seem to demonstrate that
the conditional building is working correctly at all the places the code
built before. I no longer have any ia64 machines handy to test that the
exclusion actually works there.
Signed-off-by: Peter Jones <pjones@redhat.com>
Acked-by: Tony Luck <tony.luck@intel.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
(Compile-)Tested-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2015-06-06 03:14:54 +08:00
|
|
|
#ifdef CONFIG_EFI_ESRT
|
2015-04-29 06:44:31 +08:00
|
|
|
extern void __init efi_esrt_init(void);
|
efi: Work around ia64 build problem with ESRT driver
So, I'm told this problem exists in the world:
> Subject: Build error in -next due to 'efi: Add esrt support'
>
> Building ia64:defconfig ... failed
> --------------
> Error log:
>
> drivers/firmware/efi/esrt.c:28:31: fatal error: asm/early_ioremap.h: No such file or directory
>
I'm not really sure how it's okay that we have things in asm-generic on
some platforms but not others - is having it the same everywhere not the
whole point of asm-generic?
That said, ia64 doesn't have early_ioremap.h . So instead, since it's
difficult to imagine new IA64 machines with UEFI 2.5, just don't build
this code there.
To me this looks like a workaround - doing something like:
generic-y += early_ioremap.h
in arch/ia64/include/asm/Kbuild would appear to be more correct, but
ia64 has its own early_memremap() decl in arch/ia64/include/asm/io.h ,
and it's a macro. So adding the above /and/ requiring that asm/io.h be
included /after/ asm/early_ioremap.h in all cases would fix it, but
that's pretty ugly as well. Since I'm not going to spend the rest of my
life rectifying ia64 headers vs "generic" headers that aren't generic,
it's much simpler to just not build there.
Note that I've only actually tried to build this patch on x86_64, but
esrt.o still gets built there, and that would seem to demonstrate that
the conditional building is working correctly at all the places the code
built before. I no longer have any ia64 machines handy to test that the
exclusion actually works there.
Signed-off-by: Peter Jones <pjones@redhat.com>
Acked-by: Tony Luck <tony.luck@intel.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
(Compile-)Tested-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2015-06-06 03:14:54 +08:00
|
|
|
#else
|
|
|
|
static inline void efi_esrt_init(void) { }
|
|
|
|
#endif
|
2020-01-22 21:40:57 +08:00
|
|
|
extern int efi_config_parse_tables(const efi_config_table_t *config_tables,
|
|
|
|
int count,
|
|
|
|
const efi_config_table_type_t *arch_tables);
|
2020-01-20 17:49:11 +08:00
|
|
|
extern int efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
|
|
|
|
int min_major_version);
|
|
|
|
extern void efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
|
|
|
|
unsigned long fw_vendor);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern u64 efi_get_iobase (void);
|
2017-07-18 05:10:14 +08:00
|
|
|
extern int efi_mem_type(unsigned long phys_addr);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern u64 efi_mem_attributes (unsigned long phys_addr);
|
2006-05-06 07:19:50 +08:00
|
|
|
extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern int __init efi_uart_console_only (void);
|
2015-04-29 06:44:31 +08:00
|
|
|
extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
|
|
|
|
extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
|
2016-03-01 05:22:52 +08:00
|
|
|
extern void efi_mem_reserve(phys_addr_t addr, u64 size);
|
2018-09-22 00:32:46 +08:00
|
|
|
extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);
|
2005-04-17 06:20:36 +08:00
|
|
|
extern void efi_initialize_iomem_resources(struct resource *code_resource,
|
2007-10-22 07:42:01 +08:00
|
|
|
struct resource *data_resource, struct resource *bss_resource);
|
2020-02-18 17:19:34 +08:00
|
|
|
extern u64 efi_get_fdt_params(struct efi_memory_map_data *data);
|
2015-04-29 06:44:31 +08:00
|
|
|
extern struct kobject *efi_kobj;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-06-13 19:39:55 +08:00
|
|
|
extern int efi_reboot_quirk_mode;
|
efi/reboot: Allow powering off machines using EFI
Not only can EfiResetSystem() be used to reboot, it can also be used to
power down machines.
By and large, this functionality doesn't work very well across the range
of EFI machines in the wild, so it should definitely only be used as a
last resort. In an ideal world, this wouldn't be needed at all.
Unfortunately, we're starting to see machines where EFI is the *only*
reliable way to power down, and nothing else, not PCI, not ACPI, works.
efi_poweroff_required() should be implemented on a per-architecture
basis, since exactly when we should be using EFI runtime services is a
platform-specific decision. There's no analogue for reboot because each
architecture handles reboot very differently - the x86 code in
particular is pretty complex.
Patches to enable this for specific classes of hardware will be
submitted separately.
Tested-by: Mark Salter <msalter@redhat.com>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2014-06-13 19:35:21 +08:00
|
|
|
extern bool efi_poweroff_required(void);
|
|
|
|
|
2015-09-30 22:01:56 +08:00
|
|
|
#ifdef CONFIG_EFI_FAKE_MEMMAP
|
|
|
|
extern void __init efi_fake_memmap(void);
|
|
|
|
#else
|
|
|
|
static inline void efi_fake_memmap(void) { }
|
|
|
|
#endif
|
|
|
|
|
2020-01-22 22:05:12 +08:00
|
|
|
extern unsigned long efi_mem_attr_table;
|
|
|
|
|
2016-04-26 04:06:45 +08:00
|
|
|
/*
|
|
|
|
* efi_memattr_perm_setter - arch specific callback function passed into
|
|
|
|
* efi_memattr_apply_permissions() that updates the
|
|
|
|
* mapping permissions described by the second
|
|
|
|
* argument in the page tables referred to by the
|
|
|
|
* first argument.
|
|
|
|
*/
|
|
|
|
typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *);
|
|
|
|
|
|
|
|
extern int efi_memattr_init(void);
|
|
|
|
extern int efi_memattr_apply_permissions(struct mm_struct *mm,
|
|
|
|
efi_memattr_perm_setter fn);
|
|
|
|
|
2017-08-16 21:46:51 +08:00
|
|
|
/*
|
|
|
|
* efi_early_memdesc_ptr - get the n-th EFI memmap descriptor
|
|
|
|
* @map: the start of efi memmap
|
|
|
|
* @desc_size: the size of space for each EFI memmap descriptor
|
|
|
|
* @n: the index of efi memmap descriptor
|
|
|
|
*
|
|
|
|
* EFI boot service provides the GetMemoryMap() function to get a copy of the
|
|
|
|
* current memory map which is an array of memory descriptors, each of
|
|
|
|
* which describes a contiguous block of memory. It also gets the size of the
|
|
|
|
* map, and the size of each descriptor, etc.
|
|
|
|
*
|
|
|
|
* Note that per section 6.2 of UEFI Spec 2.6 Errata A, the returned size of
|
|
|
|
* each descriptor might not be equal to sizeof(efi_memory_memdesc_t),
|
|
|
|
* since efi_memory_memdesc_t may be extended in the future. Thus the OS
|
|
|
|
* MUST use the returned size of the descriptor to find the start of each
|
|
|
|
* efi_memory_memdesc_t in the memory map array. This should only be used
|
|
|
|
* during bootup since for_each_efi_memory_desc_xxx() is available after the
|
|
|
|
* kernel initializes the EFI subsystem to set up struct efi_memory_map.
|
|
|
|
*/
|
|
|
|
#define efi_early_memdesc_ptr(map, desc_size, n) \
|
|
|
|
(efi_memory_desc_t *)((void *)(map) + ((n) * (desc_size)))
|
|
|
|
|
2014-01-11 03:26:06 +08:00
|
|
|
/* Iterate through an efi_memory_map */
|
2016-04-26 04:06:38 +08:00
|
|
|
#define for_each_efi_memory_desc_in_map(m, md) \
|
2014-01-11 03:26:06 +08:00
|
|
|
for ((md) = (m)->map; \
|
2016-08-15 23:05:45 +08:00
|
|
|
(md) && ((void *)(md) + (m)->desc_size) <= (m)->map_end; \
|
2014-01-11 03:26:06 +08:00
|
|
|
(md) = (void *)(md) + (m)->desc_size)
|
|
|
|
|
2016-04-26 04:06:38 +08:00
|
|
|
/**
|
|
|
|
* for_each_efi_memory_desc - iterate over descriptors in efi.memmap
|
|
|
|
* @md: the efi_memory_desc_t * iterator
|
|
|
|
*
|
|
|
|
* Once the loop finishes @md must not be accessed.
|
|
|
|
*/
|
|
|
|
#define for_each_efi_memory_desc(md) \
|
2016-04-26 04:06:39 +08:00
|
|
|
for_each_efi_memory_desc_in_map(&efi.memmap, md)
|
2016-04-26 04:06:38 +08:00
|
|
|
|
2014-09-03 19:32:20 +08:00
|
|
|
/*
|
|
|
|
* Format an EFI memory descriptor's type and attributes to a user-provided
|
|
|
|
* character buffer, as per snprintf(), and return the buffer.
|
|
|
|
*/
|
|
|
|
char * __init efi_md_typeattr_format(char *buf, size_t size,
|
|
|
|
const efi_memory_desc_t *md);
|
|
|
|
|
2018-12-09 04:27:02 +08:00
|
|
|
|
|
|
|
typedef void (*efi_element_handler_t)(const char *source,
|
|
|
|
const void *element_data,
|
|
|
|
size_t element_size);
|
|
|
|
extern int __init parse_efi_signature_list(
|
|
|
|
const char *source,
|
|
|
|
const void *data, size_t size,
|
|
|
|
efi_element_handler_t (*get_handler_for_guid)(const efi_guid_t *));
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* efi_range_is_wc - check the WC bit on an address range
|
|
|
|
* @start: starting kvirt address
|
|
|
|
* @len: length of range
|
|
|
|
*
|
|
|
|
* Consult the EFI memory map and make sure it's ok to set this range WC.
|
|
|
|
* Returns true or false.
|
|
|
|
*/
|
|
|
|
static inline int efi_range_is_wc(unsigned long start, unsigned long len)
|
|
|
|
{
|
2005-06-17 06:14:00 +08:00
|
|
|
unsigned long i;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
|
|
|
|
unsigned long paddr = __pa(start + i);
|
|
|
|
if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* The range checked out */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_EFI_PCDP
|
|
|
|
extern int __init efi_setup_pcdp_console(char *);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2012-11-14 17:42:35 +08:00
|
|
|
* We play games with efi_enabled so that the compiler will, if
|
|
|
|
* possible, remove EFI-related code altogether.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2012-11-14 17:42:35 +08:00
|
|
|
#define EFI_BOOT 0 /* Were we booted from EFI? */
|
|
|
|
#define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */
|
|
|
|
#define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */
|
|
|
|
#define EFI_MEMMAP 4 /* Can we use EFI memory map? */
|
|
|
|
#define EFI_64BIT 5 /* Is the firmware 64-bit? */
|
2014-07-01 01:52:58 +08:00
|
|
|
#define EFI_PARAVIRT 6 /* Access is via a paravirt interface */
|
|
|
|
#define EFI_ARCH_1 7 /* First arch-specific bit */
|
2015-02-05 18:44:41 +08:00
|
|
|
#define EFI_DBG 8 /* Print additional debug info at runtime */
|
2015-09-23 22:29:34 +08:00
|
|
|
#define EFI_NX_PE_DATA 9 /* Can runtime data regions be mapped non-executable? */
|
2017-01-31 21:21:36 +08:00
|
|
|
#define EFI_MEM_ATTR 10 /* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */
|
2019-11-07 09:43:11 +08:00
|
|
|
#define EFI_MEM_NO_SOFT_RESERVE 11 /* Is the kernel configured to ignore soft reservations? */
|
2020-01-16 00:35:45 +08:00
|
|
|
#define EFI_PRESERVE_BS_REGIONS 12 /* Are EFI boot-services memory segments available? */
|
2012-11-14 17:42:35 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#ifdef CONFIG_EFI
|
2014-01-15 21:21:22 +08:00
|
|
|
/*
|
|
|
|
* Test whether the above EFI_* bits are enabled.
|
|
|
|
*/
|
|
|
|
static inline bool efi_enabled(int feature)
|
|
|
|
{
|
|
|
|
return test_bit(feature, &efi.flags) != 0;
|
|
|
|
}
|
2014-06-13 19:22:22 +08:00
|
|
|
extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
|
2019-11-07 09:43:11 +08:00
|
|
|
|
|
|
|
bool __pure __efi_soft_reserve_enabled(void);
|
|
|
|
|
|
|
|
static inline bool __pure efi_soft_reserve_enabled(void)
|
|
|
|
{
|
|
|
|
return IS_ENABLED(CONFIG_EFI_SOFT_RESERVE)
|
|
|
|
&& __efi_soft_reserve_enabled();
|
|
|
|
}
|
2020-01-21 18:17:47 +08:00
|
|
|
|
|
|
|
static inline bool efi_rt_services_supported(unsigned int mask)
|
|
|
|
{
|
|
|
|
return (efi.runtime_supported_mask & mask) == mask;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#else
|
2014-01-15 21:21:22 +08:00
|
|
|
static inline bool efi_enabled(int feature)
|
2012-11-14 17:42:35 +08:00
|
|
|
{
|
2014-01-15 21:21:22 +08:00
|
|
|
return false;
|
2012-11-14 17:42:35 +08:00
|
|
|
}
|
2014-06-13 19:22:22 +08:00
|
|
|
static inline void
|
|
|
|
efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {}
|
2016-04-26 04:07:00 +08:00
|
|
|
|
2019-11-07 09:43:11 +08:00
|
|
|
static inline bool efi_soft_reserve_enabled(void)
|
|
|
|
{
|
|
|
|
return false;
|
2020-01-21 18:17:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool efi_rt_services_supported(unsigned int mask)
|
|
|
|
{
|
|
|
|
return false;
|
2019-11-07 09:43:11 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2016-04-26 04:06:58 +08:00
|
|
|
extern int efi_status_to_err(efi_status_t status);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Variable Attributes
|
|
|
|
*/
|
|
|
|
#define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001
|
|
|
|
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002
|
|
|
|
#define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004
|
2012-05-01 04:11:29 +08:00
|
|
|
#define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008
|
|
|
|
#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010
|
|
|
|
#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020
|
|
|
|
#define EFI_VARIABLE_APPEND_WRITE 0x0000000000000040
|
|
|
|
|
2021-10-29 05:05:17 +08:00
|
|
|
#define EFI_VARIABLE_MASK (EFI_VARIABLE_NON_VOLATILE | \
|
2012-05-01 04:11:29 +08:00
|
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS | \
|
|
|
|
EFI_VARIABLE_RUNTIME_ACCESS | \
|
|
|
|
EFI_VARIABLE_HARDWARE_ERROR_RECORD | \
|
|
|
|
EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \
|
|
|
|
EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \
|
|
|
|
EFI_VARIABLE_APPEND_WRITE)
|
2013-02-04 04:16:40 +08:00
|
|
|
/*
|
|
|
|
* Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
|
|
|
|
* not including trailing NUL
|
|
|
|
*/
|
2016-05-21 08:01:18 +08:00
|
|
|
#define EFI_VARIABLE_GUID_LEN UUID_STRING_LEN
|
2013-02-04 04:16:40 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* EFI Device Path information
|
|
|
|
*/
|
|
|
|
#define EFI_DEV_HW 0x01
|
|
|
|
#define EFI_DEV_PCI 1
|
|
|
|
#define EFI_DEV_PCCARD 2
|
|
|
|
#define EFI_DEV_MEM_MAPPED 3
|
|
|
|
#define EFI_DEV_VENDOR 4
|
|
|
|
#define EFI_DEV_CONTROLLER 5
|
|
|
|
#define EFI_DEV_ACPI 0x02
|
|
|
|
#define EFI_DEV_BASIC_ACPI 1
|
|
|
|
#define EFI_DEV_EXPANDED_ACPI 2
|
|
|
|
#define EFI_DEV_MSG 0x03
|
|
|
|
#define EFI_DEV_MSG_ATAPI 1
|
|
|
|
#define EFI_DEV_MSG_SCSI 2
|
|
|
|
#define EFI_DEV_MSG_FC 3
|
|
|
|
#define EFI_DEV_MSG_1394 4
|
|
|
|
#define EFI_DEV_MSG_USB 5
|
|
|
|
#define EFI_DEV_MSG_USB_CLASS 15
|
|
|
|
#define EFI_DEV_MSG_I20 6
|
|
|
|
#define EFI_DEV_MSG_MAC 11
|
|
|
|
#define EFI_DEV_MSG_IPV4 12
|
|
|
|
#define EFI_DEV_MSG_IPV6 13
|
|
|
|
#define EFI_DEV_MSG_INFINIBAND 9
|
|
|
|
#define EFI_DEV_MSG_UART 14
|
|
|
|
#define EFI_DEV_MSG_VENDOR 10
|
|
|
|
#define EFI_DEV_MEDIA 0x04
|
|
|
|
#define EFI_DEV_MEDIA_HARD_DRIVE 1
|
|
|
|
#define EFI_DEV_MEDIA_CDROM 2
|
|
|
|
#define EFI_DEV_MEDIA_VENDOR 3
|
|
|
|
#define EFI_DEV_MEDIA_FILE 4
|
|
|
|
#define EFI_DEV_MEDIA_PROTOCOL 5
|
|
|
|
#define EFI_DEV_BIOS_BOOT 0x05
|
|
|
|
#define EFI_DEV_END_PATH 0x7F
|
|
|
|
#define EFI_DEV_END_PATH2 0xFF
|
|
|
|
#define EFI_DEV_END_INSTANCE 0x01
|
|
|
|
#define EFI_DEV_END_ENTIRE 0xFF
|
|
|
|
|
|
|
|
struct efi_generic_dev_path {
|
2020-02-10 16:46:57 +08:00
|
|
|
u8 type;
|
|
|
|
u8 sub_type;
|
|
|
|
u16 length;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct efi_acpi_dev_path {
|
|
|
|
struct efi_generic_dev_path header;
|
|
|
|
u32 hid;
|
|
|
|
u32 uid;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct efi_pci_dev_path {
|
|
|
|
struct efi_generic_dev_path header;
|
|
|
|
u8 fn;
|
|
|
|
u8 dev;
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
struct efi_vendor_dev_path {
|
|
|
|
struct efi_generic_dev_path header;
|
|
|
|
efi_guid_t vendorguid;
|
|
|
|
u8 vendordata[];
|
|
|
|
} __packed;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2016-11-13 05:32:34 +08:00
|
|
|
struct efi_dev_path {
|
|
|
|
union {
|
2020-02-10 16:46:57 +08:00
|
|
|
struct efi_generic_dev_path header;
|
|
|
|
struct efi_acpi_dev_path acpi;
|
|
|
|
struct efi_pci_dev_path pci;
|
|
|
|
struct efi_vendor_dev_path vendor;
|
2016-11-13 05:32:34 +08:00
|
|
|
};
|
2020-02-10 16:46:57 +08:00
|
|
|
} __packed;
|
2016-11-13 05:32:34 +08:00
|
|
|
|
2020-02-10 16:46:57 +08:00
|
|
|
struct device *efi_get_device_by_path(const struct efi_dev_path **node,
|
|
|
|
size_t *len);
|
2016-11-13 05:32:34 +08:00
|
|
|
|
2008-02-25 15:18:37 +08:00
|
|
|
static inline void memrange_efi_to_native(u64 *addr, u64 *npages)
|
|
|
|
{
|
|
|
|
*npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr);
|
|
|
|
*addr &= PAGE_MASK;
|
|
|
|
}
|
|
|
|
|
2011-03-12 09:43:27 +08:00
|
|
|
/*
|
|
|
|
* EFI Variable support.
|
|
|
|
*
|
|
|
|
* Different firmware drivers can expose their EFI-like variables using
|
|
|
|
* the following.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct efivar_operations {
|
|
|
|
efi_get_variable_t *get_variable;
|
|
|
|
efi_get_next_variable_t *get_next_variable;
|
|
|
|
efi_set_variable_t *set_variable;
|
2016-02-02 06:06:56 +08:00
|
|
|
efi_set_variable_t *set_variable_nonblocking;
|
2013-03-25 17:14:30 +08:00
|
|
|
efi_query_variable_store_t *query_variable_store;
|
2011-03-12 09:43:27 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct efivars {
|
|
|
|
struct kset *kset;
|
2012-10-05 13:54:56 +08:00
|
|
|
struct kobject *kobject;
|
2011-03-12 09:43:27 +08:00
|
|
|
const struct efivar_operations *ops;
|
|
|
|
};
|
|
|
|
|
2013-02-04 04:16:40 +08:00
|
|
|
/*
|
|
|
|
* The maximum size of VariableName + Data = 1024
|
|
|
|
* Therefore, it's reasonable to save that much
|
|
|
|
* space in each part of the structure,
|
|
|
|
* and we use a page for reading/writing.
|
|
|
|
*/
|
|
|
|
|
2014-03-17 18:57:00 +08:00
|
|
|
#define EFI_VAR_NAME_LEN 1024
|
|
|
|
|
2013-02-04 04:16:40 +08:00
|
|
|
struct efi_variable {
|
2014-03-17 18:57:00 +08:00
|
|
|
efi_char16_t VariableName[EFI_VAR_NAME_LEN/sizeof(efi_char16_t)];
|
2013-02-04 04:16:40 +08:00
|
|
|
efi_guid_t VendorGuid;
|
|
|
|
unsigned long DataSize;
|
|
|
|
__u8 Data[1024];
|
|
|
|
efi_status_t Status;
|
|
|
|
__u32 Attributes;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct efivar_entry {
|
|
|
|
struct efi_variable var;
|
|
|
|
struct list_head list;
|
|
|
|
struct kobject kobj;
|
efivars, efi-pstore: Hold off deletion of sysfs entry until the scan is completed
Currently, when mounting pstore file system, a read callback of
efi_pstore driver runs mutiple times as below.
- In the first read callback, scan efivar_sysfs_list from head and pass
a kmsg buffer of a entry to an upper pstore layer.
- In the second read callback, rescan efivar_sysfs_list from the entry
and pass another kmsg buffer to it.
- Repeat the scan and pass until the end of efivar_sysfs_list.
In this process, an entry is read across the multiple read function
calls. To avoid race between the read and erasion, the whole process
above is protected by a spinlock, holding in open() and releasing in
close().
At the same time, kmemdup() is called to pass the buffer to pstore
filesystem during it. And then, it causes a following lockdep warning.
To make the dynamic memory allocation runnable without taking spinlock,
holding off a deletion of sysfs entry if it happens while scanning it
via efi_pstore, and deleting it after the scan is completed.
To implement it, this patch introduces two flags, scanning and deleting,
to efivar_entry.
On the code basis, it seems that all the scanning and deleting logic is
not needed because __efivars->lock are not dropped when reading from the
EFI variable store.
But, the scanning and deleting logic is still needed because an
efi-pstore and a pstore filesystem works as follows.
In case an entry(A) is found, the pointer is saved to psi->data. And
efi_pstore_read() passes the entry(A) to a pstore filesystem by
releasing __efivars->lock.
And then, the pstore filesystem calls efi_pstore_read() again and the
same entry(A), which is saved to psi->data, is used for resuming to scan
a sysfs-list.
So, to protect the entry(A), the logic is needed.
[ 1.143710] ------------[ cut here ]------------
[ 1.144058] WARNING: CPU: 1 PID: 1 at kernel/lockdep.c:2740 lockdep_trace_alloc+0x104/0x110()
[ 1.144058] DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags))
[ 1.144058] Modules linked in:
[ 1.144058] CPU: 1 PID: 1 Comm: systemd Not tainted 3.11.0-rc5 #2
[ 1.144058] 0000000000000009 ffff8800797e9ae0 ffffffff816614a5 ffff8800797e9b28
[ 1.144058] ffff8800797e9b18 ffffffff8105510d 0000000000000080 0000000000000046
[ 1.144058] 00000000000000d0 00000000000003af ffffffff81ccd0c0 ffff8800797e9b78
[ 1.144058] Call Trace:
[ 1.144058] [<ffffffff816614a5>] dump_stack+0x54/0x74
[ 1.144058] [<ffffffff8105510d>] warn_slowpath_common+0x7d/0xa0
[ 1.144058] [<ffffffff8105517c>] warn_slowpath_fmt+0x4c/0x50
[ 1.144058] [<ffffffff8131290f>] ? vsscanf+0x57f/0x7b0
[ 1.144058] [<ffffffff810bbd74>] lockdep_trace_alloc+0x104/0x110
[ 1.144058] [<ffffffff81192da0>] __kmalloc_track_caller+0x50/0x280
[ 1.144058] [<ffffffff815147bb>] ? efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff8115b260>] kmemdup+0x20/0x50
[ 1.144058] [<ffffffff815147bb>] efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff81514800>] ? efi_pstore_read_func.part.1+0x170/0x170
[ 1.144058] [<ffffffff815148b4>] efi_pstore_read_func+0xb4/0xe0
[ 1.144058] [<ffffffff81512b7b>] __efivar_entry_iter+0xfb/0x120
[ 1.144058] [<ffffffff8151428f>] efi_pstore_read+0x3f/0x50
[ 1.144058] [<ffffffff8128d7ba>] pstore_get_records+0x9a/0x150
[ 1.158207] [<ffffffff812af25c>] ? selinux_d_instantiate+0x1c/0x20
[ 1.158207] [<ffffffff8128ce30>] ? parse_options+0x80/0x80
[ 1.158207] [<ffffffff8128ced5>] pstore_fill_super+0xa5/0xc0
[ 1.158207] [<ffffffff811ae7d2>] mount_single+0xa2/0xd0
[ 1.158207] [<ffffffff8128ccf8>] pstore_mount+0x18/0x20
[ 1.158207] [<ffffffff811ae8b9>] mount_fs+0x39/0x1b0
[ 1.158207] [<ffffffff81160550>] ? __alloc_percpu+0x10/0x20
[ 1.158207] [<ffffffff811c9493>] vfs_kern_mount+0x63/0xf0
[ 1.158207] [<ffffffff811cbb0e>] do_mount+0x23e/0xa20
[ 1.158207] [<ffffffff8115b51b>] ? strndup_user+0x4b/0xf0
[ 1.158207] [<ffffffff811cc373>] SyS_mount+0x83/0xc0
[ 1.158207] [<ffffffff81673cc2>] system_call_fastpath+0x16/0x1b
[ 1.158207] ---[ end trace 61981bc62de9f6f4 ]---
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Tested-by: Madper Xie <cxie@redhat.com>
Cc: stable@kernel.org
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2013-10-31 03:27:26 +08:00
|
|
|
bool scanning;
|
|
|
|
bool deleting;
|
2013-02-04 04:16:40 +08:00
|
|
|
};
|
|
|
|
|
2013-02-08 23:48:51 +08:00
|
|
|
static inline void
|
|
|
|
efivar_unregister(struct efivar_entry *var)
|
|
|
|
{
|
|
|
|
kobject_put(&var->kobj);
|
|
|
|
}
|
|
|
|
|
2013-02-04 04:16:40 +08:00
|
|
|
int efivars_register(struct efivars *efivars,
|
2011-03-12 09:43:27 +08:00
|
|
|
const struct efivar_operations *ops,
|
2013-02-04 04:16:40 +08:00
|
|
|
struct kobject *kobject);
|
|
|
|
int efivars_unregister(struct efivars *efivars);
|
|
|
|
struct kobject *efivars_kobject(void);
|
|
|
|
|
2020-07-08 18:01:57 +08:00
|
|
|
int efivar_supports_writes(void);
|
2013-02-04 04:16:40 +08:00
|
|
|
int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *),
|
2016-05-07 05:39:30 +08:00
|
|
|
void *data, bool duplicates, struct list_head *head);
|
2013-02-04 04:16:40 +08:00
|
|
|
|
2016-07-16 03:36:30 +08:00
|
|
|
int efivar_entry_add(struct efivar_entry *entry, struct list_head *head);
|
|
|
|
int efivar_entry_remove(struct efivar_entry *entry);
|
2013-02-04 04:16:40 +08:00
|
|
|
|
|
|
|
int __efivar_entry_delete(struct efivar_entry *entry);
|
|
|
|
int efivar_entry_delete(struct efivar_entry *entry);
|
|
|
|
|
|
|
|
int efivar_entry_size(struct efivar_entry *entry, unsigned long *size);
|
2013-04-30 03:08:02 +08:00
|
|
|
int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
|
|
|
unsigned long *size, void *data);
|
2013-02-04 04:16:40 +08:00
|
|
|
int efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
|
|
|
unsigned long *size, void *data);
|
|
|
|
int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
|
|
|
|
unsigned long size, void *data, struct list_head *head);
|
|
|
|
int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
|
|
|
|
unsigned long *size, void *data, bool *set);
|
|
|
|
int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
|
|
|
|
bool block, unsigned long size, void *data);
|
|
|
|
|
2016-07-16 03:36:30 +08:00
|
|
|
int efivar_entry_iter_begin(void);
|
2013-02-04 04:16:40 +08:00
|
|
|
void efivar_entry_iter_end(void);
|
|
|
|
|
|
|
|
int __efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
|
|
|
|
struct list_head *head, void *data,
|
|
|
|
struct efivar_entry **prev);
|
|
|
|
int efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
|
|
|
|
struct list_head *head, void *data);
|
|
|
|
|
|
|
|
struct efivar_entry *efivar_entry_find(efi_char16_t *name, efi_guid_t guid,
|
|
|
|
struct list_head *head, bool remove);
|
|
|
|
|
2016-02-09 03:48:14 +08:00
|
|
|
bool efivar_validate(efi_guid_t vendor, efi_char16_t *var_name, u8 *data,
|
|
|
|
unsigned long data_size);
|
2016-02-09 03:48:15 +08:00
|
|
|
bool efivar_variable_is_removable(efi_guid_t vendor, const char *name,
|
|
|
|
size_t len);
|
2013-02-04 04:16:40 +08:00
|
|
|
|
2020-12-13 16:39:40 +08:00
|
|
|
#if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER)
|
2016-04-26 04:06:59 +08:00
|
|
|
extern bool efi_capsule_pending(int *reset_type);
|
|
|
|
|
|
|
|
extern int efi_capsule_supported(efi_guid_t guid, u32 flags,
|
|
|
|
size_t size, int *reset);
|
|
|
|
|
|
|
|
extern int efi_capsule_update(efi_capsule_header_t *capsule,
|
2017-06-02 21:52:03 +08:00
|
|
|
phys_addr_t *pages);
|
2020-12-13 16:39:40 +08:00
|
|
|
#else
|
|
|
|
static inline bool efi_capsule_pending(int *reset_type) { return false; }
|
|
|
|
#endif
|
2011-03-12 09:43:27 +08:00
|
|
|
|
2013-12-20 18:02:18 +08:00
|
|
|
#ifdef CONFIG_EFI_RUNTIME_MAP
|
|
|
|
int efi_runtime_map_init(struct kobject *);
|
2014-08-09 05:26:11 +08:00
|
|
|
int efi_get_runtime_map_size(void);
|
|
|
|
int efi_get_runtime_map_desc_size(void);
|
|
|
|
int efi_runtime_map_copy(void *buf, size_t bufsz);
|
2013-12-20 18:02:18 +08:00
|
|
|
#else
|
|
|
|
static inline int efi_runtime_map_init(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-09 05:26:11 +08:00
|
|
|
static inline int efi_get_runtime_map_size(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int efi_get_runtime_map_desc_size(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int efi_runtime_map_copy(void *buf, size_t bufsz)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-20 18:02:18 +08:00
|
|
|
#endif
|
|
|
|
|
2019-04-12 16:01:53 +08:00
|
|
|
#ifdef CONFIG_EFI
|
|
|
|
extern bool efi_runtime_disabled(void);
|
|
|
|
#else
|
|
|
|
static inline bool efi_runtime_disabled(void) { return true; }
|
|
|
|
#endif
|
|
|
|
|
2016-06-25 15:20:27 +08:00
|
|
|
extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
|
2019-01-31 22:58:49 +08:00
|
|
|
extern unsigned long efi_call_virt_save_flags(void);
|
2016-06-25 15:20:27 +08:00
|
|
|
|
2017-02-06 19:22:43 +08:00
|
|
|
enum efi_secureboot_mode {
|
|
|
|
efi_secureboot_mode_unset,
|
|
|
|
efi_secureboot_mode_unknown,
|
|
|
|
efi_secureboot_mode_disabled,
|
|
|
|
efi_secureboot_mode_enabled,
|
|
|
|
};
|
2020-10-30 14:08:38 +08:00
|
|
|
|
|
|
|
static inline
|
|
|
|
enum efi_secureboot_mode efi_get_secureboot_mode(efi_get_variable_t *get_var)
|
|
|
|
{
|
|
|
|
u8 secboot, setupmode = 0;
|
|
|
|
efi_status_t status;
|
|
|
|
unsigned long size;
|
|
|
|
|
|
|
|
size = sizeof(secboot);
|
|
|
|
status = get_var(L"SecureBoot", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size,
|
|
|
|
&secboot);
|
|
|
|
if (status == EFI_NOT_FOUND)
|
|
|
|
return efi_secureboot_mode_disabled;
|
|
|
|
if (status != EFI_SUCCESS)
|
|
|
|
return efi_secureboot_mode_unknown;
|
|
|
|
|
|
|
|
size = sizeof(setupmode);
|
|
|
|
get_var(L"SetupMode", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size, &setupmode);
|
|
|
|
if (secboot == 0 || setupmode == 1)
|
|
|
|
return efi_secureboot_mode_disabled;
|
|
|
|
return efi_secureboot_mode_enabled;
|
|
|
|
}
|
2017-02-06 19:22:43 +08:00
|
|
|
|
efi: Add embedded peripheral firmware support
Just like with PCI options ROMs, which we save in the setup_efi_pci*
functions from arch/x86/boot/compressed/eboot.c, the EFI code / ROM itself
sometimes may contain data which is useful/necessary for peripheral drivers
to have access to.
Specifically the EFI code may contain an embedded copy of firmware which
needs to be (re)loaded into the peripheral. Normally such firmware would be
part of linux-firmware, but in some cases this is not feasible, for 2
reasons:
1) The firmware is customized for a specific use-case of the chipset / use
with a specific hardware model, so we cannot have a single firmware file
for the chipset. E.g. touchscreen controller firmwares are compiled
specifically for the hardware model they are used with, as they are
calibrated for a specific model digitizer.
2) Despite repeated attempts we have failed to get permission to
redistribute the firmware. This is especially a problem with customized
firmwares, these get created by the chip vendor for a specific ODM and the
copyright may partially belong with the ODM, so the chip vendor cannot
give a blanket permission to distribute these.
This commit adds support for finding peripheral firmware embedded in the
EFI code and makes the found firmware available through the new
efi_get_embedded_fw() function.
Support for loading these firmwares through the standard firmware loading
mechanism is added in a follow-up commit in this patch-series.
Note we check the EFI_BOOT_SERVICES_CODE for embedded firmware near the end
of start_kernel(), just before calling rest_init(), this is on purpose
because the typical EFI_BOOT_SERVICES_CODE memory-segment is too large for
early_memremap(), so the check must be done after mm_init(). This relies
on EFI_BOOT_SERVICES_CODE not being free-ed until efi_free_boot_services()
is called, which means that this will only work on x86 for now.
Reported-by: Dave Olsthoorn <dave@bewaar.me>
Suggested-by: Peter Jones <pjones@redhat.com>
Acked-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Link: https://lore.kernel.org/r/20200115163554.101315-3-hdegoede@redhat.com
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2020-01-16 00:35:46 +08:00
|
|
|
#ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
|
|
|
|
void efi_check_for_embedded_firmwares(void);
|
|
|
|
#else
|
|
|
|
static inline void efi_check_for_embedded_firmwares(void) { }
|
|
|
|
#endif
|
|
|
|
|
2019-12-24 23:10:19 +08:00
|
|
|
efi_status_t efi_random_get_seed(void);
|
2019-11-06 15:06:13 +08:00
|
|
|
|
2016-06-25 15:20:27 +08:00
|
|
|
/*
|
|
|
|
* Arch code can implement the following three template macros, avoiding
|
|
|
|
* reptition for the void/non-void return cases of {__,}efi_call_virt():
|
|
|
|
*
|
|
|
|
* * arch_efi_call_virt_setup()
|
|
|
|
*
|
|
|
|
* Sets up the environment for the call (e.g. switching page tables,
|
|
|
|
* allowing kernel-mode use of floating point, if required).
|
|
|
|
*
|
|
|
|
* * arch_efi_call_virt()
|
|
|
|
*
|
|
|
|
* Performs the call. The last expression in the macro must be the call
|
|
|
|
* itself, allowing the logic to be shared by the void and non-void
|
|
|
|
* cases.
|
|
|
|
*
|
|
|
|
* * arch_efi_call_virt_teardown()
|
|
|
|
*
|
|
|
|
* Restores the usual kernel environment once the call has returned.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#define efi_call_virt_pointer(p, f, args...) \
|
|
|
|
({ \
|
|
|
|
efi_status_t __s; \
|
|
|
|
unsigned long __flags; \
|
|
|
|
\
|
|
|
|
arch_efi_call_virt_setup(); \
|
|
|
|
\
|
2019-01-31 22:58:49 +08:00
|
|
|
__flags = efi_call_virt_save_flags(); \
|
2016-06-25 15:20:27 +08:00
|
|
|
__s = arch_efi_call_virt(p, f, args); \
|
|
|
|
efi_call_virt_check_flags(__flags, __stringify(f)); \
|
|
|
|
\
|
|
|
|
arch_efi_call_virt_teardown(); \
|
|
|
|
\
|
|
|
|
__s; \
|
|
|
|
})
|
|
|
|
|
|
|
|
#define __efi_call_virt_pointer(p, f, args...) \
|
|
|
|
({ \
|
|
|
|
unsigned long __flags; \
|
|
|
|
\
|
|
|
|
arch_efi_call_virt_setup(); \
|
|
|
|
\
|
2019-01-31 22:58:49 +08:00
|
|
|
__flags = efi_call_virt_save_flags(); \
|
2016-06-25 15:20:27 +08:00
|
|
|
arch_efi_call_virt(p, f, args); \
|
|
|
|
efi_call_virt_check_flags(__flags, __stringify(f)); \
|
|
|
|
\
|
|
|
|
arch_efi_call_virt_teardown(); \
|
|
|
|
})
|
|
|
|
|
2017-08-25 23:50:16 +08:00
|
|
|
#define EFI_RANDOM_SEED_SIZE 64U
|
|
|
|
|
2016-11-13 05:32:31 +08:00
|
|
|
struct linux_efi_random_seed {
|
|
|
|
u32 size;
|
|
|
|
u8 bits[];
|
|
|
|
};
|
|
|
|
|
2017-09-20 16:13:39 +08:00
|
|
|
struct linux_efi_tpm_eventlog {
|
|
|
|
u32 size;
|
2019-06-08 04:51:47 +08:00
|
|
|
u32 final_events_preboot_size;
|
2017-09-20 16:13:39 +08:00
|
|
|
u8 version;
|
|
|
|
u8 log[];
|
|
|
|
};
|
|
|
|
|
|
|
|
extern int efi_tpm_eventlog_init(void);
|
|
|
|
|
2019-05-21 04:54:59 +08:00
|
|
|
struct efi_tcg2_final_events_table {
|
|
|
|
u64 version;
|
|
|
|
u64 nr_events;
|
|
|
|
u8 events[];
|
|
|
|
};
|
|
|
|
extern int efi_tpm_final_log_size;
|
|
|
|
|
2019-07-11 02:59:15 +08:00
|
|
|
extern unsigned long rci2_table_phys;
|
|
|
|
|
2018-09-12 03:15:22 +08:00
|
|
|
/*
|
|
|
|
* efi_runtime_service() function identifiers.
|
|
|
|
* "NONE" is used by efi_recover_from_page_fault() to check if the page
|
|
|
|
* fault happened while executing an efi runtime service.
|
|
|
|
*/
|
2018-09-12 03:15:21 +08:00
|
|
|
enum efi_rts_ids {
|
2019-02-16 00:55:51 +08:00
|
|
|
EFI_NONE,
|
|
|
|
EFI_GET_TIME,
|
|
|
|
EFI_SET_TIME,
|
|
|
|
EFI_GET_WAKEUP_TIME,
|
|
|
|
EFI_SET_WAKEUP_TIME,
|
|
|
|
EFI_GET_VARIABLE,
|
|
|
|
EFI_GET_NEXT_VARIABLE,
|
|
|
|
EFI_SET_VARIABLE,
|
|
|
|
EFI_QUERY_VARIABLE_INFO,
|
|
|
|
EFI_GET_NEXT_HIGH_MONO_COUNT,
|
|
|
|
EFI_RESET_SYSTEM,
|
|
|
|
EFI_UPDATE_CAPSULE,
|
|
|
|
EFI_QUERY_CAPSULE_CAPS,
|
2018-09-12 03:15:21 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* efi_runtime_work: Details of EFI Runtime Service work
|
|
|
|
* @arg<1-5>: EFI Runtime Service function arguments
|
|
|
|
* @status: Status of executing EFI Runtime Service
|
|
|
|
* @efi_rts_id: EFI Runtime Service function identifier
|
|
|
|
* @efi_rts_comp: Struct used for handling completions
|
|
|
|
*/
|
|
|
|
struct efi_runtime_work {
|
|
|
|
void *arg1;
|
|
|
|
void *arg2;
|
|
|
|
void *arg3;
|
|
|
|
void *arg4;
|
|
|
|
void *arg5;
|
|
|
|
efi_status_t status;
|
|
|
|
struct work_struct work;
|
|
|
|
enum efi_rts_ids efi_rts_id;
|
|
|
|
struct completion efi_rts_comp;
|
|
|
|
};
|
|
|
|
|
|
|
|
extern struct efi_runtime_work efi_rts_work;
|
|
|
|
|
efi: Use a work queue to invoke EFI Runtime Services
Presently, when a user process requests the kernel to execute any
UEFI runtime service, the kernel temporarily switches to a separate
set of page tables that describe the virtual mapping of the UEFI
runtime services regions in memory. Since UEFI runtime services are
typically invoked with interrupts enabled, any code that may be called
during this time, will have an incorrect view of the process's address
space. Although it is unusual for code running in interrupt context to
make assumptions about the process context it runs in, there are cases
(such as the perf subsystem taking samples) where this causes problems.
So let's set up a work queue for calling UEFI runtime services, so that
the actual calls are made when the work queue items are dispatched by a
work queue worker running in a separate kernel thread. Such threads are
not expected to have userland mappings in the first place, and so the
additional mappings created for the UEFI runtime services can never
clash with any.
The ResetSystem() runtime service is not covered by the work queue
handling, since it is not expected to return, and may be called at a
time when the kernel is torn down to the point where we cannot expect
work queues to still be operational.
The non-blocking variants of SetVariable() and QueryVariableInfo()
are also excluded: these are intended to be used from atomic context,
which obviously rules out waiting for a completion to be signalled by
another thread. Note that these variants are currently only used for
UEFI runtime services calls that occur very early in the boot, and
for ones that occur in critical conditions, e.g., to flush kernel logs
to UEFI variables via efi-pstore.
Suggested-by: Andy Lutomirski <luto@kernel.org>
Signed-off-by: Sai Praneeth Prakhya <sai.praneeth.prakhya@intel.com>
[ardb: exclude ResetSystem() from the workqueue treatment
merge from 2 separate patches and rewrite commit log]
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-efi@vger.kernel.org
Link: http://lkml.kernel.org/r/20180711094040.12506-4-ard.biesheuvel@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2018-07-11 17:40:35 +08:00
|
|
|
/* Workqueue to queue EFI Runtime Services */
|
|
|
|
extern struct workqueue_struct *efi_rts_wq;
|
|
|
|
|
2018-09-22 00:32:44 +08:00
|
|
|
struct linux_efi_memreserve {
|
2018-11-30 01:12:28 +08:00
|
|
|
int size; // allocated size of the array
|
|
|
|
atomic_t count; // number of entries used
|
|
|
|
phys_addr_t next; // pa of next struct instance
|
|
|
|
struct {
|
|
|
|
phys_addr_t base;
|
|
|
|
phys_addr_t size;
|
efi: Replace zero-length array and use struct_size() helper
The current codebase makes use of the zero-length array language
extension to the C90 standard, but the preferred mechanism to declare
variable-length types such as these ones is a flexible array member[1][2],
introduced in C99:
struct foo {
int stuff;
struct boo array[];
};
By making use of the mechanism above, we will get a compiler warning
in case the flexible array does not occur last in the structure, which
will help us prevent some kind of undefined behavior bugs from being
inadvertently introduced[3] to the codebase from now on.
Also, notice that, dynamic memory allocations won't be affected by
this change:
"Flexible array members have incomplete type, and so the sizeof operator
may not be applied. As a quirk of the original implementation of
zero-length arrays, sizeof evaluates to zero."[1]
sizeof(flexible-array-member) triggers a warning because flexible array
members have incomplete type[1]. There are some instances of code in
which the sizeof operator is being incorrectly/erroneously applied to
zero-length arrays and the result is zero. Such instances may be hiding
some bugs. So, this work (flexible-array member conversions) will also
help to get completely rid of those sorts of issues.
Lastly, make use of the sizeof_field() helper instead of an open-coded
version.
This issue was found with the help of Coccinelle and audited _manually_.
[1] https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
[2] https://github.com/KSPP/linux/issues/21
[3] commit 76497732932f ("cxgb3/l2t: Fix undefined behaviour")
Signed-off-by: Gustavo A. R. Silva <gustavoars@kernel.org>
Reviewed-by: Kees Cook <keescook@chromium.org>
Link: https://lore.kernel.org/r/20200527171425.GA4053@embeddedor
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2020-05-28 01:14:25 +08:00
|
|
|
} entry[];
|
2018-09-22 00:32:44 +08:00
|
|
|
};
|
|
|
|
|
2018-11-30 01:12:29 +08:00
|
|
|
#define EFI_MEMRESERVE_COUNT(size) (((size) - sizeof(struct linux_efi_memreserve)) \
|
efi: Replace zero-length array and use struct_size() helper
The current codebase makes use of the zero-length array language
extension to the C90 standard, but the preferred mechanism to declare
variable-length types such as these ones is a flexible array member[1][2],
introduced in C99:
struct foo {
int stuff;
struct boo array[];
};
By making use of the mechanism above, we will get a compiler warning
in case the flexible array does not occur last in the structure, which
will help us prevent some kind of undefined behavior bugs from being
inadvertently introduced[3] to the codebase from now on.
Also, notice that, dynamic memory allocations won't be affected by
this change:
"Flexible array members have incomplete type, and so the sizeof operator
may not be applied. As a quirk of the original implementation of
zero-length arrays, sizeof evaluates to zero."[1]
sizeof(flexible-array-member) triggers a warning because flexible array
members have incomplete type[1]. There are some instances of code in
which the sizeof operator is being incorrectly/erroneously applied to
zero-length arrays and the result is zero. Such instances may be hiding
some bugs. So, this work (flexible-array member conversions) will also
help to get completely rid of those sorts of issues.
Lastly, make use of the sizeof_field() helper instead of an open-coded
version.
This issue was found with the help of Coccinelle and audited _manually_.
[1] https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
[2] https://github.com/KSPP/linux/issues/21
[3] commit 76497732932f ("cxgb3/l2t: Fix undefined behaviour")
Signed-off-by: Gustavo A. R. Silva <gustavoars@kernel.org>
Reviewed-by: Kees Cook <keescook@chromium.org>
Link: https://lore.kernel.org/r/20200527171425.GA4053@embeddedor
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
2020-05-28 01:14:25 +08:00
|
|
|
/ sizeof_field(struct linux_efi_memreserve, entry[0]))
|
2018-11-30 01:12:29 +08:00
|
|
|
|
2020-03-26 21:50:41 +08:00
|
|
|
void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size);
|
|
|
|
|
2020-05-16 21:26:47 +08:00
|
|
|
char *efi_systab_show_arch(char *str);
|
|
|
|
|
2020-09-05 09:31:05 +08:00
|
|
|
/*
|
|
|
|
* The LINUX_EFI_MOK_VARIABLE_TABLE_GUID config table can be provided
|
|
|
|
* to the kernel by an EFI boot loader. The table contains a packed
|
|
|
|
* sequence of these entries, one for each named MOK variable.
|
|
|
|
* The sequence is terminated by an entry with a completely NULL
|
|
|
|
* name and 0 data size.
|
|
|
|
*/
|
|
|
|
struct efi_mokvar_table_entry {
|
|
|
|
char name[256];
|
|
|
|
u64 data_size;
|
|
|
|
u8 data[];
|
|
|
|
} __attribute((packed));
|
|
|
|
|
|
|
|
#ifdef CONFIG_LOAD_UEFI_KEYS
|
|
|
|
extern void __init efi_mokvar_table_init(void);
|
|
|
|
extern struct efi_mokvar_table_entry *efi_mokvar_entry_next(
|
|
|
|
struct efi_mokvar_table_entry **mokvar_entry);
|
|
|
|
extern struct efi_mokvar_table_entry *efi_mokvar_entry_find(const char *name);
|
|
|
|
#else
|
|
|
|
static inline void efi_mokvar_table_init(void) { }
|
|
|
|
static inline struct efi_mokvar_table_entry *efi_mokvar_entry_next(
|
|
|
|
struct efi_mokvar_table_entry **mokvar_entry)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
static inline struct efi_mokvar_table_entry *efi_mokvar_entry_find(
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2021-11-26 08:13:32 +08:00
|
|
|
extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);
|
|
|
|
|
2022-04-13 05:21:24 +08:00
|
|
|
struct linux_efi_coco_secret_area {
|
|
|
|
u64 base_pa;
|
|
|
|
u64 size;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Header of a populated EFI secret area */
|
|
|
|
#define EFI_SECRET_TABLE_HEADER_GUID EFI_GUID(0x1e74f542, 0x71dd, 0x4d66, 0x96, 0x3e, 0xef, 0x42, 0x87, 0xff, 0x17, 0x3b)
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* _LINUX_EFI_H */
|