x86_64: Improvements at compressed kernel stage
PATCH v3 3/24 x86/boot: Set cr0 to known state in trampoline
In reply to Evgeniy BaskovEnsure WP bit to be set to prevent boot code from writing to non-writable memory pages.
--- arch/x86/boot/compressed/head_64.S | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-)
arch/x86/boot/compressed/head_64.S +2 -3
@@ -684,9 +684,8 @@ SYM_CODE_START(trampoline_32bit_src) pushl $__KERNEL_CS pushl %eax - /* Enable paging again. */ - movl %cr0, %eax - btsl $X86_CR0_PG_BIT, %eax + /* Enable paging and set CR0 to known state (this also sets WP flag) */ + movl $CR0_STATE, %eax movl %eax, %cr0 lret
Signature · 1 line
2.37.4
PATCH v3 4/24 x86/boot: Increase boot page table size
In reply to Evgeniy BaskovPrevious upper limit ignored pages implicitly mapped from #PF handler by code accessing ACPI tables (boot/compressed/{acpi.c,efi.c}), so theoretical upper limit is higher than it was set.
Using 4KB pages is desirable for better memory protection granularity. Approximately twice as much memory is required for those.
Increase initial page table size to 64 4KB page tables.
--- arch/x86/include/asm/boot.h | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-)
arch/x86/include/asm/boot.h +14 -12
@@ -41,22 +41,24 @@# define BOOT_STACK_SIZE 0x4000# define BOOT_INIT_PGT_SIZE (6*4096) -# ifdef CONFIG_RANDOMIZE_BASE /* * Assuming all cross the 512GB boundary: * 1 page for level4 -* (2+2)*4 pages for kernel, param, cmd_line, and randomized kernel -* 2 pages for first 2M (video RAM: CONFIG_X86_VERBOSE_BOOTUP). -* Total is 19 pages. +* (3+3)*2 pages for param and cmd_line +* (2+2+S)*2 pages for kernel and randomized kernel, where S is total number +* of sections of kernel. Explanation: 2+2 are upper level page tables. +* We can have only S unaligned parts of section: 1 at the end of the kernel +* and (S-1) at the section borders. The start address of the kernel is +* aligned, so an extra page table. There are at most S=6 sections in +* vmlinux ELF image. +* 3 pages for first 2M (video RAM: CONFIG_X86_VERBOSE_BOOTUP). +* Total is 36 pages. +* +* Some pages are also required for UEFI memory map and +* ACPI table mappings, so we need to add extra space. +* FIXME: Figure out exact amount of pages. */ -# ifdef CONFIG_X86_VERBOSE_BOOTUP -# define BOOT_PGT_SIZE (19*4096) -# else /* !CONFIG_X86_VERBOSE_BOOTUP */ -# define BOOT_PGT_SIZE (17*4096) -# endif -# else /* !CONFIG_RANDOMIZE_BASE */ -# define BOOT_PGT_SIZE BOOT_INIT_PGT_SIZE -# endif +# define BOOT_PGT_SIZE (64*4096)#else /* !CONFIG_X86_64 */ # define BOOT_STACK_SIZE 0x1000
Signature · 1 line
2.37.4
PATCH v3 2/24 x86/build: Remove RWX sections and align on 4KB
In reply to Evgeniy BaskovAvoid creating sections simultaneously writable and readable to prepare for W^X implementation. Align sections on page size (4KB) to allow protecting them in the page tables.
Split init code form ".init" segment into separate R_X ".inittext" segment and make ".init" segment non-executable.
Also add these segments to x86_32 architecture for consistency. Currently paging is disabled in x86_32 in compressed kernel, so protection is not applied anyways, but .init code was incorrectly placed in non-executable ".data" segment. This should not change anything meaningful in memory layout now, but might be required in case memory protection will also be implemented in compressed kernel for x86_32.
--- arch/x86/kernel/vmlinux.lds.S | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-)
arch/x86/kernel/vmlinux.lds.S +8 -7
@@ -102,12 +102,11 @@ jiffies = jiffies_64; PHDRS { text PT_LOAD FLAGS(5); /* R_E */ data PT_LOAD FLAGS(6); /* RW_ */ -#ifdef CONFIG_X86_64 -#ifdef CONFIG_SMP +#if defined(CONFIG_X86_64) && defined(CONFIG_SMP) percpu PT_LOAD FLAGS(6); /* RW_ */ #endif - init PT_LOAD FLAGS(7); /* RWE */ -#endif + inittext PT_LOAD FLAGS(5); /* R_E */ + init PT_LOAD FLAGS(6); /* RW_ */ note PT_NOTE FLAGS(0); /* ___ */ }
@@ -226,9 +225,10 @@ SECTIONS #endif INIT_TEXT_SECTION(PAGE_SIZE) -#ifdef CONFIG_X86_64 - :init -#endif + :inittext + + . = ALIGN(PAGE_SIZE); + /* * Section for code used exclusively before alternatives are run. All
@@ -240,6 +240,7 @@ SECTIONS .altinstr_aux : AT(ADDR(.altinstr_aux) - LOAD_OFFSET) { *(.altinstr_aux) } + :init INIT_DATA_SECTION(16)
Signature · 1 line
2.37.4
PATCH v3 1/24 x86/boot: Align vmlinuz sections on page size
In reply to Evgeniy BaskovTo protect sections on page table level each section needs to be aligned on page size (4KB).
Set sections alignment in linker script.
--- arch/x86/boot/compressed/vmlinux.lds.S | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/boot/compressed/vmlinux.lds.S +6 -0
@@ -27,21 +27,27 @@ SECTIONS HEAD_TEXT _ehead = . ; } + . = ALIGN(PAGE_SIZE); .rodata..compressed : { + _compressed = .; *(.rodata..compressed) + _ecompressed = .; } + . = ALIGN(PAGE_SIZE); .text : { _text = .; /* Text */ *(.text) *(.text.*) _etext = . ; } + . = ALIGN(PAGE_SIZE); .rodata : { _rodata = . ; *(.rodata) /* read-only data */ *(.rodata.*) _erodata = . ; } + . = ALIGN(PAGE_SIZE); .data : { _data = . ; *(.data)
Signature · 1 line
2.37.4
v3 cover x86_64: Improvements at compressed kernel stage
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code for x86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.
Kernel is made to be more compatible with PE image specification [3], allowing it to be successfully loaded by stricter PE loader implementations like the one from [2]. There is at least one known implementation that uses that loader in production [4]. There are also ongoing efforts to upstream these changes.
Also the patchset adds EFI_MEMORY_ATTTRIBUTE_PROTOCOL, included into EFI specification since version 2.10, as a better alternative to using DXE services for memory protection attributes manipulation, since it is defined by the UEFI specification itself and not UEFI PI specification. This protocol is not widely available so the code using DXE services is kept in place as a fallback in case specific implementation does not support the new protocol.
One of EFI implementations that already support EFI_MEMORY_ATTTRIBUTE_PROTOCOL is Microsoft Project Mu [5].
Kernel image generation tool (tools/build.c) is refactored as a part of changes that makes PE image more compatible.
The patchset implements memory protection for compressed kernel code while executing both inside EFI boot services and outside of them. For EFISTUB code path W^X protection policy is maintained throughout the whole execution of compressed kernel. The latter is achieved by extracting the kernel directly from EFI environment and jumping to it's head immediately after exiting EFI boot services. As a side effect of this change one page table rebuild and a copy of the kernel image is removed.
Memory protection inside EFI environment is controlled by the CONFIG_DXE_MEM_ATTRIBUTES option, although with these patches this option also control the use EFI_MEMORY_ATTTRIBUTE_PROTOCOL and memory protection attributes of PE sections and not only DXE services as the name might suggest.
Changes in v2:
* Fix spelling.
* Rebase code to current master.
* Split huge patches into smaller ones.
* Remove unneeded forward declarations.
* Make direct extraction unconditional.
* Also make it work for x86_32.
* Reduce lower limit of KASLR to 64M.
* Make callback interface more logically consistent.
* Actually declare callbacks structure before using it.
* Mention effect on x86_32 in commit message of
"x86/build: Remove RWX sections and align on 4KB".
* Clarify commit message of
"x86/boot: Increase boot page table size".
* Remove "startup32_" prefix on startup32_enable_nx_if_supported.
* Move linker generated sections outside of function scope.
* Drop some unintended changes.
* Drop generating 2 reloc entries.
(as I've misread the documentation and there's no need for this change.)
* Set has_nx from enable_nx_if_supported correctly.
* Move ELF header check to build time.
* Set WP at the same time as PG in trampoline code,
as it is more logically consistent.
* Put x86-specific EFISTUB definitions in x86-stub.h header.
* Catch presence of ELF segments violating W^X during build.
* Move PE definitions from build.c to a new header file.
* Fix generation of PE '.compat' section.
I decided to keep protection of compressed kernel blob and '.rodata' separate from '.text' for now, since it does not really have a lot of overhead.
Otherwise, all comments on v1 seems to be addressed.
Changes in v3:
* Setup IDT before issuing cpuid so that AMD SEV #VC handler is set.
* Replace memcpy with strncpy to prevent out-of-bounds reads in tools/build.c.
* Zero BSS before entering efi_main(), since it can contain garbage when booting via EFI handover protocol.
* When booting via EFI don't require init_size of RAM, since in-place unpacking is not used anyway with that interface. This saves ~40M of memory for debian .config.
* Setup sections memory protection in efi_main() to cover EFI handover protocol, where EFI sections are likely not properly protected.
Patch "x86/boot: Support 4KB pages for identity mapping" needs review from x86/mm team.
I have also included Peter's patch [6] into the series for simplicity.
Many thanks to Ard Biesheuvel <[email protected]> and
Andrew Cooper <[email protected]> for reviewing the patches, and to Peter Jones <[email protected]>, Mario Limonciello <[email protected]> and Joey Lee <[email protected]> for additional testing!
[1] https://lkml.org/lkml/2022/8/1/1314
[2] https://github.com/acidanthera/audk/tree/secure_pe
[3] https://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v83.docx
[4] https://www.ispras.ru/en/technologies/asperitas/
[5] https://github.com/microsoft/mu_tiano_platforms
[6] https://lkml.org/lkml/2022/10/18/1178
Evgeniy Baskov (23):
x86/boot: Align vmlinuz sections on page size x86/build: Remove RWX sections and align on 4KB x86/boot: Set cr0 to known state in trampoline x86/boot: Increase boot page table size x86/boot: Support 4KB pages for identity mapping x86/boot: Setup memory protection for bzImage code x86/build: Check W^X of vmlinux during build x86/boot: Map memory explicitly
x86/boot: Remove mapping from page fault handler efi/libstub: Move helper function to related file x86/boot: Make console interface more abstract x86/boot: Make kernel_add_identity_map() a pointer x86/boot: Split trampoline and pt init code x86/boot: Add EFI kernel extraction interface efi/x86: Support extracting kernel from libstub x86/boot: Reduce lower limit of physical KASLR x86/boot: Reduce size of the DOS stub tools/include: Add simplified version of pe.h x86/build: Cleanup tools/build.c
x86/build: Make generated PE more spec compliant efi/x86: Explicitly set sections memory attributes efi/libstub: Add memory attribute protocol definitions efi/libstub: Use memory attribute protocol
Peter Jones (1):
efi/libstub: Make memory protection warnings include newlines
arch/x86/boot/Makefile | 2 +- arch/x86/boot/compressed/Makefile | 8 +- arch/x86/boot/compressed/acpi.c | 21 +- arch/x86/boot/compressed/efi.c | 19 +- arch/x86/boot/compressed/head_32.S | 53 +- arch/x86/boot/compressed/head_64.S | 89 ++- arch/x86/boot/compressed/ident_map_64.c | 122 ++-- arch/x86/boot/compressed/kaslr.c | 8 +- arch/x86/boot/compressed/misc.c | 278 ++++----- arch/x86/boot/compressed/misc.h | 23 +- arch/x86/boot/compressed/pgtable.h | 20 - arch/x86/boot/compressed/pgtable_64.c | 75 ++- arch/x86/boot/compressed/putstr.c | 130 ++++ arch/x86/boot/compressed/sev.c | 6 +- arch/x86/boot/compressed/vmlinux.lds.S | 6 + arch/x86/boot/header.S | 110 +--- arch/x86/boot/tools/build.c | 569 +++++++++++------- arch/x86/include/asm/boot.h | 26 +- arch/x86/include/asm/efi.h | 7 + arch/x86/include/asm/init.h | 1 + arch/x86/include/asm/shared/extract.h | 26 + arch/x86/include/asm/shared/pgtable.h | 29 + arch/x86/kernel/vmlinux.lds.S | 15 +- arch/x86/mm/ident_map.c | 185 +++++- drivers/firmware/efi/Kconfig | 2 + drivers/firmware/efi/libstub/Makefile | 2 +- drivers/firmware/efi/libstub/efistub.h | 26 + drivers/firmware/efi/libstub/mem.c | 190 ++++++ .../firmware/efi/libstub/x86-extract-direct.c | 208 +++++++ drivers/firmware/efi/libstub/x86-stub.c | 231 ++----- drivers/firmware/efi/libstub/x86-stub.h | 14 + include/linux/efi.h | 1 + tools/include/linux/pe.h | 150 +++++ 33 files changed, 1852 insertions(+), 800 deletions(-) delete mode 100644 arch/x86/boot/compressed/pgtable.h create mode 100644 arch/x86/boot/compressed/putstr.c create mode 100644 arch/x86/include/asm/shared/extract.h create mode 100644 arch/x86/include/asm/shared/pgtable.h create mode 100644 drivers/firmware/efi/libstub/x86-extract-direct.c create mode 100644 drivers/firmware/efi/libstub/x86-stub.h create mode 100644 tools/include/linux/pe.h
Signature · 1 line
2.37.4
PATCH v3 7/24 x86/build: Check W^X of vmlinux during build
Check if there are simultaneously writable and executable program segments in vmlinux ELF image and fail build if there are any.
This would prevent accidental introduction of RWX segments.
--- arch/x86/boot/compressed/Makefile | 6 ++++++ 1 file changed, 6 insertions(+)
arch/x86/boot/compressed/Makefile +6 -0
@@ -112,11 +112,17 @@ vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_thunk_$(BITS).o vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o efi-obj-$(CONFIG_EFI_STUB) = $(objtree)/drivers/firmware/efi/libstub/lib.a +quiet_cmd_wx_check = WXCHK $< +cmd_wx_check = if $(OBJDUMP) -p $< | grep "flags .wx" > /dev/null; \ + then (echo >&2 "$<: Simultaneously writable and executable sections are prohibited"; \ + /bin/false); fi + $(obj)/vmlinux: $(vmlinux-objs-y) $(efi-obj-y) FORCE $(call if_changed,ld) OBJCOPYFLAGS_vmlinux.bin := -R .comment -S $(obj)/vmlinux.bin: vmlinux FORCE + $(call cmd,wx_check) $(call if_changed,objcopy) targets += $(patsubst $(obj)/%,%,$(vmlinux-objs-y)) vmlinux.bin.all vmlinux.relocs
Signature · 1 line
2.37.4
PATCH v3 8/24 x86/boot: Map memory explicitly
In reply to Evgeniy BaskovImplicit mappings hide possible memory errors, e.g. allocations for ACPI tables were not included in boot page table size.
Replace all implicit mappings from page fault handler with explicit mappings.
--- arch/x86/boot/compressed/acpi.c | 21 ++++++++++++++++++++- arch/x86/boot/compressed/efi.c | 19 ++++++++++++++++++- arch/x86/boot/compressed/kaslr.c | 4 ++++ 3 files changed, 42 insertions(+), 2 deletions(-)
arch/x86/boot/compressed/acpi.c +20 -1
@@ -93,6 +93,8 @@ static u8 *scan_mem_for_rsdp(u8 *start, u32 length) end = start + length; +kernel_add_identity_map ((unsigned long )start, (unsigned long )end,0 ); +/* Search from given start address for the requested length */ for (address = start; address < end; address +=ACPI_RSDP_SCAN_STEP ) {/*
@@ -128,6 +130,9 @@ static acpi_physical_address bios_get_rsdp_addr(void)unsigned long address;u8 *rsdp; +kernel_add_identity_map ((unsigned long )ACPI_EBDA_PTR_LOCATION , + (unsigned long )ACPI_EBDA_PTR_LOCATION +2 ,0 ); +/* Get the location of the Extended BIOS Data Area (EBDA) */ address = *(u16 *)ACPI_EBDA_PTR_LOCATION ; address <<=4 ;
@@ -215,6 +220,9 @@ static unsigned long get_acpi_srat_table(void)if (!rsdp)return 0 ; +kernel_add_identity_map ((unsigned long )rsdp, + (unsigned long )(rsdp +1 ),0 ); +/* Get ACPI root table from RSDP.*/ if (!(cmdline_find_option("acpi", arg, sizeof(arg)) == 4 && !strncmp(arg, "rsdt", 4)) &&
@@ -235,6 +243,9 @@ static unsigned long get_acpi_srat_table(void)if (len <sizeof (struct acpi_table_header ) + size)return 0 ; +kernel_add_identity_map ((unsigned long )header, + (unsigned long )header + len,0 ); + num_entries = (len -sizeof (struct acpi_table_header )) / size; entry = (u8 *)(root_table +sizeof (struct acpi_table_header ));
@@ -247,8 +258,16 @@ static unsigned long get_acpi_srat_table(void)if (acpi_table) { header = (struct acpi_table_header *)acpi_table; -if (ACPI_COMPARE_NAMESEG (header->signature,ACPI_SIG_SRAT )) +kernel_add_identity_map (acpi_table, + acpi_table +sizeof (*header), +0 ); + +if (ACPI_COMPARE_NAMESEG (header->signature,ACPI_SIG_SRAT )) { +kernel_add_identity_map (acpi_table, + acpi_table + header->length, +0 );return acpi_table; + } } entry += size; }
arch/x86/boot/compressed/efi.c +18 -1
@@ -57,10 +57,14 @@ enum efi_type efi_get_type(struct boot_params *bp)*/ unsigned long efi_get_system_table (struct boot_params *bp) { -unsigned long sys_tbl_pa; + static unsigned long sys_tbl_pa __section(".data");struct efi_info *ei; +unsigned long sys_tbl_size;enum efi_type et; +if (sys_tbl_pa) +return sys_tbl_pa; +/* Get systab from boot params. */ ei = &bp->efi_info;#ifdef CONFIG_X86_64
@@ -73,6 +77,13 @@ unsigned long efi_get_system_table(struct boot_params *bp)return 0 ; } +if (efi_get_type (bp) ==EFI_TYPE_64 ) + sys_tbl_size =sizeof (efi_system_table_64_t); +else + sys_tbl_size =sizeof (efi_system_table_32_t); + +kernel_add_identity_map (sys_tbl_pa, sys_tbl_pa + sys_tbl_size,0 ); +return sys_tbl_pa; }
@@ -92,6 +103,10 @@ static struct efi_setup_data *get_kexec_setup_data(struct boot_params *bp, pa_data = bp->hdr.setup_data;while (pa_data) { +unsigned long pa_data_end = pa_data +sizeof (struct setup_data ) + +sizeof (struct efi_setup_data ); +kernel_add_identity_map (pa_data, pa_data_end,0 ); + data = (struct setup_data *)pa_data;if (data->type ==SETUP_EFI ) { esd = (struct efi_setup_data *)(pa_data +sizeof (struct setup_data ));
@@ -160,6 +175,8 @@ int efi_get_conf_table(struct boot_params *bp, unsigned long *cfg_tbl_pa,return -EINVAL ; } +kernel_add_identity_map (*cfg_tbl_pa, *cfg_tbl_pa + *cfg_tbl_len,0 ); +return 0 ; }
arch/x86/boot/compressed/kaslr.c +4 -0
@@ -688,6 +688,8 @@ process_efi_entries(unsigned long minimum, unsigned long image_size)u32 nr_desc;int i; +kernel_add_identity_map ((unsigned long )e, (unsigned long )(e +1 ),0 ); + signature = (char *)&e->efi_loader_signature;if (strncmp (signature,EFI32_LOADER_SIGNATURE ,4 ) &&strncmp (signature,EFI64_LOADER_SIGNATURE ,4 ))
@@ -704,6 +706,8 @@ process_efi_entries(unsigned long minimum, unsigned long image_size) pmap = (e->efi_memmap | ((__u64 )e->efi_memmap_hi <<32 ));#endif +kernel_add_identity_map (pmap, pmap + e->efi_memmap_size,0 ); + nr_desc = e->efi_memmap_size / e->efi_memdesc_size;for (i =0 ; i < nr_desc; i++) { md =efi_early_memdesc_ptr (pmap, e->efi_memdesc_size, i);
Signature · 1 line
2.37.4
PATCH v3 12/24 x86/boot: Make kernel_add_identity_map() a pointer
In reply to Evgeniy BaskovConvert kernel_add_identity_map() into a function pointer to be able to provide alternative implementations of this function. Required to enable calling the code using this function from EFI environment.
--- arch/x86/boot/compressed/ident_map_64.c | 7 ++++--- arch/x86/boot/compressed/misc.c | 24 ++++++++++++++++++++++++ arch/x86/boot/compressed/misc.h | 15 +++------------ 3 files changed, 31 insertions(+), 15 deletions(-)
arch/x86/boot/compressed/ident_map_64.c +4 -3
@@ -92,9 +92,9 @@ bool has_nx; /* set in head_64.S *//* * Adds the specified range to the identity mappings. */ -unsigned long kernel_add_identity_map (unsigned long start, -unsigned long end, -unsigned int flags) +unsigned long kernel_add_identity_map_ (unsigned long start, +unsigned long end, +unsigned int flags) {int ret;
@@ -142,6 +142,7 @@ void initialize_identity_maps(void *rmode)struct setup_data *sd; boot_params = rmode; + kernel_add_identity_map = kernel_add_identity_map_;/* Exclude the encryption mask from __PHYSICAL_MASK */ physical_mask &= ~sme_me_mask;
arch/x86/boot/compressed/misc.c +24 -0
@@ -275,6 +275,22 @@ static void parse_elf(void *output, unsigned long output_len,free (phdrs); } +/* +* This points to actual implementation of mapping function +* for current environment: either EFI API wrapper, +* own implementation or dummy implementation below. +*/ +unsigned long (*kernel_add_identity_map)(unsigned long start, +unsigned long end, +unsigned int flags); + +static inline unsigned long kernel_add_identity_map_dummy (unsigned long start, +unsigned long end, +unsigned int flags) +{ +return start; +} +/* * The compressed kernel image (ZO), has been moved so that its position * is against the end of the buffer used to hold the uncompressed kernel
@@ -312,6 +328,14 @@ asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,init_default_io_ops (); +/* +* On 64-bit this pointer is set during page table uninitialization, +* but on 32-bit it remains uninitialized, since paging is disabled. +*/ +if (IS_ENABLED (CONFIG_X86_32 )) + kernel_add_identity_map = kernel_add_identity_map_dummy; + +/* * Detect TDX guest environment. *
arch/x86/boot/compressed/misc.h +3 -12
@@ -180,18 +180,9 @@ static inline int count_immovable_mem_regions(void) { return 0; }#ifdef CONFIG_X86_5LEVEL extern unsigned int __pgtable_l5_enabled, pgdir_shift, ptrs_per_p4d;#endif -#ifdef CONFIG_X86_64 -extern unsigned long kernel_add_identity_map (unsigned long start, -unsigned long end, -unsigned int flags); -#else -static inline unsigned long kernel_add_identity_map (unsigned long start, -unsigned long end, -unsigned int flags) -{ -return start; -} -#endif +extern unsigned long (*kernel_add_identity_map)(unsigned long start, +unsigned long end, +unsigned int flags);/* Used by PAGE_KERN* macros: */ extern pteval_t __default_kernel_pte_mask;
Signature · 1 line
2.37.4
PATCH v3 11/24 x86/boot: Make console interface more abstract
In reply to Evgeniy BaskovTo be able to extract kernel from EFI, console output functions need to be replaceable by alternative implementations.
Make all of those functions pointers.
Move serial console code to separate file.
--- arch/x86/boot/compressed/Makefile | 2 +- arch/x86/boot/compressed/misc.c | 109 +------------------------ arch/x86/boot/compressed/misc.h | 9 ++- arch/x86/boot/compressed/putstr.c | 130 ++++++++++++++++++++++++++++++ 4 files changed, 139 insertions(+), 111 deletions(-) create mode 100644 arch/x86/boot/compressed/putstr.c
arch/x86/boot/compressed/Makefile +1 -1
@@ -93,7 +93,7 @@ $(obj)/misc.o: $(obj)/../voffset.h vmlinux-objs-y := $(obj)/vmlinux.lds $(obj)/kernel_info.o $(obj)/head_$(BITS).o \ $(obj)/misc.o $(obj)/string.o $(obj)/cmdline.o $(obj)/error.o \ - $(obj)/piggy.o $(obj)/cpuflags.o + $(obj)/piggy.o $(obj)/cpuflags.o $(obj)/putstr.o vmlinux-objs-$(CONFIG_EARLY_PRINTK) += $(obj)/early_serial_console.o vmlinux-objs-$(CONFIG_RANDOMIZE_BASE) += $(obj)/kaslr.o
arch/x86/boot/compressed/misc.c +1 -108
133 lines not on this page · raw message
arch/x86/boot/compressed/misc.h +7 -2
@@ -57,8 +57,8 @@ extern memptr free_mem_end_ptr;void *malloc (int size);void free (void *where);extern struct boot_params *boot_params; -void __putstr (const char *s); -void __puthex (unsigned long value); +extern void (*__putstr)(const char *s); +extern void (*__puthex)(unsigned long value);#define error_putstr (__x) __putstr(__x)#define error_puthex (__x) __puthex(__x)
@@ -128,6 +128,11 @@ static inline void console_init(void) { }#endif +/* putstr.c */ +void init_bare_console (void ); +void init_console_func (void (*putstr_)(const char *), +void (*puthex_)(unsigned long )); +#ifdef CONFIG_AMD_MEM_ENCRYPT void sev_enable (struct boot_params *bp);void sev_es_shutdown_ghcb (void );
arch/x86/boot/compressed/putstr.c new file +130 -0
130 lines not on this page · raw message
Signature · 1 line
2.37.4
PATCH v3 5/24 x86/boot: Support 4KB pages for identity mapping
In reply to Evgeniy BaskovCurrent identity mapping code only supports 2M and 1G pages. 4KB pages are desirable for better memory protection granularity in compressed kernel code.
Change identity mapping code to support 4KB pages and memory remapping with different attributes.
--- arch/x86/include/asm/init.h | 1 + arch/x86/mm/ident_map.c | 185 +++++++++++++++++++++++++++++------- 2 files changed, 154 insertions(+), 32 deletions(-)
arch/x86/include/asm/init.h +1 -0
@@ -8,6 +8,7 @@ struct x86_mapping_info {unsigned long page_flag;/* page flag for PMD or PUD entry */ unsigned long offset;/* ident mapping offset */ bool direct_gbpages;/* PUD level 1GB page support */ +bool allow_4kpages;/* Allow more granular mappings with 4K pages */ unsigned long kernpg_flag;/* kernel pagetable flag override */ };
arch/x86/mm/ident_map.c +153 -32
265 lines not on this page · raw message
Signature · 1 line
2.37.4
PATCH v3 6/24 x86/boot: Setup memory protection for bzImage code
In reply to Evgeniy BaskovUse previously added code to use 4KB pages for mapping. Map compressed and uncompressed kernel with appropriate memory protection attributes. For compressed kernel set them up manually. For uncompressed kernel used flags specified in ELF header.
delete mode 100644 arch/x86/boot/compressed/pgtable.h create mode 100644 arch/x86/include/asm/shared/pgtable.h --- arch/x86/boot/compressed/head_64.S | 24 +++++- arch/x86/boot/compressed/ident_map_64.c | 97 ++++++++++++++++--------- arch/x86/boot/compressed/misc.c | 63 ++++++++++++++-- arch/x86/boot/compressed/misc.h | 22 +++++- arch/x86/boot/compressed/pgtable.h | 20 ----- arch/x86/boot/compressed/pgtable_64.c | 2 +- arch/x86/boot/compressed/sev.c | 6 +- arch/x86/include/asm/shared/pgtable.h | 29 ++++++++ 8 files changed, 197 insertions(+), 66 deletions(-) delete mode 100644 arch/x86/boot/compressed/pgtable.h create mode 100644 arch/x86/include/asm/shared/pgtable.h
arch/x86/boot/compressed/head_64.S +23 -1
@@ -29,13 +29,14 @@ #include <linux/linkage.h> #include <asm/segment.h> #include <asm/boot.h> +#include <asm/cpufeatures.h> #include <asm/msr.h> #include <asm/processor-flags.h> #include <asm/asm-offsets.h> #include <asm/bootparam.h> #include <asm/desc_defs.h> #include <asm/trapnr.h> -#include "pgtable.h" +#include <asm/shared/pgtable.h> /* * Locally defined symbols should be marked hidden:
@@ -578,6 +579,7 @@ SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated) pushq %rsi call load_stage2_idt + call enable_nx_if_supported /* Pass boot_params to initialize_identity_maps() */ movq (%rsp), %rdi call initialize_identity_maps
@@ -602,6 +604,26 @@ SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated) jmp *%rax SYM_FUNC_END(.Lrelocated) +SYM_FUNC_START_LOCAL_NOALIGN(enable_nx_if_supported) + pushq %rbx + + mov $0x80000001, %eax + cpuid + btl $(X86_FEATURE_NX & 31), %edx + jnc .Lnonx + + movl $MSR_EFER, %ecx + rdmsr + btsl $_EFER_NX, %eax + wrmsr + + movb $1, has_nx(%rip) + +.Lnonx: + popq %rbx + RET +SYM_FUNC_END(enable_nx_if_supported) + .code32 /* * This is the 32-bit trampoline that will be copied over to low memory.
arch/x86/boot/compressed/ident_map_64.c +64 -33
168 lines not on this page · raw message
arch/x86/boot/compressed/misc.c +58 -5
105 lines not on this page · raw message
arch/x86/boot/compressed/misc.h +18 -4
@@ -44,8 +44,12 @@#define memptr unsigned#endif -/* boot/compressed/vmlinux start and end markers */ -extern char _head[], _end[]; +/* Compressed kernel section start/end markers. */ +extern char _head[], _ehead[]; +extern char _compressed[], _ecompressed[]; +extern char _text[], _etext[]; +extern char _rodata[], _erodata[]; +extern char _data[], _end[];/* misc.c */ extern memptr free_mem_ptr;
@@ -171,8 +175,18 @@ static inline int count_immovable_mem_regions(void) { return 0; }#ifdef CONFIG_X86_5LEVEL extern unsigned int __pgtable_l5_enabled, pgdir_shift, ptrs_per_p4d;#endif -extern void kernel_add_identity_map (unsigned long start,unsigned long end); - +#ifdef CONFIG_X86_64 +extern unsigned long kernel_add_identity_map (unsigned long start, +unsigned long end, +unsigned int flags); +#else +static inline unsigned long kernel_add_identity_map (unsigned long start, +unsigned long end, +unsigned int flags) +{ +return start; +} +#endif /* Used by PAGE_KERN* macros: */ extern pteval_t __default_kernel_pte_mask;
arch/x86/boot/compressed/pgtable.h deleted +0 -20
@@ -1,20 +0,0 @@ -#ifndef BOOT_COMPRESSED_PAGETABLE_H -#define BOOT_COMPRESSED_PAGETABLE_H - -#define TRAMPOLINE_32BIT_SIZE (2 * PAGE_SIZE) - -#define TRAMPOLINE_32BIT_PGTABLE_OFFSET 0 - -#define TRAMPOLINE_32BIT_CODE_OFFSET PAGE_SIZE -#define TRAMPOLINE_32BIT_CODE_SIZE 0x80 - -#define TRAMPOLINE_32BIT_STACK_END TRAMPOLINE_32BIT_SIZE - -#ifndef __ASSEMBLER__ - -extern unsigned long *trampoline_32bit; - -extern void trampoline_32bit_src (void *return_ptr); - -#endif /* __ASSEMBLER__ */ -#endif /* BOOT_COMPRESSED_PAGETABLE_H */
arch/x86/boot/compressed/pgtable_64.c +1 -1
@@ -2,7 +2,7 @@#include "misc.h" #include <asm/e820/types.h> #include <asm/processor.h> -#include "pgtable.h" +#include <asm/shared/pgtable.h> #include "../string.h" #include "efi.h"
arch/x86/boot/compressed/sev.c +4 -2
@@ -13,6 +13,7 @@#include "misc.h" #include <asm/pgtable_types.h> +#include <asm/shared/pgtable.h> #include <asm/sev.h> #include <asm/trapnr.h> #include <asm/trap_pf.h>
@@ -435,10 +436,11 @@ void sev_prep_identity_maps(unsigned long top_level_pgt)unsigned long cc_info_pa = boot_params->cc_blob_address;struct cc_blob_sev_info *cc_info; -kernel_add_identity_map (cc_info_pa, cc_info_pa +sizeof (*cc_info)); +kernel_add_identity_map (cc_info_pa, cc_info_pa +sizeof (*cc_info),MAP_NOFLUSH ); cc_info = (struct cc_blob_sev_info *)cc_info_pa; -kernel_add_identity_map (cc_info->cpuid_phys, cc_info->cpuid_phys + cc_info->cpuid_len); +kernel_add_identity_map (cc_info->cpuid_phys, + cc_info->cpuid_phys + cc_info->cpuid_len,MAP_NOFLUSH ); }sev_verify_cbit (top_level_pgt);
arch/x86/include/asm/shared/pgtable.h new file +29 -0
@@ -0,0 +1,29 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef ASM_SHARED_PAGETABLE_H +#define ASM_SHARED_PAGETABLE_H + +#define MAP_WRITE 0x02/* Writable memory */ +#define MAP_EXEC 0x04/* Executable memory */ +#define MAP_ALLOC 0x10/* Range needs to be allocated */ +#define MAP_PROTECT 0x20/* Set exact memory attributes for memory range */ +#define MAP_NOFLUSH 0x40/* Avoid flushing TLB */ + +#define TRAMPOLINE_32BIT_SIZE (3 * PAGE_SIZE) + +#define TRAMPOLINE_32BIT_PLACEMENT_MAX (0xA0000) + +#define TRAMPOLINE_32BIT_PGTABLE_OFFSET 0 + +#define TRAMPOLINE_32BIT_CODE_OFFSET PAGE_SIZE +#define TRAMPOLINE_32BIT_CODE_SIZE 0x80 + +#define TRAMPOLINE_32BIT_STACK_END TRAMPOLINE_32BIT_SIZE + +#ifndef __ASSEMBLER__ + +extern unsigned long *trampoline_32bit; + +extern void trampoline_32bit_src (void *return_ptr); + +#endif /* __ASSEMBLER__ */ +#endif /* ASM_SHARED_PAGETABLE_H */
Signature · 1 line
2.37.4
PATCH v3 13/24 x86/boot: Split trampoline and pt init code
In reply to Evgeniy BaskovWhen allocating trampoline from libstub trampoline allocation is performed separately, so it needs to be skipped.
Split trampoline initialization and allocation code into two functions to make them invokable separately.
--- arch/x86/boot/compressed/pgtable_64.c | 73 +++++++++++++++++---------- 1 file changed, 46 insertions(+), 27 deletions(-)
arch/x86/boot/compressed/pgtable_64.c +46 -27
@@ -106,12 +106,8 @@ static unsigned long find_trampoline_placement(void)return bios_start -TRAMPOLINE_32BIT_SIZE ; } -struct paging_config paging_prepare (void *rmode) +bool trampoline_pgtable_init (struct boot_params *boot_params) { -struct paging_config paging_config = {}; - -/* Initialize boot_params. Required for cmdline_find_option_bool(). */ - boot_params = rmode;/* * Check if LA57 is desired and supported.
@@ -125,26 +121,10 @@ struct paging_config paging_prepare(void *rmode)* * That's substitute for boot_cpu_has() in early boot code. */ -if (IS_ENABLED (CONFIG_X86_5LEVEL ) && - !cmdline_find_option_bool ("no5lvl" ) && -native_cpuid_eax (0 ) >=7 && - (native_cpuid_ecx (7 ) & (1 << (X86_FEATURE_LA57 &31 )))) { - paging_config.l5_required =1 ; - } - - paging_config.trampoline_start =find_trampoline_placement (); - - trampoline_32bit = (unsigned long *)paging_config.trampoline_start; - -/* Preserve trampoline memory */ -memcpy (trampoline_save, trampoline_32bit,TRAMPOLINE_32BIT_SIZE ); - -/* Clear trampoline memory first */ -memset (trampoline_32bit,0 ,TRAMPOLINE_32BIT_SIZE ); - -/* Copy trampoline code in place */ -memcpy (trampoline_32bit +TRAMPOLINE_32BIT_CODE_OFFSET /sizeof (unsigned long ), - &trampoline_32bit_src,TRAMPOLINE_32BIT_CODE_SIZE ); +bool l5_required =IS_ENABLED (CONFIG_X86_5LEVEL ) && + !cmdline_find_option_bool ("no5lvl" ) && +native_cpuid_eax (0 ) >=7 && + (native_cpuid_ecx (7 ) & (1 << (X86_FEATURE_LA57 &31 )));/* * The code below prepares page table in trampoline memory.
@@ -160,10 +140,10 @@ struct paging_config paging_prepare(void *rmode)* We are not going to use the page table in trampoline memory if we * are already in the desired paging mode. */ -if (paging_config.l5_required == !!(native_read_cr4 () &X86_CR4_LA57 )) +if (l5_required == !!(native_read_cr4 () &X86_CR4_LA57 )) goto out; -if (paging_config.l5_required) { +if (l5_required) {/* * For 4- to 5-level paging transition, set up current CR3 as * the first and the only entry in a new top-level page table.
@@ -185,6 +165,45 @@ struct paging_config paging_prepare(void *rmode) (void *)src, PAGE_SIZE); } +out: +return l5_required; +} + +struct paging_config paging_prepare (void *rmode) +{ +struct paging_config paging_config = {}; +bool early_trampoline_alloc =0 ; + +/* Initialize boot_params. Required for cmdline_find_option_bool(). */ + boot_params = rmode; + +/* +* We only need to find trampoline placement, if we have +* not already done it from libstub. +*/ + + paging_config.trampoline_start =find_trampoline_placement (); + trampoline_32bit = (unsigned long *)paging_config.trampoline_start; + early_trampoline_alloc =0 ; + +/* +* Preserve trampoline memory. +* When trampoline is located in memory +* owned by us, i.e. allocated in EFISTUB, +* we don't care about previous contents +* of this memory so copying can also be skipped. +*/ +memcpy (trampoline_save, trampoline_32bit,TRAMPOLINE_32BIT_SIZE ); + +/* Clear trampoline memory first */ +memset (trampoline_32bit,0 ,TRAMPOLINE_32BIT_SIZE ); + +/* Copy trampoline code in place */ +memcpy (trampoline_32bit +TRAMPOLINE_32BIT_CODE_OFFSET /sizeof (unsigned long ), + &trampoline_32bit_src,TRAMPOLINE_32BIT_CODE_SIZE ); + + paging_config.l5_required =trampoline_pgtable_init (boot_params); + out:return paging_config; }
Signature · 1 line
2.37.4
PATCH v3 10/24 efi/libstub: Move helper function to related file
In reply to Evgeniy Baskovefi_adjust_memory_range_protection() can be useful outside x86-stub.c.
Move it to mem.c, where memory related code resides and make it non-static.
Change its behavior to setup exact attributes and disallow making memory regions readable and writable simultaneously for supported configurations.
--- drivers/firmware/efi/libstub/efistub.h | 4 + drivers/firmware/efi/libstub/mem.c | 102 ++++++++++++++++++++++++ drivers/firmware/efi/libstub/x86-stub.c | 66 ++------------- 3 files changed, 112 insertions(+), 60 deletions(-)
drivers/firmware/efi/libstub/efistub.h +4 -0
@@ -917,6 +917,10 @@ efi_status_t efi_relocate_kernel(unsigned long *image_addr,unsigned long alignment, unsigned long min_addr); +efi_status_t efi_adjust_memory_range_protection (unsigned long start, +unsigned long size, +unsigned long attributes); +efi_status_t efi_parse_options (char const *cmdline);void efi_parse_option_graphics (char *option);
drivers/firmware/efi/libstub/mem.c +102 -0
105 lines not on this page · raw message
drivers/firmware/efi/libstub/x86-stub.c +6 -60
87 lines not on this page · raw message
Signature · 1 line
2.37.4
PATCH v3 9/24 x86/boot: Remove mapping from page fault handler
In reply to Evgeniy BaskovAfter every implicit mapping is removed, this code is no longer needed.
Remove memory mapping from page fault handler to ensure that there are no hidden invalid memory accesses.
--- arch/x86/boot/compressed/ident_map_64.c | 26 ++++++++++--------------- 1 file changed, 10 insertions(+), 16 deletions(-)
arch/x86/boot/compressed/ident_map_64.c +10 -16
@@ -386,27 +386,21 @@ void do_boot_page_fault(struct pt_regs *regs, unsigned long error_code) {unsigned long address =native_read_cr2 ();unsigned long end; -bool ghcb_fault; +char *msg; - ghcb_fault =sev_es_check_ghcb_fault (address); +if (sev_es_check_ghcb_fault (address)) + msg ="Page-fault on GHCB page:" ; +else + msg ="Unexpected page-fault:" ; address &=PMD_MASK ; end = address +PMD_SIZE ;/* -* Check for unexpected error codes. Unexpected are: -* - Faults on present pages -* - User faults -* - Reserved bits set -*/ -if (error_code & (X86_PF_PROT |X86_PF_USER |X86_PF_RSVD )) -do_pf_error ("Unexpected page-fault:" , error_code, address, regs->ip); -else if (ghcb_fault) -do_pf_error ("Page-fault on GHCB page:" , error_code, address, regs->ip); - -/* -* Error code is sane - now identity map the 2M region around -* the faulting address. +* Since all memory allocations are made explicit +* now, every page fault at this stage is an +* error and the error handler is there only +* for debug purposes. */ -kernel_add_identity_map (address, end,MAP_WRITE ); +do_pf_error (msg, error_code, address, regs->ip); }
Signature · 1 line
2.37.4
PATCH v3 14/24 x86/boot: Add EFI kernel extraction interface
In reply to Evgeniy BaskovTo enable extraction of kernel image from EFI stub code directly extraction code needs to have separate interface that avoid part of low level initialization logic, i.e. serial port setup.
Add kernel extraction function callable from libstub as a part of preparation for extracting the kernel directly from EFI environment.
--- arch/x86/boot/compressed/head_32.S | 3 +- arch/x86/boot/compressed/head_64.S | 2 +- arch/x86/boot/compressed/misc.c | 100 +++++++++++++++++--------- arch/x86/boot/compressed/misc.h | 1 + arch/x86/include/asm/shared/extract.h | 26 +++++++ 5 files changed, 96 insertions(+), 36 deletions(-) create mode 100644 arch/x86/include/asm/shared/extract.h
arch/x86/boot/compressed/head_32.S +1 -2
@@ -217,8 +217,7 @@ SYM_DATA(image_offset, .long 0) */ .bss .balign 4 -boot_heap: - .fill BOOT_HEAP_SIZE, 1, 0 +SYM_DATA(boot_heap, .fill BOOT_HEAP_SIZE, 1, 0) boot_stack: .fill BOOT_STACK_SIZE, 1, 0 boot_stack_end:
arch/x86/boot/compressed/head_64.S +1 -1
@@ -1006,7 +1006,7 @@ SYM_FUNC_END(startup32_check_sev_cbit) */ .bss .balign 4 -SYM_DATA_LOCAL(boot_heap, .fill BOOT_HEAP_SIZE, 1, 0) +SYM_DATA(boot_heap, .fill BOOT_HEAP_SIZE, 1, 0) SYM_DATA_START_LOCAL(boot_stack) .fill BOOT_STACK_SIZE, 1, 0
arch/x86/boot/compressed/misc.c +67 -33
139 lines not on this page · raw message
arch/x86/boot/compressed/misc.h +1 -0
@@ -26,6 +26,7 @@#include <asm/boot.h> #include <asm/bootparam.h> #include <asm/desc_defs.h> +#include <asm/shared/extract.h> #include "tdx.h"
arch/x86/include/asm/shared/extract.h new file +26 -0
@@ -0,0 +1,26 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef ASM_SHARED_EXTRACT_H +#define ASM_SHARED_EXTRACT_H + +#include <asm/bootparam.h> + +#define MAP_WRITE 0x02/* Writable memory */ +#define MAP_EXEC 0x04/* Executable memory */ +#define MAP_ALLOC 0x10/* Range needs to be allocated */ +#define MAP_PROTECT 0x20/* Set exact memory attributes for memory range */ + +struct efi_extract_callbacks { +void (*putstr)(const char *msg); +void (*puthex)(unsigned long x); +unsigned long (*map_range)(unsigned long start, +unsigned long end, +unsigned int flags); +}; + +void *efi_extract_kernel (struct boot_params *rmode, +struct efi_extract_callbacks *cb, +unsigned char *input_data, +unsigned long input_len, +unsigned long output_len); + +#endif /* ASM_SHARED_EXTRACT_H */
Signature · 1 line
2.37.4
PATCH v3 16/24 x86/boot: Reduce lower limit of physical KASLR
In reply to Evgeniy BaskovSet lower limit of physical KASLR to 64M.
Previously is was set to 512M when kernel is loaded higher than that. That prevented physical KASLR from being performed on x86_32, where upper limit is also set to 512M. The limit is pretty arbitrary, and the most important is to set it above the ISA hole, i.e. higher than 16M.
It was not that important before, but now kernel is not getting relocated to the lower address when booting via EFI, exposing the KASLR failures.
--- arch/x86/boot/compressed/kaslr.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/boot/compressed/kaslr.c +2 -2
@@ -852,10 +852,10 @@ void choose_random_location(unsigned long input,/* * Low end of the randomization range should be the -* smaller of 512M or the initial kernel image +* smaller of 64M or the initial kernel image * location: */ - min_addr =min (*output,512UL <<20 ); + min_addr =min (*output,64UL <<20 );/* Make sure minimum is aligned. */ min_addr =ALIGN (min_addr,CONFIG_PHYSICAL_ALIGN );
Signature · 1 line
2.37.4
PATCH v3 17/24 x86/boot: Reduce size of the DOS stub
In reply to Evgeniy BaskovThis is required to fit more sections in PE section tables, since its size is restricted by zero page located at specific offset after the PE header.
--- arch/x86/boot/header.S | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-)
arch/x86/boot/header.S +6 -8
@@ -59,17 +59,16 @@ start2: cld movw $bugger_off_msg, %si + movw $bugger_off_msg_size, %cx msg_loop: lodsb - andb %al, %al - jz bs_die movb $0xe, %ah movw $7, %bx int $0x10 - jmp msg_loop + decw %cx + jnz msg_loop -bs_die: # Allow the user to press a key, then reboot xorw %ax, %ax int $0x16
@@ -89,10 +88,9 @@ bs_die: .section ".bsdata", "a" bugger_off_msg: - .ascii "Use a boot loader.\r\n" - .ascii "\n" - .ascii "Remove disk and press any key to reboot...\r\n" - .byte 0 + .ascii "Use a boot loader. " + .ascii "Press a key to reboot" + .set bugger_off_msg_size, . - bugger_off_msg #ifdef CONFIG_EFI_STUB pe_header:
Signature · 1 line
2.37.4
PATCH v3 18/24 tools/include: Add simplified version of pe.h
In reply to Evgeniy BaskovThis is needed to remove magic numbers from x86 bzImage building tool (arch/x86/boot/tools/build.c).
--- tools/include/linux/pe.h | 150 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 tools/include/linux/pe.h
tools/include/linux/pe.h new file +150 -0
@@ -0,0 +1,150 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* +* Simplified version of include/linux/pe.h: +* Copyright 2011 Red Hat, Inc. All rights reserved. +* Author(s): Peter Jones <[email protected]> +*/ +#ifndef __LINUX_PE_H +#define __LINUX_PE_H + +#include <linux/types.h> + +#define IMAGE_FILE_MACHINE_I386 0x014c + +#define IMAGE_SCN_CNT_CODE 0x00000020/* .text */ +#define IMAGE_SCN_CNT_INITIALIZED_DATA 0x00000040/* .data */ +#define IMAGE_SCN_ALIGN_4096BYTES 0x00d00000 +#define IMAGE_SCN_MEM_DISCARDABLE 0x02000000/* scn can be discarded */ +#define IMAGE_SCN_MEM_EXECUTE 0x20000000/* can be executed as code */ +#define IMAGE_SCN_MEM_READ 0x40000000/* readable */ +#define IMAGE_SCN_MEM_WRITE 0x80000000/* writeable */ + +#define MZ_HEADER_PEADDR_OFFSET 0x3c + +struct pe_hdr { +uint32_t magic;/* PE magic */ +uint16_t machine;/* machine type */ +uint16_t sections;/* number of sections */ +uint32_t timestamp;/* time_t */ +uint32_t symbol_table;/* symbol table offset */ +uint32_t symbols;/* number of symbols */ +uint16_t opt_hdr_size;/* size of optional header */ +uint16_t flags;/* flags */ +}; + +/* the fact that pe32 isn't padded where pe32+ is 64-bit means union won't +* work right. vomit. */ +struct pe32_opt_hdr { +/* "standard" header */ +uint16_t magic;/* file type */ +uint8_t ld_major;/* linker major version */ +uint8_t ld_minor;/* linker minor version */ +uint32_t text_size;/* size of text section(s) */ +uint32_t data_size;/* size of data section(s) */ +uint32_t bss_size;/* size of bss section(s) */ +uint32_t entry_point;/* file offset of entry point */ +uint32_t code_base;/* relative code addr in ram */ +uint32_t data_base;/* relative data addr in ram */ +/* "windows" header */ +uint32_t image_base;/* preferred load address */ +uint32_t section_align;/* alignment in bytes */ +uint32_t file_align;/* file alignment in bytes */ +uint16_t os_major;/* major OS version */ +uint16_t os_minor;/* minor OS version */ +uint16_t image_major;/* major image version */ +uint16_t image_minor;/* minor image version */ +uint16_t subsys_major;/* major subsystem version */ +uint16_t subsys_minor;/* minor subsystem version */ +uint32_t win32_version;/* reserved, must be 0 */ +uint32_t image_size;/* image size */ +uint32_t header_size;/* header size rounded up to +file_align */ +uint32_t csum;/* checksum */ +uint16_t subsys;/* subsystem */ +uint16_t dll_flags;/* more flags! */ +uint32_t stack_size_req;/* amt of stack requested */ +uint32_t stack_size;/* amt of stack required */ +uint32_t heap_size_req;/* amt of heap requested */ +uint32_t heap_size;/* amt of heap required */ +uint32_t loader_flags;/* reserved, must be 0 */ +uint32_t data_dirs;/* number of data dir entries */ +}; + +struct pe32plus_opt_hdr { +uint16_t magic;/* file type */ +uint8_t ld_major;/* linker major version */ +uint8_t ld_minor;/* linker minor version */ +uint32_t text_size;/* size of text section(s) */ +uint32_t data_size;/* size of data section(s) */ +uint32_t bss_size;/* size of bss section(s) */ +uint32_t entry_point;/* file offset of entry point */ +uint32_t code_base;/* relative code addr in ram */ +/* "windows" header */ +uint64_t image_base;/* preferred load address */ +uint32_t section_align;/* alignment in bytes */ +uint32_t file_align;/* file alignment in bytes */ +uint16_t os_major;/* major OS version */ +uint16_t os_minor;/* minor OS version */ +uint16_t image_major;/* major image version */ +uint16_t image_minor;/* minor image version */ +uint16_t subsys_major;/* major subsystem version */ +uint16_t subsys_minor;/* minor subsystem version */ +uint32_t win32_version;/* reserved, must be 0 */ +uint32_t image_size;/* image size */ +uint32_t header_size;/* header size rounded up to +file_align */ +uint32_t csum;/* checksum */ +uint16_t subsys;/* subsystem */ +uint16_t dll_flags;/* more flags! */ +uint64_t stack_size_req;/* amt of stack requested */ +uint64_t stack_size;/* amt of stack required */ +uint64_t heap_size_req;/* amt of heap requested */ +uint64_t heap_size;/* amt of heap required */ +uint32_t loader_flags;/* reserved, must be 0 */ +uint32_t data_dirs;/* number of data dir entries */ +}; + +struct data_dirent { +uint32_t virtual_address;/* relative to load address */ +uint32_t size; +}; + +struct data_directory { +struct data_dirent exports;/* .edata */ +struct data_dirent imports;/* .idata */ +struct data_dirent resources;/* .rsrc */ +struct data_dirent exceptions;/* .pdata */ +struct data_dirent certs;/* certs */ +struct data_dirent base_relocations;/* .reloc */ +struct data_dirent debug;/* .debug */ +struct data_dirent arch;/* reservered */ +struct data_dirent global_ptr;/* global pointer reg. Size=0 */ +struct data_dirent tls;/* .tls */ +struct data_dirent load_config;/* load configuration structure */ +struct data_dirent bound_imports;/* no idea */ +struct data_dirent import_addrs;/* import address table */ +struct data_dirent delay_imports;/* delay-load import table */ +struct data_dirent clr_runtime_hdr;/* .cor (object only) */ +struct data_dirent reserved; +}; + +struct section_header { +char name[8 ];/* name or "/12\0" string tbl offset */ +uint32_t virtual_size;/* size of loaded section in ram */ +uint32_t virtual_address;/* relative virtual address */ +uint32_t raw_data_size;/* size of the section */ +uint32_t data_addr;/* file pointer to first page of sec */ +uint32_t relocs;/* file pointer to relocation entries */ +uint32_t line_numbers;/* line numbers! */ +uint16_t num_relocs;/* number of relocations */ +uint16_t num_lin_numbers;/* srsly. */ +uint32_t flags; +}; + +struct coff_reloc { +uint32_t virtual_address; +uint32_t symbol_table_index; +uint16_t data; +}; + +#endif /* __LINUX_PE_H */
Signature · 1 line
2.37.4
PATCH v3 15/24 efi/x86: Support extracting kernel from libstub
In reply to Evgeniy BaskovDoing it that way allows setting up stricter memory attributes, simplifies boot code path and removes potential relocation of kernel image.
Wire up required interfaces and minimally initialize zero page fields needed for it to function correctly.
create mode 100644 arch/x86/include/asm/shared/extract.h create mode 100644 drivers/firmware/efi/libstub/x86-extract-direct.c --- arch/x86/boot/compressed/head_32.S | 50 ++++- arch/x86/boot/compressed/head_64.S | 58 ++++- drivers/firmware/efi/Kconfig | 2 + drivers/firmware/efi/libstub/Makefile | 2 +- .../firmware/efi/libstub/x86-extract-direct.c | 208 ++++++++++++++++++ drivers/firmware/efi/libstub/x86-stub.c | 119 +--------- drivers/firmware/efi/libstub/x86-stub.h | 14 ++ 7 files changed, 338 insertions(+), 115 deletions(-) create mode 100644 drivers/firmware/efi/libstub/x86-extract-direct.c create mode 100644 drivers/firmware/efi/libstub/x86-stub.h
arch/x86/boot/compressed/head_32.S +48 -2
@@ -152,11 +152,57 @@ SYM_FUNC_END(startup_32) #ifdef CONFIG_EFI_STUB SYM_FUNC_START(efi32_stub_entry) +/* + * Calculate the delta between where we were compiled to run + * at and where we were actually loaded at. This can only be done + * with a short local call on x86. Nothing else will tell us what + * address we are running at. The reserved chunk of the real-mode + * data at 0x1e4 (defined as a scratch field) are used as the stack + * for this calculation. Only 4 bytes are needed. + */ + call 1f +1: popl %ebx + addl $_GLOBAL_OFFSET_TABLE_+(.-1b), %ebx + + /* Clear BSS */ + xorl %eax, %eax + leal _bss@GOTOFF(%ebx), %edi + leal _ebss@GOTOFF(%ebx), %ecx + subl %edi, %ecx + shrl $2, %ecx + rep stosl + add $0x4, %esp movl 8(%esp), %esi /* save boot_params pointer */ + movl %edx, %edi /* save GOT address */ call efi_main - /* efi_main returns the possibly relocated address of startup_32 */ - jmp *%eax + movl %eax, %ecx + + /* + * efi_main returns the possibly + * relocated address of extracted kernel entry point. + */ + + cli + + /* Load new GDT */ + leal gdt@GOTOFF(%ebx), %eax + movl %eax, 2(%eax) + lgdt (%eax) + + /* Load segment registers with our descriptors */ + movl $__BOOT_DS, %eax + movl %eax, %ds + movl %eax, %es + movl %eax, %fs + movl %eax, %gs + movl %eax, %ss + + /* Zero EFLAGS */ + pushl $0 + popfl + + jmp *%ecx SYM_FUNC_END(efi32_stub_entry) SYM_FUNC_ALIAS(efi_stub_entry, efi32_stub_entry) #endif
arch/x86/boot/compressed/head_64.S +55 -3
67 lines not on this page · raw message
drivers/firmware/efi/Kconfig +2 -0
@@ -91,6 +91,8 @@ config EFI_DXE_MEM_ATTRIBUTES Use DXE services to check and alter memory protection attributes during boot via EFISTUB to ensure that memory ranges used by the kernel are writable and executable. + This option also enables stricter memory attributes + on compressed kernel PE image. config EFI_PARAMS_FROM_FDT bool
drivers/firmware/efi/libstub/Makefile +1 -1
@@ -83,7 +83,7 @@ lib-$(CONFIG_EFI_GENERIC_STUB) += efi-stub.o string.o intrinsics.o systable.o lib-$(CONFIG_ARM) += arm32-stub.o lib-$(CONFIG_ARM64) += arm64-stub.o smbios.o -lib-$(CONFIG_X86) += x86-stub.o +lib-$(CONFIG_X86) += x86-stub.o x86-extract-direct.o lib-$(CONFIG_RISCV) += riscv-stub.o lib-$(CONFIG_LOONGARCH) += loongarch-stub.o
drivers/firmware/efi/libstub/x86-extract-direct.c new file +208 -0
208 lines not on this page · raw message
drivers/firmware/efi/libstub/x86-stub.c +10 -109
169 lines not on this page · raw message
drivers/firmware/efi/libstub/x86-stub.h new file +14 -0
@@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#ifndef _DRIVERS_FIRMWARE_EFI_X86STUB_H +#define _DRIVERS_FIRMWARE_EFI_X86STUB_H + +#include <linux/efi.h> + +#include <asm/bootparam.h> + +void __noreturn efi_exit (efi_handle_t handle,efi_status_t status); +unsigned long extract_kernel_direct (efi_handle_t handle,struct boot_params *boot_params); +void startup_32 (struct boot_params *boot_params); + +#endif
Signature · 1 line
2.37.4
PATCH v3 22/24 efi/libstub: Add memory attribute protocol definitions
In reply to Evgeniy BaskovEFI_MEMORY_ATTRIBUTE_PROTOCOL servers as a better alternative to DXE services for setting memory attributes in EFI Boot Services environment. This protocol is better since it is a part of UEFI specification itself and not UEFI PI specification like DXE services.
Add EFI_MEMORY_ATTRIBUTE_PROTOCOL definitions.
Support mixed mode properly for its calls.
--- arch/x86/include/asm/efi.h | 7 +++++++ drivers/firmware/efi/libstub/efistub.h | 22 ++++++++++++++++++++++ include/linux/efi.h | 1 + 3 files changed, 30 insertions(+)
arch/x86/include/asm/efi.h +7 -0
@@ -325,6 +325,13 @@ static inline u32 efi64_convert_status(efi_status_t status)#define __efi64_argmap_set_memory_space_attributes (phys, size, flags) \ (__efi64_split(phys), __efi64_split(size), __efi64_split(flags)) +/* Memory Attribute Protocol */ +#define __efi64_argmap_set_memory_attributes (protocol, phys, size, flags) \ + ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) + +#define __efi64_argmap_clear_memory_attributes (protocol, phys, size, flags) \ + ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) +/* * The macros below handle the plumbing for the argument mapping. To add a * mapping for a specific EFI method, simply define a macro
drivers/firmware/efi/libstub/efistub.h +22 -0
@@ -39,6 +39,9 @@ extern const efi_system_table_t *efi_system_table;typedef union efi_dxe_services_table efi_dxe_services_table_t ;extern const efi_dxe_services_table_t *efi_dxe_table; +typedef union efi_memory_attribute_protocol efi_memory_attribute_protocol_t ; +extern efi_memory_attribute_protocol_t *efi_mem_attrib_proto; + efi_status_t __efiapi efi_pe_entry(efi_handle_t handle,efi_system_table_t *sys_table_arg);
@@ -415,6 +418,25 @@ union efi_dxe_services_table { } mixed_mode; }; +union efi_memory_attribute_protocol { +struct { +void *get_memory_attributes; + efi_status_t (__efiapi *set_memory_attributes)(efi_memory_attribute_protocol_t *, + efi_physical_addr_t, + u64, + u64); + efi_status_t (__efiapi *clear_memory_attributes)(efi_memory_attribute_protocol_t *, + efi_physical_addr_t, + u64, + u64); + }; +struct { +u32 get_memory_attributes; +u32 set_memory_attributes; +u32 clear_memory_attributes; + } mixed_mode; +}; +typedef union efi_uga_draw_protocol efi_uga_draw_protocol_t ;union efi_uga_draw_protocol {
include/linux/efi.h +1 -0
@@ -390,6 +390,7 @@ void efi_native_runtime_setup(void);#define EFI_RT_PROPERTIES_TABLE_GUID EFI_GUID(0xeb66918a, 0x7eef, 0x402a, 0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)#define EFI_DXE_SERVICES_TABLE_GUID EFI_GUID(0x05ad34ba, 0x6f02, 0x4214, 0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9)#define EFI_SMBIOS_PROTOCOL_GUID EFI_GUID(0x03583ff6, 0xcb36, 0x4940, 0x94, 0x7e, 0xb9, 0xb3, 0x9f, 0x4a, 0xfa, 0xf7) +#define EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID EFI_GUID(0xf4560cf6, 0x40ec, 0x4b4a, 0xa1, 0x92, 0xbf, 0x1d, 0x57, 0xd0, 0xb1, 0x89)#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)
Signature · 1 line
2.37.4
PATCH v3 21/24 efi/x86: Explicitly set sections memory attributes
In reply to Evgeniy BaskovExplicitly change sections memory attributes in efi_pe_entry in case of incorrect EFI implementations and to reduce access rights to compressed kernel blob. By default it is set executable due to restriction in maximum number of sections that can fit before zero page.
--- drivers/firmware/efi/libstub/x86-stub.c | 54 +++++++++++++++++++++++++ 1 file changed, 54 insertions(+)
drivers/firmware/efi/libstub/x86-stub.c +54 -0
@@ -27,6 +27,12 @@ const efi_dxe_services_table_t *efi_dxe_table;extern u32 image_offset; static efi_loaded_image_t *image __section(".data"); +extern char _head[], _ehead[]; +extern char _compressed[], _ecompressed[]; +extern char _text[], _etext[]; +extern char _rodata[], _erodata[]; +extern char _data[]; +static efi_status_t preserve_pci_rom_image (efi_pci_io_protocol_t *pci,struct pci_setup_rom **__rom) {
@@ -343,6 +349,52 @@ void __noreturn efi_exit(efi_handle_t handle, efi_status_t status) asm("hlt" ); } + +/* +* Manually setup memory protection attributes for each ELF section +* since we cannot do it properly by using PE sections. +*/ +static void setup_sections_memory_protection (unsigned long image_base) +{ +#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES + efi_dxe_table =get_efi_config_table (EFI_DXE_SERVICES_TABLE_GUID ); + +if (!efi_dxe_table || + efi_dxe_table->hdr.signature !=EFI_DXE_SERVICES_TABLE_SIGNATURE ) { +efi_warn ("Unable to locate EFI DXE services table\n" ); + efi_dxe_table =NULL ; +return ; + } + +/* .setup [image_base, _head] */ +efi_adjust_memory_range_protection (image_base, + (unsigned long )_head - image_base, +EFI_MEMORY_RO |EFI_MEMORY_XP ); +/* .head.text [_head, _ehead] */ +efi_adjust_memory_range_protection ((unsigned long )_head, + (unsigned long )_ehead - (unsigned long )_head, +EFI_MEMORY_RO ); +/* .rodata..compressed [_compressed, _ecompressed] */ +efi_adjust_memory_range_protection ((unsigned long )_compressed, + (unsigned long )_ecompressed - (unsigned long )_compressed, +EFI_MEMORY_RO |EFI_MEMORY_XP ); +/* .text [_text, _etext] */ +efi_adjust_memory_range_protection ((unsigned long )_text, + (unsigned long )_etext - (unsigned long )_text, +EFI_MEMORY_RO ); +/* .rodata [_rodata, _erodata] */ +efi_adjust_memory_range_protection ((unsigned long )_rodata, + (unsigned long )_erodata - (unsigned long )_rodata, +EFI_MEMORY_RO |EFI_MEMORY_XP ); +/* .data, .bss [_data, _end] */ +efi_adjust_memory_range_protection ((unsigned long )_data, + (unsigned long )_end - (unsigned long )_data, +EFI_MEMORY_XP ); +#else + (void )image_base; +#endif +} +void __noreturn efi_stub_entry (efi_handle_t handle,efi_system_table_t *sys_table_arg,struct boot_params *boot_params);
@@ -687,6 +739,8 @@ asmlinkage unsigned long efi_main(efi_handle_t handle, efi_dxe_table =NULL ; } +setup_sections_memory_protection (bzimage_addr - image_offset); +#ifdef CONFIG_CMDLINE_BOOL status =efi_parse_options (CONFIG_CMDLINE );if (status !=EFI_SUCCESS ) {
Signature · 1 line
2.37.4
PATCH v3 24/24 efi/libstub: Make memory protection warnings include newlines
In reply to Evgeniy BaskovFrom: Peter Jones <[email protected]>
efi_warn() doesn't put newlines on messages, and that makes reading warnings without newlines hard to do.
--- drivers/firmware/efi/libstub/mem.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/firmware/efi/libstub/mem.c +2 -2
@@ -294,7 +294,7 @@ efi_status_t efi_adjust_memory_range_protection(unsigned long start, rounded_end - rounded_start, attr_clear);if (status !=EFI_SUCCESS ) { -efi_warn ("Failed to clear memory attributes at [%08lx,%08lx]: %lx" , +efi_warn ("Failed to clear memory attributes at [%08lx,%08lx]: %lx\n" , (unsigned long )rounded_start, (unsigned long )rounded_end, status);
@@ -307,7 +307,7 @@ efi_status_t efi_adjust_memory_range_protection(unsigned long start, rounded_end - rounded_start, attributes);if (status !=EFI_SUCCESS ) { -efi_warn ("Failed to set memory attributes at [%08lx,%08lx]: %lx" , +efi_warn ("Failed to set memory attributes at [%08lx,%08lx]: %lx\n" , (unsigned long )rounded_start, (unsigned long )rounded_end, status);
Signature · 1 line
2.37.4
PATCH v3 19/24 x86/build: Cleanup tools/build.c
In reply to Evgeniy BaskovUse newer C standard. Since kernel requires C99 compiler now, we can make use of the new features to make the core more readable.
Use mmap() for reading files also to make things simpler.
Replace most magic numbers with defines.
Should have no functional changes. This is done in preparation for the next changes that makes generated PE header more spec compliant.
--- arch/x86/boot/tools/build.c | 387 +++++++++++++++++++++++------------- 1 file changed, 245 insertions(+), 142 deletions(-)
arch/x86/boot/tools/build.c +245 -142
@@ -25,20 +25,21 @@* Substantially overhauled by H. Peter Anvin, April 2007 */ +#include <fcntl.h> +#include <stdarg.h> +#include <stdint.h> #include <stdio.h> -#include <string.h> #include <stdlib.h> -#include <stdarg.h> -#include <sys/types.h> +#include <string.h> +#include <sys/mman.h> #include <sys/stat.h> +#include <sys/types.h> #include <unistd.h> -#include <fcntl.h> -#include <sys/mman.h> +#include <tools/le_byteshift.h> +#include <linux/pe.h> -typedef unsigned char u8 ; -typedef unsigned short u16 ; -typedef unsigned int u32 ; +#define round_up (x, n) (((x) + (n) - 1) & ~((n) - 1))#define DEFAULT_MAJOR_ROOT 0#define DEFAULT_MINOR_ROOT 0
@@ -48,8 +49,13 @@ typedef unsigned int u32;#define SETUP_SECT_MIN 5#define SETUP_SECT_MAX 64 +#define PARAGRAPH_SIZE 16 +#define SECTOR_SIZE 512 +#define FILE_ALIGNMENT 512 +#define SECTION_ALIGNMENT 4096 +/* This must be large enough to hold the entire setup */ -u8 buf[SETUP_SECT_MAX *512 ]; +uint8_t buf[SETUP_SECT_MAX *SECTOR_SIZE ];#define PECOFF_RELOC_RESERVE 0x20
@@ -59,6 +65,52 @@ u8 buf[SETUP_SECT_MAX*512];#define PECOFF_COMPAT_RESERVE 0x0#endif +#define RELOC_SECTION_SIZE 10 + +/* PE header has different format depending on the architecture */ +#ifdef CONFIG_X86_64 +typedef struct pe32plus_opt_hdr pe_opt_hdr ; +#else +typedef struct pe32_opt_hdr pe_opt_hdr ; +#endif + +static inline struct pe_hdr *get_pe_header (uint8_t *buf) +{ +uint32_t pe_offset =get_unaligned_le32 (buf+MZ_HEADER_PEADDR_OFFSET ); +return (struct pe_hdr *)(buf + pe_offset); +} + +static inline pe_opt_hdr *get_pe_opt_header (uint8_t *buf) +{ +return (pe_opt_hdr *)(get_pe_header (buf) +1 ); +} + +static inline struct section_header *get_sections (uint8_t *buf) +{ +pe_opt_hdr *hdr =get_pe_opt_header (buf); +uint32_t n_data_dirs =get_unaligned_le32 (&hdr->data_dirs); +uint8_t *sections = (uint8_t *)(hdr +1 ) + n_data_dirs*sizeof (struct data_dirent ); +return (struct section_header *)sections; +} + +static inline struct data_directory *get_data_dirs (uint8_t *buf) +{ +pe_opt_hdr *hdr =get_pe_opt_header (buf); +return (struct data_directory *)(hdr +1 ); +} + +#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES +#define SCN_RW (IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | IMAGE_SCN_ALIGN_4096BYTES) +#define SCN_RX (IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_ALIGN_4096BYTES) +#define SCN_RO (IMAGE_SCN_MEM_READ | IMAGE_SCN_ALIGN_4096BYTES) +#else +/* With memory protection disabled all sections are RWX */ +#define SCN_RW (IMAGE_SCN_MEM_READ | IMAGE_SCN_MEM_WRITE | \ + IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_ALIGN_4096BYTES) +#define SCN_RX SCN_RW +#define SCN_RO SCN_RW +#endif +static unsigned long efi32_stub_entry;static unsigned long efi64_stub_entry;static unsigned long efi_pe_entry;
@@ -70,7 +122,7 @@ static unsigned long _end;/*----------------------------------------------------------------------*/ -static const u32 crctab32[] = { +static const uint32_t crctab32[] = {0x00000000 ,0x77073096 ,0xee0e612c ,0x990951ba ,0x076dc419 ,0x706af48f ,0xe963a535 ,0x9e6495a3 ,0x0edb8832 ,0x79dcb8a4 ,0xe0d5e91e ,0x97d2d988 ,0x09b64c2b ,0x7eb17cbd ,0xe7b82d07 ,
@@ -125,12 +177,12 @@ static const u32 crctab32[] = { 0x2d02ef8d }; -static u32 partial_crc32_one (u8 c,u32 crc) +static uint32_t partial_crc32_one (uint8_t c,uint32_t crc) {return crctab32[(crc ^ c) &0xff ] ^ (crc >>8 ); } -static u32 partial_crc32 (const u8 *s,int len,u32 crc) +static uint32_t partial_crc32 (const uint8_t *s,int len,uint32_t crc) {while (len--) crc =partial_crc32_one (*s++, crc);
@@ -152,57 +204,106 @@ static void usage(void)die ("Usage: build setup system zoffset.h image" ); } +static void *map_file (const char *path,size_t *psize) +{ +struct stat statbuf; +size_t size; +void *addr; +int fd; + + fd =open (path,O_RDONLY ); +if (fd <0 ) +die ("Unable to open `%s': %m" , path); +if (fstat (fd, &statbuf)) +die ("Unable to stat `%s': %m" , path); + + size = statbuf.st_size; +/* +* Map one byte more, to allow adding null-terminator +* for text files. +*/ + addr =mmap (NULL , size +1 ,PROT_READ |PROT_WRITE ,MAP_PRIVATE , fd,0 ); +if (addr ==MAP_FAILED ) +die ("Unable to mmap '%s': %m" , path); + +close (fd); + + *psize = size; +return addr; +} + +static void unmap_file (void *addr,size_t size) +{ +munmap (addr, size +1 ); +} + +static void *map_output_file (const char *path,size_t size) +{ +void *addr; +int fd; + + fd =open (path,O_RDWR |O_CREAT ,0660 ); +if (fd <0 ) +die ("Unable to create `%s': %m" , path); + +if (ftruncate (fd, size)) +die ("Unable to resize `%s': %m" , path); + + addr =mmap (NULL , size,PROT_READ |PROT_WRITE ,MAP_SHARED , fd,0 ); +if (addr ==MAP_FAILED ) +die ("Unable to mmap '%s': %m" , path); + +return addr; +} +#ifdef CONFIG_EFI_STUB -static void update_pecoff_section_header_fields (char *section_name,u32 vma,u32 size,u32 datasz,u32 offset) +static void update_pecoff_section_header_fields (char *section_name,uint32_t vma, +uint32_t size,uint32_t datasz, +uint32_t offset) {unsigned int pe_header;unsigned short num_sections; -u8 *section; +struct section_header *section; - pe_header =get_unaligned_le32 (&buf[0x3c ]); - num_sections =get_unaligned_le16 (&buf[pe_header +6 ]); - -#ifdef CONFIG_X86_32 - section = &buf[pe_header +0xa8 ]; -#else - section = &buf[pe_header +0xb8 ]; -#endif +struct pe_hdr *hdr =get_pe_header (buf); + num_sections =get_unaligned_le16 (&hdr->sections); + section =get_sections (buf);while (num_sections >0 ) { -if (strncmp ((char *)section, section_name,8 ) ==0 ) { +if (strncmp (section->name, section_name,8 ) ==0 ) {/* section header size field */ -put_unaligned_le32 (size, section +0x8 ); +put_unaligned_le32 (size, §ion->virtual_size);/* section header vma field */ -put_unaligned_le32 (vma, section +0xc ); +put_unaligned_le32 (vma, §ion->virtual_address);/* section header 'size of initialised data' field */ -put_unaligned_le32 (datasz, section +0x10 ); +put_unaligned_le32 (datasz, §ion->raw_data_size);/* section header 'file offset' field */ -put_unaligned_le32 (offset, section +0x14 ); +put_unaligned_le32 (offset, §ion->data_addr);break ; } - section +=0x28 ; + section++; num_sections--; } } -static void update_pecoff_section_header (char *section_name,u32 offset,u32 size) +static void update_pecoff_section_header (char *section_name,uint32_t offset,uint32_t size) {update_pecoff_section_header_fields (section_name, offset, size, size, offset); }static void update_pecoff_setup_and_reloc (unsigned int size) { -u32 setup_offset =0x200 ; -u32 reloc_offset = size -PECOFF_RELOC_RESERVE -PECOFF_COMPAT_RESERVE ; +uint32_t setup_offset =SECTOR_SIZE ; +uint32_t reloc_offset = size -PECOFF_RELOC_RESERVE -PECOFF_COMPAT_RESERVE ;#ifdef CONFIG_EFI_MIXED -u32 compat_offset = reloc_offset +PECOFF_RELOC_RESERVE ; +uint32_t compat_offset = reloc_offset +PECOFF_RELOC_RESERVE ;#endif -u32 setup_size = reloc_offset - setup_offset; +uint32_t setup_size = reloc_offset - setup_offset;update_pecoff_section_header (".setup" , setup_offset, setup_size);update_pecoff_section_header (".reloc" , reloc_offset,PECOFF_RELOC_RESERVE );
@@ -211,8 +312,8 @@ static void update_pecoff_setup_and_reloc(unsigned int size)* Modify .reloc section contents with a single entry. The * relocation is applied to offset 10 of the relocation section. */ -put_unaligned_le32 (reloc_offset +10 , &buf[reloc_offset]); -put_unaligned_le32 (10 , &buf[reloc_offset +4 ]); +put_unaligned_le32 (reloc_offset +RELOC_SECTION_SIZE , &buf[reloc_offset]); +put_unaligned_le32 (RELOC_SECTION_SIZE , &buf[reloc_offset +4 ]);#ifdef CONFIG_EFI_MIXED update_pecoff_section_header (".compat" , compat_offset,PECOFF_COMPAT_RESERVE );
@@ -224,19 +325,17 @@ static void update_pecoff_setup_and_reloc(unsigned int size)*/ buf[compat_offset] =0x1 ; buf[compat_offset +1 ] =0x8 ; -put_unaligned_le16 (0x14c , &buf[compat_offset +2 ]); +put_unaligned_le16 (IMAGE_FILE_MACHINE_I386 , &buf[compat_offset +2 ]);put_unaligned_le32 (efi32_pe_entry + size, &buf[compat_offset +4 ]);#endif } -static void update_pecoff_text (unsigned int text_start,unsigned int file_sz, +static unsigned int update_pecoff_sections (unsigned int text_start,unsigned int text_sz,unsigned int init_sz) { -unsigned int pe_header; -unsigned int text_sz = file_sz - text_start; +unsigned int file_sz = text_start + text_sz;unsigned int bss_sz = init_sz - file_sz; - - pe_header =get_unaligned_le32 (&buf[0x3c ]); +pe_opt_hdr *hdr =get_pe_opt_header (buf);/* * The PE/COFF loader may load the image at an address which is
@@ -254,18 +353,20 @@ static void update_pecoff_text(unsigned int text_start, unsigned int file_sz,* Size of code: Subtract the size of the first sector (512 bytes) * which includes the header. */ -put_unaligned_le32 (file_sz -512 + bss_sz, &buf[pe_header +0x1c ]); +put_unaligned_le32 (file_sz -SECTOR_SIZE + bss_sz, &hdr->text_size);/* Size of image */ -put_unaligned_le32 (init_sz, &buf[pe_header +0x50 ]); +put_unaligned_le32 (init_sz, &hdr->image_size);/* * Address of entry point for PE/COFF executable */ -put_unaligned_le32 (text_start + efi_pe_entry, &buf[pe_header +0x28 ]); +put_unaligned_le32 (text_start + efi_pe_entry, &hdr->entry_point);update_pecoff_section_header_fields (".text" , text_start, text_sz + bss_sz, text_sz, text_start); + +return text_start + file_sz; }static int reserve_pecoff_reloc_section (int c)
@@ -275,7 +376,7 @@ static int reserve_pecoff_reloc_section(int c)return PECOFF_RELOC_RESERVE ; } -static void efi_stub_defaults (void ) +static void efi_stub_update_defaults (void ) {/* Defaults for old kernel */ #ifdef CONFIG_X86_32
@@ -297,7 +398,7 @@ static void efi_stub_entry_update(void)#ifdef CONFIG_EFI_MIXED if (efi32_stub_entry != addr) -die ("32-bit and 64-bit EFI entry points do not match\n" ); +die ("32-bit and 64-bit EFI entry points do not match" );#endif put_unaligned_le32 (addr, &buf[0x264 ]); }
@@ -308,7 +409,7 @@ static inline void update_pecoff_setup_and_reloc(unsigned int size) {}static inline void update_pecoff_text (unsigned int text_start,unsigned int file_sz,unsigned int init_sz) {} -static inline void efi_stub_defaults (void ) {} +static inline void efi_stub_update_defaults (void ) {}static inline void efi_stub_entry_update (void ) {}static inline int reserve_pecoff_reloc_section (int c)
@@ -336,20 +437,15 @@ static int reserve_pecoff_compat_section(int c)static void parse_zoffset (char *fname) { -FILE *file; -char *p; -int c; +size_t size; +char *data, *p; - file =fopen (fname,"r" ); -if (!file) -die ("Unable to open `%s': %m" , fname); - c =fread (buf,1 ,sizeof (buf) -1 , file); -if (ferror (file)) -die ("read-error on `zoffset.h'" ); -fclose (file); - buf[c] =0 ; + data =map_file (fname, &size); - p = (char *)buf; +/* We can do that, since we mapped one byte more */ + data[size] =0 ; + + p = (char *)data;while (p && *p) {PARSE_ZOFS (p, efi32_stub_entry);
@@ -365,82 +461,99 @@ static void parse_zoffset(char *fname)while (p && (*p =='\r' || *p =='\n' )) p++; } + +unmap_file (data, size); } -int main (int argc,char ** argv) +static unsigned int read_setup (char *path) { -unsigned int i, sz, setup_sectors, init_sz; -int c; -u32 sys_size; -struct stat sb; -FILE *file, *dest; -int fd; -void *kernel; -u32 crc =0xffffffffUL ; - -efi_stub_defaults (); - -if (argc !=5 ) -usage (); -parse_zoffset (argv[3 ]); - - dest =fopen (argv[4 ],"w" ); -if (!dest) -die ("Unable to write `%s': %m" , argv[4 ]); +FILE *file; +unsigned int setup_size, file_size;/* Copy the setup code */ - file =fopen (argv[1 ],"r" ); + file =fopen (path,"r" );if (!file) -die ("Unable to open `%s': %m" , argv[1 ]); - c =fread (buf,1 ,sizeof (buf), file); +die ("Unable to open `%s': %m" , path); + + file_size =fread (buf,1 ,sizeof (buf), file);if (ferror (file))die ("read-error on `setup'" ); -if (c <1024 ) + +if (file_size <2 *SECTOR_SIZE )die ("The setup must be at least 1024 bytes" ); -if (get_unaligned_le16 (&buf[510 ]) !=0xAA55 ) + +if (get_unaligned_le16 (&buf[SECTOR_SIZE -2 ]) !=0xAA55 )die ("Boot block hasn't got boot flag (0xAA55)" ); +fclose (file); - c +=reserve_pecoff_compat_section (c); - c +=reserve_pecoff_reloc_section (c); +/* Reserve space for PE sections */ + file_size +=reserve_pecoff_compat_section (file_size); + file_size +=reserve_pecoff_reloc_section (file_size);/* Pad unused space with zeros */ - setup_sectors = (c +511 ) /512 ; -if (setup_sectors <SETUP_SECT_MIN ) - setup_sectors =SETUP_SECT_MIN ; - i = setup_sectors*512 ; -memset (buf+c,0 , i-c); -update_pecoff_setup_and_reloc (i); + setup_size =round_up (file_size,SECTOR_SIZE ); + +if (setup_size <SETUP_SECT_MIN *SECTOR_SIZE ) + setup_size =SETUP_SECT_MIN *SECTOR_SIZE ; + +/* +* Global buffer is already initialised +* to 0, but just in case, zero out padding. +*/ + +memset (buf + file_size,0 , setup_size - file_size); + +return setup_size; +} + +int main (int argc,char **argv) +{ +size_t kern_file_size; +unsigned int setup_size; +unsigned int setup_sectors; +unsigned int init_size; +unsigned int total_size; +unsigned int kern_size; +void *kernel; +uint32_t crc =0xffffffffUL ; +uint8_t *output; + +if (argc !=5 ) +usage (); + +efi_stub_update_defaults (); +parse_zoffset (argv[3 ]); + + setup_size =read_setup (argv[1 ]); + + setup_sectors = setup_size/SECTOR_SIZE ;/* Set the default root device */ put_unaligned_le16 (DEFAULT_ROOT_DEV , &buf[508 ]); -/* Open and stat the kernel file */ - fd =open (argv[2 ],O_RDONLY ); -if (fd <0 ) -die ("Unable to open `%s': %m" , argv[2 ]); -if (fstat (fd, &sb)) -die ("Unable to stat `%s': %m" , argv[2 ]); - sz = sb.st_size; - kernel =mmap (NULL , sz,PROT_READ ,MAP_SHARED , fd,0 ); -if (kernel ==MAP_FAILED ) -die ("Unable to mmap '%s': %m" , argv[2 ]); -/* Number of 16-byte paragraphs, including space for a 4-byte CRC */ - sys_size = (sz +15 +4 ) /16 ; +/* Map kernel file to memory */ + kernel =map_file (argv[2 ], &kern_file_size); +#ifdef CONFIG_EFI_STUB -/* -* COFF requires minimum 32-byte alignment of sections, and -* adding a signature is problematic without that alignment. -*/ - sys_size = (sys_size +1 ) & ~1 ; +/* PE specification require 512-byte minimum section file alignment */ + kern_size =round_up (kern_file_size +4 ,SECTOR_SIZE ); +update_pecoff_setup_and_reloc (setup_size); +#else +/* Number of 16-byte paragraphs, including space for a 4-byte CRC */ + kern_size =round_up (kern_file_size +4 ,PARAGRAPH_SIZE );#endif /* Patch the setup code with the appropriate size parameters */ - buf[0x1f1 ] = setup_sectors-1 ; -put_unaligned_le32 (sys_size, &buf[0x1f4 ]); + buf[0x1f1 ] = setup_sectors -1 ; +put_unaligned_le32 (kern_size/PARAGRAPH_SIZE , &buf[0x1f4 ]); + +/* Update kernel_info offset. */ +put_unaligned_le32 (kernel_info, &buf[0x268 ]); + + init_size =get_unaligned_le32 (&buf[0x260 ]); - init_sz =get_unaligned_le32 (&buf[0x260 ]);#ifdef CONFIG_EFI_STUB /* * The decompression buffer will start at ImageBase. When relocating
@@ -456,45 +569,35 @@ int main(int argc, char ** argv)* For future-proofing, increase init_sz if necessary. */ -if (init_sz - _end < i + _ehead) { - init_sz = (i + _ehead + _end +4095 ) & ~4095 ; -put_unaligned_le32 (init_sz, &buf[0x260 ]); +if (init_size - _end < setup_size + _ehead) { + init_size =round_up (setup_size + _ehead + _end,SECTION_ALIGNMENT ); +put_unaligned_le32 (init_size, &buf[0x260 ]); } -#endif -update_pecoff_text (setup_sectors *512 , i + (sys_size *16 ), init_sz); -efi_stub_entry_update (); - -/* Update kernel_info offset. */ -put_unaligned_le32 (kernel_info, &buf[0x268 ]); + total_size =update_pecoff_sections (setup_size, kern_size, init_size); - crc =partial_crc32 (buf, i, crc); -if (fwrite (buf,1 , i, dest) != i) -die ("Writing setup failed" ); +efi_stub_entry_update (); +#else + (void )init_size; + total_size = setup_size + kern_size; +#endif -/* Copy the kernel code */ - crc =partial_crc32 (kernel, sz, crc); -if (fwrite (kernel,1 , sz, dest) != sz) -die ("Writing kernel failed" ); + output =map_output_file (argv[4 ], total_size); -/* Add padding leaving 4 bytes for the checksum */ -while (sz++ < (sys_size*16 ) -4 ) { - crc =partial_crc32_one ('\0' , crc); -if (fwrite ("\0" ,1 ,1 , dest) !=1 ) -die ("Writing padding failed" ); - } +memcpy (output, buf, setup_size); +memcpy (output + setup_size, kernel, kern_file_size); +memset (output + setup_size + kern_file_size,0 , kern_size - kern_file_size); -/* Write the CRC */ -put_unaligned_le32 (crc, buf); -if (fwrite (buf,1 ,4 , dest) !=4 ) -die ("Writing CRC failed" ); +/* Calculate and write kernel checksum. */ + crc =partial_crc32 (output, total_size -4 , crc); +put_unaligned_le32 (crc, &output[total_size -4 ]); -/* Catch any delayed write failures */ -if (fclose (dest)) -die ("Writing image failed" ); +/* Catch any delayed write failures. */ +if (munmap (output, total_size) <0 ) +die ("Writing kernel failed" ); -close (fd); +unmap_file (kernel, kern_file_size); -/* Everything is OK */ +/* Everything is OK. */ return 0 ; }
Signature · 1 line
2.37.4
PATCH v3 23/24 efi/libstub: Use memory attribute protocol
In reply to Evgeniy BaskovAdd EFI_MEMORY_ATTRIBUTE_PROTOCOL as preferred alternative to DXE services for changing memory attributes in the EFISTUB.
Use DXE services only as a fallback in case aforementioned protocol is not supported by UEFI implementation.
Move DXE services initialization code closer to the place they are used to match EFI_MEMORY_ATTRIBUTE_PROTOCOL initialization code.
--- drivers/firmware/efi/libstub/mem.c | 168 ++++++++++++++++++------ drivers/firmware/efi/libstub/x86-stub.c | 17 --- 2 files changed, 128 insertions(+), 57 deletions(-)
drivers/firmware/efi/libstub/mem.c +128 -40
@@ -5,6 +5,9 @@#include "efistub.h" +const efi_dxe_services_table_t *efi_dxe_table; +efi_memory_attribute_protocol_t *efi_mem_attrib_proto; +/** * efi_get_memory_map() - get memory map * @map: pointer to memory map pointer to which to assign the
@@ -126,66 +129,47 @@ void efi_free(unsigned long size, unsigned long addr)efi_bs_call (free_pages, addr, nr_pages); } -/** -* efi_adjust_memory_range_protection() - change memory range protection attributes -* @start: memory range start address -* @size: memory range size -* -* Actual memory range for which memory attributes are modified is -* the smallest ranged with start address and size aligned to EFI_PAGE_SIZE -* that includes [start, start + size]. -* -* @return: status code -*/ -efi_status_t efi_adjust_memory_range_protection (unsigned long start, -unsigned long size, -unsigned long attributes) +static void retrieve_dxe_table (void ) +{ + efi_dxe_table =get_efi_config_table (EFI_DXE_SERVICES_TABLE_GUID ); +if (efi_dxe_table && + efi_dxe_table->hdr.signature !=EFI_DXE_SERVICES_TABLE_SIGNATURE ) { +efi_warn ("Ignoring DXE services table: invalid signature\n" ); + efi_dxe_table =NULL ; + } +} + +static efi_status_t adjust_mem_attrib_dxe (efi_physical_addr_t rounded_start, +efi_physical_addr_t rounded_end, +unsigned long attributes) {efi_status_t status;efi_gcd_memory_space_desc_t desc; -efi_physical_addr_t end, next; -efi_physical_addr_t rounded_start, rounded_end; +efi_physical_addr_t end, next, start;efi_physical_addr_t unprotect_start, unprotect_size; -if (efi_dxe_table ==NULL ) -return EFI_UNSUPPORTED ; +if (!efi_dxe_table) { +retrieve_dxe_table (); -/* -* This function should not be used to modify attributes -* other than writable/executable. -*/ - -if ((attributes & ~(EFI_MEMORY_RO |EFI_MEMORY_XP )) !=0 ) -return EFI_INVALID_PARAMETER ; - -/* -* Disallow simultaniously executable and writable memory -* to inforce W^X policy if direct extraction code is enabled. -*/ - -if ((attributes & (EFI_MEMORY_RO |EFI_MEMORY_XP )) ==0 ) { -efi_warn ("W^X violation at [%08lx,%08lx]\n" , - (unsigned long )rounded_start, - (unsigned long )rounded_end); +if (!efi_dxe_table) +return EFI_UNSUPPORTED ; } - rounded_start =rounddown (start,EFI_PAGE_SIZE ); - rounded_end =roundup (start + size,EFI_PAGE_SIZE ); -/* * Don't modify memory region attributes, they are * already suitable, to lower the possibility to * encounter firmware bugs. */ -for (end = start + size; start < end; start = next) { + +for (start = rounded_start, end = rounded_end; start < end; start = next) { status =efi_dxe_call (get_memory_space_descriptor, start, &desc);if (status !=EFI_SUCCESS ) {efi_warn ("Unable to get memory descriptor at %lx\n" , - start); + (unsigned long )start);return status; }
@@ -227,3 +211,107 @@ efi_status_t efi_adjust_memory_range_protection(unsigned long start,return EFI_SUCCESS ; } + +static void retrieve_memory_attributes_proto (void ) +{ +efi_status_t status; +efi_guid_t guid =EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID ; + + status =efi_bs_call (locate_protocol, &guid,NULL , + (void **)&efi_mem_attrib_proto); +if (status !=EFI_SUCCESS ) + efi_mem_attrib_proto =NULL ; +} + +/** +* efi_adjust_memory_range_protection() - change memory range protection attributes +* @start: memory range start address +* @size: memory range size +* +* Actual memory range for which memory attributes are modified is +* the smallest ranged with start address and size aligned to EFI_PAGE_SIZE +* that includes [start, start + size]. +* +* This function first attempts to use EFI_MEMORY_ATTRIBUTE_PROTOCOL, +* that is a part of UEFI Specification since version 2.10. +* If the protocol is unavailable it falls back to DXE services functions. +* +* @return: status code +*/ +efi_status_t efi_adjust_memory_range_protection (unsigned long start, +unsigned long size, +unsigned long attributes) +{ +efi_status_t status; +efi_physical_addr_t rounded_start, rounded_end; +unsigned long attr_clear; + +/* +* This function should not be used to modify attributes +* other than writable/executable. +*/ + +if ((attributes & ~(EFI_MEMORY_RO |EFI_MEMORY_XP )) !=0 ) +return EFI_INVALID_PARAMETER ; + +/* +* Warn if requested to make memory simultaneously +* executable and writable to enforce W^X policy. +*/ + +if ((attributes & (EFI_MEMORY_RO |EFI_MEMORY_XP )) ==0 ) { +efi_warn ("W^X violation at [%08lx,%08lx]" , + (unsigned long )rounded_start, + (unsigned long )rounded_end); + } + + rounded_start =rounddown (start,EFI_PAGE_SIZE ); + rounded_end =roundup (start + size,EFI_PAGE_SIZE ); + +if (!efi_mem_attrib_proto) { +retrieve_memory_attributes_proto (); + +/* Fall back to DXE services if unsupported */ +if (!efi_mem_attrib_proto) { +return adjust_mem_attrib_dxe (rounded_start, + rounded_end, + attributes); + } + } + +/* +* Unlike DXE services functions, EFI_MEMORY_ATTRIBUTE_PROTOCOL +* does not clear unset protection bit, so it needs to be cleared +* explcitly +*/ + + attr_clear = ~attributes & + (EFI_MEMORY_RO |EFI_MEMORY_XP |EFI_MEMORY_RP ); + + status =efi_call_proto (efi_mem_attrib_proto, + clear_memory_attributes, + rounded_start, + rounded_end - rounded_start, + attr_clear); +if (status !=EFI_SUCCESS ) { +efi_warn ("Failed to clear memory attributes at [%08lx,%08lx]: %lx" , + (unsigned long )rounded_start, + (unsigned long )rounded_end, + status); +return status; + } + + status =efi_call_proto (efi_mem_attrib_proto, + set_memory_attributes, + rounded_start, + rounded_end - rounded_start, + attributes); +if (status !=EFI_SUCCESS ) { +efi_warn ("Failed to set memory attributes at [%08lx,%08lx]: %lx" , + (unsigned long )rounded_start, + (unsigned long )rounded_end, + status); + } + +return status; +}
drivers/firmware/efi/libstub/x86-stub.c +0 -17
@@ -23,7 +23,6 @@#define MAXMEM_X86_64_4LEVEL (1ull << 46)const efi_system_table_t *efi_system_table; -const efi_dxe_services_table_t *efi_dxe_table;extern u32 image_offset; static efi_loaded_image_t *image __section(".data");
@@ -357,15 +356,6 @@ void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)static void setup_sections_memory_protection (unsigned long image_base) {#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES - efi_dxe_table =get_efi_config_table (EFI_DXE_SERVICES_TABLE_GUID ); - -if (!efi_dxe_table || - efi_dxe_table->hdr.signature !=EFI_DXE_SERVICES_TABLE_SIGNATURE ) { -efi_warn ("Unable to locate EFI DXE services table\n" ); - efi_dxe_table =NULL ; -return ; - } -/* .setup [image_base, _head] */ efi_adjust_memory_range_protection(image_base, (unsigned long)_head - image_base,
@@ -732,13 +722,6 @@ asmlinkage unsigned long efi_main(efi_handle_t handle,if (efi_system_table->hdr.signature !=EFI_SYSTEM_TABLE_SIGNATURE )efi_exit (handle,EFI_INVALID_PARAMETER ); - efi_dxe_table =get_efi_config_table (EFI_DXE_SERVICES_TABLE_GUID ); -if (efi_dxe_table && - efi_dxe_table->hdr.signature !=EFI_DXE_SERVICES_TABLE_SIGNATURE ) { -efi_warn ("Ignoring DXE services table: invalid signature\n" ); - efi_dxe_table =NULL ; - } -setup_sections_memory_protection (bzimage_addr - image_offset);#ifdef CONFIG_CMDLINE_BOOL
Signature · 1 line
2.37.4
PATCH v3 20/24 x86/build: Make generated PE more spec compliant
In reply to Evgeniy BaskovCurrently kernel image is not fully compliant PE image, so it may fail to boot with stricter implementations of UEFI PE loaders.
Set minimal alignments and sizes specified by PE documentation [1] referenced by UEFI specification [2]. Align PE header to 8 bytes.
Generate PE sections dynamically. This simplifies code, since with current implementation all of the sections needs to be defined in header.S, where most section header fields do not hold valid values, except for their names. Before the change, it also held flags, but now flags depend on kernel configuration and it is simpler to set them from build.c too.
Setup sections protection. Since we cannot fit every needed section, set a part of protection flags dynamically during initialization. This step is omitted if CONFIG_EFI_DXE_MEM_ATTRIBUTES is not set.
Reduce .bss size of the PE image to it's exact needs, since in-place extraction is not used for EFI code path.
[1] https://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v83.docx
[2] https://uefi.org/sites/default/files/resources/UEFI_Spec_2_9_2021_03_18.pdf
--- arch/x86/boot/Makefile | 2 +- arch/x86/boot/header.S | 96 +-------- arch/x86/boot/tools/build.c | 270 +++++++++++++----------- drivers/firmware/efi/libstub/x86-stub.c | 7 +- 4 files changed, 161 insertions(+), 214 deletions(-)
arch/x86/boot/Makefile +1 -1
@@ -91,7 +91,7 @@ $(obj)/vmlinux.bin: $(obj)/compressed/vmlinux FORCE SETUP_OBJS = $(addprefix $(obj)/,$(setup-y)) -sed-zoffset := -e 's/^\([0-9a-fA-F]*\) [a-zA-Z] \(startup_32\|startup_64\|efi32_stub_entry\|efi64_stub_entry\|efi_pe_entry\|efi32_pe_entry\|input_data\|kernel_info\|_end\|_ehead\|_text\|z_.*\)$$/\#define ZO_\2 0x\1/p' +sed-zoffset := -e 's/^\([0-9a-fA-F]*\) [a-zA-Z] \(startup_32\|startup_64\|efi32_stub_entry\|efi64_stub_entry\|efi_pe_entry\|efi32_pe_entry\|input_data\|kernel_info\|_end\|_ehead\|_text\|_rodata\|z_.*\)$$/\#define ZO_\2 0x\1/p' quiet_cmd_zoffset = ZOFFSET $@ cmd_zoffset = $(NM) $< | sed -n $(sed-zoffset) > $@
arch/x86/boot/header.S +10 -86
129 lines not on this page · raw message
arch/x86/boot/tools/build.c +145 -125
377 lines not on this page · raw message
drivers/firmware/efi/libstub/x86-stub.c +5 -2
@@ -389,8 +389,11 @@ efi_status_t __efiapi efi_pe_entry(efi_handle_t handle, hdr = &boot_params->hdr; -/* Copy the setup header from the second sector to boot_params */ -memcpy (&hdr->jump, image_base +512 , +/* +* Copy the setup header from the second sector +* (mapped to image_base + 0x1000) to boot_params +*/ +memcpy (&hdr->jump, image_base +0x1000 ,sizeof (struct setup_header ) - offsetof(struct setup_header , jump));/*
Signature · 1 line
2.37.4
Quoted 5 lines · Evgeniy Baskov
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code forx86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.
Hi Evgeniy,
I've tested this patch set on hardware and QEMU+MU firmware, and it works for me with a couple of minor issues:
- on one machine that has the DXE protocol but not the EFI one, we get an error because the firmware doesn't support EFI_MEMORY_RP
- on QEMU I'm seeing the size of "(unsigned long)_head - image_base" wind up as 0, which leads to an EFI_INVALID_PARAMETER on the clear_memory_attributes() call.
In both cases the system winds up working, but with unnecessary console output. I'll send you patches as a follow-up to this mail. In the mean time:
Signature · 1 line
Peter
PATCH 1/2 efi/x86: don't set unsupported memory attributes
On platforms where the firmware uses DXE, but which do not implement the EFI Memory Attribute Protocol, we implement W^X support using DXE's set_memory_attributes() call. This call will fail without making any changes if an attribute is set that isn't supported on the platform.
This patch changes efi_adjust_memory_range_protection() to avoid trying to set any attribute bits that aren't set in the memory region's capability flags.
--- drivers/firmware/efi/libstub/mem.c | 1 + 1 file changed, 1 insertion(+)
drivers/firmware/efi/libstub/mem.c +1 -0
@@ -192,6 +192,7 @@ static efi_status_t adjust_mem_attrib_dxe(efi_physical_addr_t rounded_start, desc.attributes &= ~(EFI_MEMORY_RO |EFI_MEMORY_XP ); desc.attributes |= attributes; + desc.attributes &= desc.capabilities; unprotect_start =max (rounded_start, desc.base_address); unprotect_size =min (rounded_end, next) - unprotect_start;
Signature · 1 line
2.38.1
PATCH 2/2 efi/x86: don't try to set page attributes on 0-sized regions.
In "efi/x86: Explicitly set sections memory attributes", the following region is defined to help compute page permissions:
/* .setup [image_base, _head] */
efi_adjust_memory_range_protection(image_base,
(unsigned long)_head - image_base,
EFI_MEMORY_RO | EFI_MEMORY_XP);In at least some cases, that will result in a size of 0, which will produce an error and a message on the console, though no actual failure will be caused in the boot process.
This patch checks that case in efi_adjust_memory_range_protection() and returns the error without logging.
--- drivers/firmware/efi/libstub/mem.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/firmware/efi/libstub/mem.c +3 -0
@@ -247,6 +247,9 @@ efi_status_t efi_adjust_memory_range_protection(unsigned long start,efi_physical_addr_t rounded_start, rounded_end;unsigned long attr_clear; +if (size ==0 ) +return EFI_INVALID_PARAMETER ; +/* * This function should not be used to modify attributes * other than writable/executable.
Signature · 1 line
2.38.1
Quoted 12 lines · Peter Jones
Quoted 5 lines · Evgeniy Baskov
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code forx86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.Hi Evgeniy,
I've tested this patch set on hardware and QEMU+MU firmware, and it works for me with a couple of minor issues:
Quoted 8 lines
- on one machine that has the DXE protocol but not the EFI one, we get an error because the firmware doesn't support
EFI_MEMORY_RP
- on QEMU I'm seeing the size of "(unsigned long)_head -image_base" wind up as 0, which leads to anEFI_INVALID_PARAMETERon theclear_memory_attributes()call.In both cases the system winds up working, but with unnecessary console output.
I just realized I've overstated here - I haven't actually hit the first problem on x86, only on ARM, where we don't currently use this code. I discovered it in grub, and checked your patch set to see if you had the same issue I did. That said, "in both cases the system winds up working" is probably still true - in that the edk2 code supports EFI_MEMORY_RP on x86 but not ARM, so x86 won't hit the issue when using DXE unless someone cooks up another implementation. Nevertheless I believe the patch to fix it is correct and should be applied.
Thanks!
Signature · 1 line
Peter
Quoted 31 lines · Peter Jones
Quoted 12 lines · Peter Jones
Quoted 5 lines · Evgeniy Baskov
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code forx86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.Hi Evgeniy,
I've tested this patch set on hardware and QEMU+MU firmware, and it works for me with a couple of minor issues:
Quoted 8 lines
- on one machine that has the DXE protocol but not the EFI one, we get an error because the firmware doesn't support
EFI_MEMORY_RP
- on QEMU I'm seeing the size of "(unsigned long)_head -image_base" wind up as 0, which leads to anEFI_INVALID_PARAMETERon theclear_memory_attributes()call.In both cases the system winds up working, but with unnecessary console output.
I just realized I've overstated here - I haven't actually hit the first problem on x86, only on ARM, where we don't currently use this code. I discovered it in grub, and checked your patch set to see if you had the same issue I did. That said, "in both cases the system winds up working" is probably still true - in that the edk2 code supports
EFI_MEMORY_RPon x86 but not ARM, so x86 won't hit the issue when using DXE unless someone cooks up another implementation. Nevertheless I believe the patch to fix it is correct and should be applied.
Quoted 1 line
Thanks!
Hi,
Thank you for testing and fixes!
I have also discovered one issue with v3, that can only be hit when booting with grub -- there's one kernel_add_identity_map() missing in the get_acpi_srat_table() function, before header->length is read. So I'll prepare the v4 soon and include your new patches there.
Thanks,
Evgeniy Baskov
Ard Biesheuvel
maintainerQuoted 36 lines · Evgeniy Baskov
Quoted 32 lines · Peter Jones
Quoted 18 lines · Peter Jones
Quoted 5 lines · Evgeniy Baskov
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code forx86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.Hi Evgeniy,
I've tested this patch set on hardware and QEMU+MU firmware, and it works for me with a couple of minor issues:
- on one machine that has the DXE protocol but not the EFI one, we get an error because the firmware doesn't support
EFI_MEMORY_RP
- on QEMU I'm seeing the size of "(unsigned long)_head -image_base" wind up as 0, which leads to anEFI_INVALID_PARAMETERon theclear_memory_attributes()call.Quoted 3 lines
In both cases the system winds up working, but with unnecessary console
output.I just realized I've overstated here - I haven't actually hit the first problem on x86, only on ARM, where we don't currently use this code. I discovered it in grub, and checked your patch set to see if you had the same issue I did. That said, "in both cases the system winds up working" is probably still true - in that the edk2 code supports
EFI_MEMORY_RPon x86 but not ARM, so x86 won't hit the issue when using DXE unless someone cooks up another implementation. Nevertheless I believe the patch to fix it is correct and should be applied.Quoted 1 line
Thanks!
Quoted 9 lines
Hi,
Thank you for testing and fixes!
I have also discovered one issue with v3, that can only be hit when booting with grub -- there's one
kernel_add_identity_map()missing in theget_acpi_srat_table()function, beforeheader->lengthis read. So I'll prepare the v4 soon and include your new patches there.
Happy to see this is converging. Please rebase onto latest mainline as well - some cleanups to the early boot code have landed there yesterday.
Quoted 47 lines · Ard Biesheuvel
Quoted 36 lines · Evgeniy Baskov
Quoted 32 lines · Peter Jones
Quoted 18 lines · Peter Jones
Quoted 5 lines · Evgeniy Baskov
This patchset is aimed
* to improve UEFI compatibility of compressed kernel code forx86_64
* to setup proper memory access attributes for code and rodata sections
* to implement W^X protection policy throughout the whole execution of compressed kernel for EFISTUB code path.Hi Evgeniy,
I've tested this patch set on hardware and QEMU+MU firmware, and it works for me with a couple of minor issues:
- on one machine that has the DXE protocol but not the EFI one, we get an error because the firmware doesn't support
EFI_MEMORY_RP
- on QEMU I'm seeing the size of "(unsigned long)_head -image_base" wind up as 0, which leads to anEFI_INVALID_PARAMETERon theclear_memory_attributes()call.Quoted 3 lines
In both cases the system winds up working, but with unnecessary console
output.I just realized I've overstated here - I haven't actually hit the first problem on x86, only on ARM, where we don't currently use this code. I discovered it in grub, and checked your patch set to see if you had the same issue I did. That said, "in both cases the system winds up working" is probably still true - in that the edk2 code supports
EFI_MEMORY_RPon x86 but not ARM, so x86 won't hit the issue when using DXE unless someone cooks up another implementation. Nevertheless I believe the patch to fix it is correct and should be applied.Quoted 1 line
Thanks!
Quoted 9 lines
Hi,
Thank you for testing and fixes!
I have also discovered one issue with v3, that can only be hit when booting with grub -- there's one
kernel_add_identity_map()missing in theget_acpi_srat_table()function, beforeheader->lengthis read. So I'll prepare the v4 soon and include your new patches there.
Quoted 3 lines
Happy to see this is converging. Please rebase onto latest mainline as well - some cleanups to the early boot code have landed there yesterday.
Will do, thanks!
Ard Biesheuvel
maintainerRe: [PATCH v3 22/24] efi/libstub: Add memory attribute protocol definitions
In reply to Evgeniy BaskovQuoted 7 lines · Evgeniy Baskov
EFI_MEMORY_ATTRIBUTE_PROTOCOLservers as a better alternative to DXE services for setting memory attributes in EFI Boot Services environment. This protocol is better since it is a part of UEFI specification itself and not UEFI PI specification like DXE services.
Quoted 5 lines
Add
EFI_MEMORY_ATTRIBUTE_PROTOCOLdefinitions.
Support mixed mode properly for its calls.Tested-by Mario Limonciello <[email protected]>Signed-off-by Evgeniy Baskov <[email protected]>
I have fixed up just this patch, as there is another user for the protocol in zboot.
Quoted 79 lines
--- arch/x86/include/asm/efi.h | 7 +++++++ drivers/firmware/efi/libstub/efistub.h | 22 ++++++++++++++++++++++ include/linux/efi.h | 1 + 3 files changed, 30 insertions(+)arch/x86/include/asm/efi.h +7
-0@@ -325,6 +325,13 @@ static inline u32 efi64_convert_status(efi_status_t status)#define __efi64_argmap_set_memory_space_attributes (phys, size, flags) \ (__efi64_split(phys), __efi64_split(size), __efi64_split(flags)) +/* Memory Attribute Protocol */ +#define __efi64_argmap_set_memory_attributes (protocol, phys, size, flags) \ + ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) + +#define __efi64_argmap_clear_memory_attributes (protocol, phys, size, flags) \ + ((protocol), __efi64_split(phys), __efi64_split(size), __efi64_split(flags)) +/* * The macros below handle the plumbing for the argument mapping. To add a * mapping for a specific EFI method, simply define a macro drivers/firmware/efi/libstub/efistub.h +22
-0@@ -39,6 +39,9 @@ extern const efi_system_table_t *efi_system_table;typedef union efi_dxe_services_table efi_dxe_services_table_t ;extern const efi_dxe_services_table_t *efi_dxe_table; +typedef union efi_memory_attribute_protocol efi_memory_attribute_protocol_t ; +extern efi_memory_attribute_protocol_t *efi_mem_attrib_proto; + efi_status_t __efiapi efi_pe_entry(efi_handle_t handle,efi_system_table_t *sys_table_arg);@@ -415,6 +418,25 @@ union efi_dxe_services_table { } mixed_mode; }; +union efi_memory_attribute_protocol { +struct { +void *get_memory_attributes; + efi_status_t (__efiapi *set_memory_attributes)(efi_memory_attribute_protocol_t *, + efi_physical_addr_t, + u64, + u64); + efi_status_t (__efiapi *clear_memory_attributes)(efi_memory_attribute_protocol_t *, + efi_physical_addr_t, + u64, + u64); + }; +struct { +u32 get_memory_attributes; +u32 set_memory_attributes; +u32 clear_memory_attributes; + } mixed_mode; +}; +typedef union efi_uga_draw_protocol efi_uga_draw_protocol_t ;union efi_uga_draw_protocol {include/linux/efi.h +1
-1@@ -390,6 +390,7 @@ void efi_native_runtime_setup(void);#define EFI_RT_PROPERTIES_TABLE_GUID EFI_GUID(0xeb66918a, 0x7eef, 0x402a, 0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)#define EFI_DXE_SERVICES_TABLE_GUID EFI_GUID(0x05ad34ba, 0x6f02, 0x4214, 0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9)#define EFI_SMBIOS_PROTOCOL_GUID EFI_GUID(0x03583ff6, 0xcb36, 0x4940, 0x94, 0x7e, 0xb9, 0xb3, 0x9f, 0x4a, 0xfa, 0xf7) +#define EFI_MEMORY_ATTRIBUTE_PROTOCOL_GUID EFI_GUID(0xf4560cf6, 0x40ec, 0x4b4a, 0xa1, 0x92, 0xbf, 0x1d, 0x57, 0xd0, 0xb1, 0x89)#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) --2.37.4
Re: [PATCH v3 22/24] efi/libstub: Add memory attribute protocol definitions
Quoted 8 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov
EFI_MEMORY_ATTRIBUTE_PROTOCOLservers as a better alternative to DXE services for setting memory attributes in EFI Boot Services environment. This protocol is better since it is a part of UEFI specification itself and not UEFI PI specification like DXE services.
Quoted 9 lines
Quoted 5 lines
Add
EFI_MEMORY_ATTRIBUTE_PROTOCOLdefinitions.
Support mixed mode properly for its calls.Tested-by Mario Limonciello <[email protected]>Signed-off-by Evgeniy Baskov <[email protected]>I have fixed up just this patch, as there is another user for the protocol in zboot.
One patch less in the patch set then, thanks!
Ard Biesheuvel
maintainerRe: [PATCH v3 22/24] efi/libstub: Add memory attribute protocol definitions
Quoted 13 lines · Evgeniy Baskov
Quoted 11 lines · Ard Biesheuvel
Quoted 10 lines · Evgeniy Baskov
EFI_MEMORY_ATTRIBUTE_PROTOCOLservers as a better alternative to DXE services for setting memory attributes in EFI Boot Services environment. This protocol is better since it is a part of UEFI specification itself and not UEFI PI specification like DXE services.Add
EFI_MEMORY_ATTRIBUTE_PROTOCOLdefinitions.
Support mixed mode properly for its calls.
Quoted 8 lines
Quoted 6 lines
Quoted 2 lines
Tested-by Mario Limonciello <[email protected]>Signed-off-by Evgeniy Baskov <[email protected]>I have fixed up just this patch, as there is another user for the protocol in zboot.
One patch less in the patch set then, thanks!
I meant queued up not fixed up, but you get my point :-)