Skip to contentSkip to conversation

x86_64: Improvements at compressed kernel stage

PATCH Superseded Evgeniy Baskov 3 participants 78 messages Dec 15, 2022 – Mar 13, 2023 Page 1 of 2

Subsystems (3)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore
#1 lore raw

PATCH v4 1/26 x86/boot: Align vmlinuz sections on page size

In reply to Evgeniy Baskov

To 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
index 112b2375d021..6be90f1a1198 100644
@@ -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
#8 lore raw

PATCH v4 3/26 x86/boot: Set cr0 to known state in trampoline

In reply to Evgeniy Baskov

Ensure 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
index a75712991df3..9f2e8f50fc71 100644
@@ -660,9 +660,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
#5 lore raw

PATCH v4 2/26 x86/build: Remove RWX sections and align on 4KB

In reply to Evgeniy Baskov

Avoid 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
index 2e0ee14229bf..2e56d694c491 100644
@@ -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);          /* ___ */
 }
 
@@ -227,9 +226,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
@@ -241,6 +241,7 @@ SECTIONS
 	.altinstr_aux : AT(ADDR(.altinstr_aux) - LOAD_OFFSET) {
 		*(.altinstr_aux)
 	}
+	:init
 
 	INIT_DATA_SECTION(16)
 
Signature · 1 line
2.37.4
#10 lore raw

PATCH v4 4/26 x86/boot: Increase boot page table size

In reply to Evgeniy Baskov

Previous 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
index 9191280d9ea3..024d972c248e 100644
@@ -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
#0 lore raw

v4 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.

Changes in v4:
* Add one missing identity mapping.
* Include following patches improving the use of DXE services:
- efi/x86: don't try to set page attributes on 0-sized regions.
- efi/x86: don't set unsupported memory attributes

Patch "x86/boot: Support 4KB pages for identity mapping" needs review from x86/mm team.

I have also included Peter's patches [6-8] 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
[7] https://lkml.org/lkml/2022/12/13/840
[8] https://lkml.org/lkml/2022/12/13/841

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 (3):
efi/libstub: make memory protection warnings include newlines. efi/x86: don't try to set page attributes on 0-sized regions. efi/x86: don't set unsupported memory attributes

 arch/x86/boot/Makefile                        |   2 +-
 arch/x86/boot/compressed/Makefile             |   8 +-
 arch/x86/boot/compressed/acpi.c               |  25 +-
 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            | 194 ++++++
 .../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, 1860 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
#18 lore raw

PATCH v4 7/26 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
index 1acff356d97a..4dcab38f5a38 100644
@@ -112,11 +112,17 @@ vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o
 vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_mixed.o
 vmlinux-objs-$(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) 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
#21 lore raw

PATCH v4 8/26 x86/boot: Map memory explicitly

In reply to Evgeniy Baskov

Implicit 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  | 25 ++++++++++++++++++++++++-
 arch/x86/boot/compressed/efi.c   | 19 ++++++++++++++++++-
 arch/x86/boot/compressed/kaslr.c |  4 ++++
 3 files changed, 46 insertions(+), 2 deletions(-)
arch/x86/boot/compressed/acpi.c +24 -1
index 9caf89063e77..c775e01fc7db 100644
@@ -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)) &&
@@ -231,10 +239,17 @@ static unsigned long get_acpi_srat_table(void)
 		return 0;
 
 	header = (struct acpi_table_header *)root_table;
+
+	kernel_add_identity_map((unsigned long)header,
+				(unsigned long)(header + 1), 0);
+
 	len = header->length;
 	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 +262,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
index 6edd034b0b30..ce70103fbbc0 100644
@@ -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
index 454757fbdfe5..c0ee116c4fa2 100644
@@ -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
#12 lore raw

PATCH v4 5/26 x86/boot: Support 4KB pages for identity mapping

In reply to Evgeniy Baskov

Current 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
index 5f1d3c421f68..a8277ee82c51 100644
@@ -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
#15 lore raw

PATCH v4 6/26 x86/boot: Setup memory protection for bzImage code

In reply to Evgeniy Baskov

Use 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
index 9f2e8f50fc71..8b9c4fe17126 100644
@@ -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>
 
 /*
  * Fix alignment at 16 bytes. Following CONFIG_FUNCTION_ALIGNMENT will result
@@ -554,6 +555,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
@@ -578,6 +580,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
index 62208ec04ca4..033db9b536e6 100644
@@ -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
deleted file mode 100644
index cc9b2529a086..000000000000
@@ -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
index 2ac12ff4111b..c7cf5a1059a8 100644
@@ -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
index c93930d5ccbd..99f3ad0b30f3 100644
@@ -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
new file mode 100644
index 000000000000..6527dadf39d6
@@ -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
#25 lore raw

PATCH v4 9/26 x86/boot: Remove mapping from page fault handler

In reply to Evgeniy Baskov

After 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
index fec795a4ce23..ba5108c58a4e 100644
@@ -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
#27 lore raw

PATCH v4 10/26 efi/libstub: Move helper function to related file

In reply to Evgeniy Baskov

efi_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
index 5b8f2c411ed8..c55325f829e7 100644
@@ -975,6 +975,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
#28 lore raw

PATCH v4 11/26 x86/boot: Make console interface more abstract

In reply to Evgeniy Baskov

To 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
index 4dcab38f5a38..4b1524446875 100644
@@ -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
index 033db9b536e6..38d31bec062d 100644
@@ -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
#29 lore raw

PATCH v4 12/26 x86/boot: Make kernel_add_identity_map() a pointer

In reply to Evgeniy Baskov

Convert 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
index ba5108c58a4e..1aee524d3c2b 100644
@@ -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
index aa4a22bc9cf9..c9c235d65d16 100644
@@ -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
index 38d31bec062d..0076b2845b4b 100644
@@ -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
#32 lore raw

PATCH v4 13/26 x86/boot: Split trampoline and pt init code

In reply to Evgeniy Baskov

When 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
index c7cf5a1059a8..1f7169248612 100644
@@ -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
#35 lore raw

PATCH v4 14/26 x86/boot: Add EFI kernel extraction interface

In reply to Evgeniy Baskov

To 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
index 6589ddd4cfaf..ead6007df1e5 100644
@@ -213,8 +213,7 @@ SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
  */
 	.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
index 8b9c4fe17126..2dd8be0583d2 100644
@@ -747,7 +747,7 @@ SYM_DATA_END_LABEL(boot_idt, SYM_L_GLOBAL, boot_idt_end)
  */
 	.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
index 0076b2845b4b..379c4a3ca7dd 100644
@@ -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
new file mode 100644
index 000000000000..46bf56348a86
@@ -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
#36 lore raw

PATCH v4 15/26 efi/x86: Support extracting kernel from libstub

In reply to Evgeniy Baskov

Doing 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.

---
 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
index ead6007df1e5..0be75e5072ae 100644
@@ -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
index 043ca31c114e..f50c2a84a754 100644
@@ -58,6 +58,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
index be8b8c6e8b40..99b81c95344c 100644
@@ -88,7 +88,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.o arm64-stub.o arm64-entry.o smbios.o
-lib-$(CONFIG_X86)		+= x86-stub.o
+lib-$(CONFIG_X86)		+= x86-stub.o x86-extract-direct.o
 lib-$(CONFIG_RISCV)		+= riscv.o riscv-stub.o
 lib-$(CONFIG_LOONGARCH)		+= loongarch.o 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
new file mode 100644
index 000000000000..baecc7c6e602
@@ -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
#43 lore raw

PATCH v4 16/26 x86/boot: Reduce lower limit of physical KASLR

In reply to Evgeniy Baskov

Set 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
index c0ee116c4fa2..74d1327adbba 100644
@@ -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
#44 lore raw

PATCH v4 17/26 x86/boot: Reduce size of the DOS stub

In reply to Evgeniy Baskov

This 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
index 9338c68e7413..9fec80bc504b 100644
@@ -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
@@ -90,10 +89,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
#49 lore raw

PATCH v4 18/26 tools/include: Add simplified version of pe.h

In reply to Evgeniy Baskov

This 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
new file mode 100644
index 000000000000..41c09ec371d8
@@ -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
#64 lore raw

PATCH v4 21/26 efi/x86: Explicitly set sections memory attributes

In reply to Evgeniy Baskov

Explicitly 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
index 1f0a2e7075c3..60697fcd8950 100644
@@ -27,6 +27,12 @@ const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
 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
#51 lore raw

PATCH v4 19/26 x86/build: Cleanup tools/build.c

In reply to Evgeniy Baskov

Use 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
index bd247692b701..fbc5315af032 100644
@@ -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, &section->virtual_size);
 
 			/* section header vma field */
-			put_unaligned_le32(vma, section + 0xc);
+			put_unaligned_le32(vma, &section->virtual_address);
 
 			/* section header 'size of initialised data' field */
-			put_unaligned_le32(datasz, section + 0x10);
+			put_unaligned_le32(datasz, &section->raw_data_size);
 
 			/* section header 'file offset' field */
-			put_unaligned_le32(offset, section + 0x14);
+			put_unaligned_le32(offset, &section->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
@@ -298,7 +399,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
 #endif
 	put_unaligned_le32(addr, &buf[0x264]);
@@ -310,7 +411,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)
@@ -338,20 +439,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);
@@ -367,82 +463,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
@@ -458,45 +571,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
#57 lore raw

PATCH v4 20/26 x86/build: Make generated PE more spec compliant

In reply to Evgeniy Baskov

Currently 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.

[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
index 9e38ffaadb5d..bed78c82238e 100644
@@ -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
index 1d1ab1911fd3..1f0a2e7075c3 100644
@@ -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
#73 lore raw

PATCH v4 24/26 efi/libstub: make memory protection warnings include newlines.

In reply to Evgeniy Baskov

From: 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
index 07d54c88c62e..b31d1975caa2 100644
@@ -297,7 +297,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);
@@ -310,7 +310,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
#69 lore raw

PATCH v4 22/26 efi/libstub: Add memory attribute protocol definitions

In reply to Evgeniy Baskov

EFI_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
index a63154e049d7..cd19b9eca3f6 100644
@@ -335,6 +335,13 @@ static inline u32 efi64_convert_status(efi_status_t status)
 #define __efi64_argmap_open_volume(prot, file) \
 	((prot), efi64_zero_upper(file))
 
+/* 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
index c55325f829e7..cd8a7b089b7d 100644
@@ -43,6 +43,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);
 
@@ -442,6 +445,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
index 4b27519143f5..8a333d993829 100644
@@ -391,6 +391,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
#75 lore raw

PATCH v4 26/26 efi/x86: don't set unsupported memory attributes

In reply to Evgeniy Baskov

From: Peter Jones <[email protected]>

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
index 50a0b649b75a..b86ea2920d5e 100644
@@ -195,6 +195,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.37.4
#74 lore raw

PATCH v4 25/26 efi/x86: don't try to set page attributes on 0-sized regions.

In reply to Evgeniy Baskov

From: Peter Jones <[email protected]>

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
index b31d1975caa2..50a0b649b75a 100644
@@ -249,6 +249,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.37.4
#70 lore raw

PATCH v4 23/26 efi/libstub: Use memory attribute protocol

In reply to Evgeniy Baskov

Add 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
index 3e47e5931f04..07d54c88c62e 100644
@@ -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
@@ -129,66 +132,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;
 		}
 
@@ -230,3 +214,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
index 60697fcd8950..06a62b121521 100644
@@ -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;
 u32 image_offset __section(".data");
 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
#76 lore raw
In reply to Evgeniy Baskov
Quoted 5 lines · Evgeniy Baskov

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.

Hi Evgeniy,

Aside from some minor patch fuzz in patch 6 due to building this in today's Fedora rawhide kernel rather than mainline, this patch set works for me.

Thanks!

Signature · 1 line
        Peter
#77 lore raw
Quoted 7 lines · Peter Jones
Quoted 5 lines · Evgeniy Baskov

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.

Quoted 7 lines

Hi Evgeniy,

Aside from some minor patch fuzz in patch 6 due to building this in today's Fedora rawhide kernel rather than mainline, this patch set works for me.

Thanks!

Nice to hear that, thank you for testing again!

maintainer
#11 lore raw

Re: [PATCH v4 04/26] x86/boot: Increase boot page table size

In reply to Evgeniy Baskov
Quoted 35 lines · Evgeniy Baskov

Previous 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 +3 -4
index 9191280d9ea3..024d972c248e 100644
@@ -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.

arch/x86/include/asm/boot.h line 59

Quoted 10 lines
arch/x86/include/asm/boot.h +10 -0
+ *     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.

So you are rounding up 36 to 64 to account for these pages, right?

So we should either drop the FIXME and explain that this is fine, or fix it - we cannot merge it like this.

Thanks,
Ard.

Quoted 16 lines
arch/x86/include/asm/boot.h +1 -9
  */
-#  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
--

2.37.4

maintainer
#19 lore raw

Re: [PATCH v4 07/26] x86/build: Check W^X of vmlinux during build

In reply to Evgeniy Baskov
Quoted 22 lines · Evgeniy Baskov

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 +1 -0
index 1acff356d97a..4dcab38f5a38 100644
@@ -112,11 +112,17 @@ vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o
 vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_mixed.o
 vmlinux-objs-$(CONFIG_EFI_STUB) += $(objtree)/drivers/firmware/efi/libstub/lib.a
 
+quiet_cmd_wx_check = WXCHK   $<

arch/x86/boot/compressed/Makefile vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o · line 125

Quoted 10 lines
arch/x86/boot/compressed/Makefile +5 -0
+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) FORCE
        $(call if_changed,ld)
 
 OBJCOPYFLAGS_vmlinux.bin :=  -R .comment -S
 $(obj)/vmlinux.bin: vmlinux FORCE
+       $(call cmd,wx_check)

This breaks the way we track dependencies between make targets: the FORCE will result in the check being performed every time, even if nothing gets rebuilt.

Better to do something like the below (apologies for the alphabet soup)

arch/x86/boot/compressed/Makefile +0 -0
@@ -112,18 +112,17 @@ vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o
 vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_mixed.o
 vmlinux-objs-$(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
+quiet_cmd_objcopy_and_wx_check = $(quiet_cmd_objcopy)
+ cmd_objcopy_and_wx_check = if $(OBJDUMP) -p $< | grep "flags
.wx" > /dev/null; then \
+ (echo >&2 "$<: Simultaneously
writable and executable sections are prohibited"; \
+ /bin/false); else $(cmd_objcopy); fi

$(obj)/vmlinux: $(vmlinux-objs-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)
+       $(call if_changed,objcopy_and_wx_check)
maintainer
#22 lore raw

Re: [PATCH v4 08/26] x86/boot: Map memory explicitly

In reply to Evgeniy Baskov
Quoted 7 lines · Evgeniy Baskov

Implicit 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.

I agree with the motivation but this patch seems to break the boot under SeaBIOS/QEMU, and I imagine other legacy BIOS boot scenarios as well.

Naively, I would assume that there is simply a legacy BIOS region that we fail to map here, but I am fairly clueless when it comes to non-EFI x86 boot so take this with a grain of salt.

Quoted 157 lines
---
 arch/x86/boot/compressed/acpi.c  | 25 ++++++++++++++++++++++++-
 arch/x86/boot/compressed/efi.c   | 19 ++++++++++++++++++-
 arch/x86/boot/compressed/kaslr.c |  4 ++++
 3 files changed, 46 insertions(+), 2 deletions(-)
arch/x86/boot/compressed/acpi.c +24 -1
index 9caf89063e77..c775e01fc7db 100644
@@ -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)) &&
@@ -231,10 +239,17 @@ static unsigned long get_acpi_srat_table(void)
                return 0;
 
        header = (struct acpi_table_header *)root_table;
+
+       kernel_add_identity_map((unsigned long)header,
+                               (unsigned long)(header + 1), 0);
+
        len = header->length;
        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 +262,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
index 6edd034b0b30..ce70103fbbc0 100644
@@ -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 -1
index 454757fbdfe5..c0ee116c4fa2 100644
@@ -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);
--

2.37.4

maintainer
#13 lore raw

Re: [PATCH v4 05/26] x86/boot: Support 4KB pages for identity mapping

In reply to Evgeniy Baskov
Quoted 11 lines · Evgeniy Baskov

Current 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.

This patch triggers an error reported by the build bots:

arch/x86/mm/ident_map.c:19:8: warning: no previous prototype for 'ident_split_large_pmd'

Quoted 295 lines
---
 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
index 5f1d3c421f68..a8277ee82c51 100644
@@ -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 -33
index 968d7005f4a7..662e794a325d 100644
@@ -4,24 +4,127 @@
  * included by both the compressed kernel and the regular kernel.
  */
 
-static void ident_pmd_init(struct x86_mapping_info *info, pmd_t *pmd_page,
-                          unsigned long addr, unsigned long end)
+static void ident_pte_init(struct x86_mapping_info *info, pte_t *pte_page,
+                          unsigned long addr, unsigned long end,
+                          unsigned long flags)
 {
-       addr &= PMD_MASK;
-       for (; addr < end; addr += PMD_SIZE) {
+       addr &= PAGE_MASK;
+       for (; addr < end; addr += PAGE_SIZE) {
+               pte_t *pte = pte_page + pte_index(addr);
+
+               set_pte(pte, __pte((addr - info->offset) | flags));
+       }
+}
+
+pte_t *ident_split_large_pmd(struct x86_mapping_info *info,
+                            pmd_t *pmdp, unsigned long page_addr)
+{
+       unsigned long pmd_addr, page_flags;
+       pte_t *pte;
+
+       pte = (pte_t *)info->alloc_pgt_page(info->context);
+       if (!pte)
+               return NULL;
+
+       pmd_addr = page_addr & PMD_MASK;
+
+       /* Not a large page - clear PSE flag */
+       page_flags = pmd_flags(*pmdp) & ~_PSE;
+       ident_pte_init(info, pte, pmd_addr, pmd_addr + PMD_SIZE, page_flags);
+
+       return pte;
+}
+
+static int ident_pmd_init(struct x86_mapping_info *info, pmd_t *pmd_page,
+                         unsigned long addr, unsigned long end,
+                         unsigned long flags)
+{
+       unsigned long next;
+       bool new_table = 0;
+
+       for (; addr < end; addr = next) {
                pmd_t *pmd = pmd_page + pmd_index(addr);
+               pte_t *pte;
 
-               if (pmd_present(*pmd))
+               next = (addr & PMD_MASK) + PMD_SIZE;
+               if (next > end)
+                       next = end;
+
+               /*
+                * Use 2M pages if 4k pages are not allowed or
+                * we are not mapping extra, i.e. address and size are aligned.
+                */
+
+               if (!info->allow_4kpages ||
+                   (!(addr & ~PMD_MASK) && next == addr + PMD_SIZE)) {
+
+                       pmd_t pmdval;
+
+                       addr &= PMD_MASK;
+                       pmdval = __pmd((addr - info->offset) | flags | _PSE);
+                       set_pmd(pmd, pmdval);
                        continue;
+               }
+
+               /*
+                * If currently mapped page is large, we need to split it.
+                * The case when we don't can remap 2M page to 2M page
+                * with different flags is already covered above.
+                *
+                * If there's nothing mapped to desired address,
+                * we need to allocate new page table.
+                */
 
-               set_pmd(pmd, __pmd((addr - info->offset) | info->page_flag));
+               if (pmd_large(*pmd)) {
+                       pte = ident_split_large_pmd(info, pmd, addr);
+                       new_table = 1;
+               } else if (!pmd_present(*pmd)) {
+                       pte = (pte_t *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
+                       pte = pte_offset_kernel(pmd, 0);
+                       new_table = 0;
+               }
+
+               if (!pte)
+                       return -ENOMEM;
+
+               ident_pte_init(info, pte, addr, next, flags);
+
+               if (new_table)
+                       set_pmd(pmd, __pmd(__pa(pte) | info->kernpg_flag));
        }
+
+       return 0;
 }
 
+
+pmd_t *ident_split_large_pud(struct x86_mapping_info *info,
+                            pud_t *pudp, unsigned long page_addr)
+{
+       unsigned long pud_addr, page_flags;
+       pmd_t *pmd;
+
+       pmd = (pmd_t *)info->alloc_pgt_page(info->context);
+       if (!pmd)
+               return NULL;
+
+       pud_addr = page_addr & PUD_MASK;
+
+       /* Not a large page - clear PSE flag */
+       page_flags = pud_flags(*pudp) & ~_PSE;
+       ident_pmd_init(info, pmd, pud_addr, pud_addr + PUD_SIZE, page_flags);
+
+       return pmd;
+}
+
+
 static int ident_pud_init(struct x86_mapping_info *info, pud_t *pud_page,
                          unsigned long addr, unsigned long end)
 {
        unsigned long next;
+       bool new_table = 0;
+       int result;
 
        for (; addr < end; addr = next) {
                pud_t *pud = pud_page + pud_index(addr);
@@ -31,28 +134,39 @@ static int ident_pud_init(struct x86_mapping_info *info, pud_t *pud_page,
                if (next > end)
                        next = end;
 
+               /* Use 1G pages only if forced, even if they are supported. */
                if (info->direct_gbpages) {
                        pud_t pudval;
-
-                       if (pud_present(*pud))
-                               continue;
+                       unsigned long flags;
 
                        addr &= PUD_MASK;
-                       pudval = __pud((addr - info->offset) | info->page_flag);
+                       flags = info->page_flag | _PSE;
+                       pudval = __pud((addr - info->offset) | flags);
+
                        set_pud(pud, pudval);
                        continue;
                }
 
-               if (pud_present(*pud)) {
+               if (pud_large(*pud)) {
+                       pmd = ident_split_large_pud(info, pud, addr);
+                       new_table = 1;
+               } else if (!pud_present(*pud)) {
+                       pmd = (pmd_t *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
                        pmd = pmd_offset(pud, 0);
-                       ident_pmd_init(info, pmd, addr, next);
-                       continue;
+                       new_table = 0;
                }
-               pmd = (pmd_t *)info->alloc_pgt_page(info->context);
+
                if (!pmd)
                        return -ENOMEM;
-               ident_pmd_init(info, pmd, addr, next);
-               set_pud(pud, __pud(__pa(pmd) | info->kernpg_flag));
+
+               result = ident_pmd_init(info, pmd, addr, next, info->page_flag);
+               if (result)
+                       return result;
+
+               if (new_table)
+                       set_pud(pud, __pud(__pa(pmd) | info->kernpg_flag));
        }
 
        return 0;
@@ -63,6 +177,7 @@ static int ident_p4d_init(struct x86_mapping_info *info, p4d_t *p4d_page,
 {
        unsigned long next;
        int result;
+       bool new_table = 0;
 
        for (; addr < end; addr = next) {
                p4d_t *p4d = p4d_page + p4d_index(addr);
@@ -72,15 +187,14 @@ static int ident_p4d_init(struct x86_mapping_info *info, p4d_t *p4d_page,
                if (next > end)
                        next = end;
 
-               if (p4d_present(*p4d)) {
+               if (!p4d_present(*p4d)) {
+                       pud = (pud_t *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
                        pud = pud_offset(p4d, 0);
-                       result = ident_pud_init(info, pud, addr, next);
-                       if (result)
-                               return result;
-
-                       continue;
+                       new_table = 0;
                }
-               pud = (pud_t *)info->alloc_pgt_page(info->context);
+
                if (!pud)
                        return -ENOMEM;
 
@@ -88,19 +202,22 @@ static int ident_p4d_init(struct x86_mapping_info *info, p4d_t *p4d_page,
                if (result)
                        return result;
 
-               set_p4d(p4d, __p4d(__pa(pud) | info->kernpg_flag));
+               if (new_table)
+                       set_p4d(p4d, __p4d(__pa(pud) | info->kernpg_flag));
        }
 
        return 0;
 }
 
-int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page,
-                             unsigned long pstart, unsigned long pend)
+int kernel_ident_mapping_init(struct x86_mapping_info *info,
+                             pgd_t *pgd_page, unsigned long pstart,
+                             unsigned long pend)
 {
        unsigned long addr = pstart + info->offset;
        unsigned long end = pend + info->offset;
        unsigned long next;
        int result;
+       bool new_table;
 
        /* Set the default pagetable flags if not supplied */
        if (!info->kernpg_flag)
@@ -117,20 +234,24 @@ int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t *pgd_page,
                if (next > end)
                        next = end;
 
-               if (pgd_present(*pgd)) {
+               if (!pgd_present(*pgd)) {
+                       p4d = (p4d_t *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
                        p4d = p4d_offset(pgd, 0);
-                       result = ident_p4d_init(info, p4d, addr, next);
-                       if (result)
-                               return result;
-                       continue;
+                       new_table = 0;
                }
 
-               p4d = (p4d_t *)info->alloc_pgt_page(info->context);
                if (!p4d)
                        return -ENOMEM;
+
                result = ident_p4d_init(info, p4d, addr, next);
                if (result)
                        return result;
+
+               if (!new_table)
+                       continue;
+
                if (pgtable_l5_enabled()) {
                        set_pgd(pgd, __pgd(__pa(p4d) | info->kernpg_flag));
                } else {
--

2.37.4

maintainer
#23 lore raw

Re: [PATCH v4 08/26] x86/boot: Map memory explicitly

In reply to Ard Biesheuvel
Quoted 10 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Implicit 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.

Quoted 8 lines

I agree with the motivation but this patch seems to break the boot under SeaBIOS/QEMU, and I imagine other legacy BIOS boot scenarios as well.

Naively, I would assume that there is simply a legacy BIOS region that we fail to map here, but I am fairly clueless when it comes to non-EFI x86 boot so take this with a grain of salt.

The below seems to help - not sure why exactly, but apparently legacy BIOS needs the bootparams struct to be mapped writable?

arch/x86/boot/compressed/kaslr.c +1 -0
@@ -31,6 +31,7 @@
 #include <linux/ctype.h>
 #include <generated/utsversion.h>
 #include <generated/utsrelease.h>
+#include <asm/shared/pgtable.h>
 
 #define _SETUP
 #include <asm/setup.h> /* For COMMAND_LINE_SIZE */
@@ -688,7 +689,7 @@ 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);
+ kernel_add_identity_map((unsigned long)e, (unsigned long)(e +
1), MAP_WRITE);

        signature = (char *)&e->efi_loader_signature;
        if (strncmp(signature, EFI32_LOADER_SIGNATURE, 4) &&
maintainer
#16 lore raw

Re: [PATCH v4 06/26] x86/boot: Setup memory protection for bzImage code

In reply to Evgeniy Baskov
Quoted 10 lines · Evgeniy Baskov

Use 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.

This patch breaks the 'nokaslr' command line option (at least with SeaBIOS) unless I apply the hunk below:

arch/x86/boot/compressed/misc.c +0 -0
@@ -329,7 +329,8 @@ static size_t parse_elf(void *output, unsigned

long output_len,

        handle_relocations(output, output_len, virt_addr);

- if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE))
+ if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE) ||
+ cmdline_find_option_bool("nokaslr"))

                goto skip_protect;

        for (i = 0; i < ehdr.e_phnum; i++) {

@@ -481,8 +482,10 @@ asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,
* If KASLR is disabled input and output regions may overlap.
* In this case we need to map region excutable as well. */
- unsigned long map_flags = MAP_ALLOC | MAP_WRITE |
- (IS_ENABLED(CONFIG_RANDOMIZE_BASE) ? 0 : MAP_EXEC);
+ unsigned long map_flags = MAP_ALLOC | MAP_WRITE;
+ if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE) ||
+ cmdline_find_option_bool("nokaslr"))
+ map_flags |= MAP_EXEC;
phys_addr = kernel_add_identity_map(phys_addr,
phys_addr + needed_size, map_flags);

#20 lore raw

Re: [PATCH v4 07/26] x86/build: Check W^X of vmlinux during build

In reply to Ard Biesheuvel
Quoted 68 lines · Ard Biesheuvel
Quoted 26 lines · Evgeniy Baskov

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 +0 -0
index 1acff356d97a..4dcab38f5a38 100644
@@ -112,11 +112,17 @@ vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o
 vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_mixed.o
 vmlinux-objs-$(CONFIG_EFI_STUB) += 

$(objtree)/drivers/firmware/efi/libstub/lib.a

arch/x86/boot/compressed/Makefile +3 -0
+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"; \

arch/x86/boot/compressed/Makefile

Quoted 8 lines
arch/x86/boot/compressed/Makefile +3 -0
+                    /bin/false); fi
+
 $(obj)/vmlinux: $(vmlinux-objs-y) FORCE
        $(call if_changed,ld)
 
 OBJCOPYFLAGS_vmlinux.bin :=  -R .comment -S
 $(obj)/vmlinux.bin: vmlinux FORCE
+       $(call cmd,wx_check)

This breaks the way we track dependencies between make targets: the FORCE will result in the check being performed every time, even if nothing gets rebuilt.

Better to do something like the below (apologies for the alphabet soup)

arch/x86/boot/compressed/Makefile +0 -0
@@ -112,18 +112,17 @@ vmlinux-objs-$(CONFIG_EFI) += $(obj)/efi.o
 vmlinux-objs-$(CONFIG_EFI_MIXED) += $(obj)/efi_mixed.o
 vmlinux-objs-$(CONFIG_EFI_STUB) +=

$(objtree)/drivers/firmware/efi/libstub/lib.a

arch/x86/boot/compressed/Makefile +0 -3
-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"; \

arch/x86/boot/compressed/Makefile +2 -1
-                    /bin/false); fi
+quiet_cmd_objcopy_and_wx_check = $(quiet_cmd_objcopy)
+      cmd_objcopy_and_wx_check = if $(OBJDUMP) -p $< | grep "flags

.wx" > /dev/null; then \
+ (echo >&2 "$<: Simultaneously
writable and executable sections are prohibited"; \
+ /bin/false); else
$(cmd_objcopy); fi

$(obj)/vmlinux: $(vmlinux-objs-y) FORCE

        $(call if_changed,ld)

OBJCOPYFLAGS_vmlinux.bin := -R .comment -S
$(obj)/vmlinux.bin: vmlinux FORCE

arch/x86/boot/compressed/Makefile

Quoted 3 lines
arch/x86/boot/compressed/Makefile +1 -2
-       $(call cmd,wx_check)
-       $(call if_changed,objcopy)
+       $(call if_changed,objcopy_and_wx_check)

Thank you for suggestion! I will fix it.

#24 lore raw

Re: [PATCH v4 08/26] x86/boot: Map memory explicitly

In reply to Ard Biesheuvel
Quoted 15 lines · Ard Biesheuvel
Quoted 14 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Implicit 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.

I agree with the motivation but this patch seems to break the boot under SeaBIOS/QEMU, and I imagine other legacy BIOS boot scenarios as well.

Quoted 7 lines
Quoted 4 lines

Naively, I would assume that there is simply a legacy BIOS region that we fail to map here, but I am fairly clueless when it comes to non-EFI x86 boot so take this with a grain of salt.

The below seems to help - not sure why exactly, but apparently legacy BIOS needs the bootparams struct to be mapped writable?

I think I got too eager adding mappings to everything.
In the process_efi_entries() bootparams should already be mapped, so I will just remove the call. And AFAIK bootparams is indeed gets written to.

Quoted 21 lines
arch/x86/boot/compressed/kaslr.c +2 -1
@@ -31,6 +31,7 @@
 #include <linux/ctype.h>
 #include <generated/utsversion.h>
 #include <generated/utsrelease.h>
+#include <asm/shared/pgtable.h>
 
 #define _SETUP
 #include <asm/setup.h> /* For COMMAND_LINE_SIZE */
@@ -688,7 +689,7 @@ 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);
+       kernel_add_identity_map((unsigned long)e, (unsigned long)(e +
 1), MAP_WRITE);
Quoted 2 lines
        signature = (char *)&e->efi_loader_signature;
        if (strncmp(signature, EFI32_LOADER_SIGNATURE, 4) &&

Thanks,
Evgeniy Baskov

#14 lore raw

Re: [PATCH v4 05/26] x86/boot: Support 4KB pages for identity mapping

In reply to Ard Biesheuvel
Quoted 9 lines · Ard Biesheuvel
Quoted 8 lines · Evgeniy Baskov

Current 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.

Quoted 8 lines
Quoted 3 lines

This patch triggers an error reported by the build bots:

arch/x86/mm/ident_map.c:19:8: warning: no previous prototype for 'ident_split_large_pmd'

Thanks! I'll fix them (and all of the others from the bot emails)

Quoted 333 lines
Quoted 333 lines

---
 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 +0 -0
index 5f1d3c421f68..a8277ee82c51 100644
@@ -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 +46 -5
index 968d7005f4a7..662e794a325d 100644
@@ -4,24 +4,127 @@
  * included by both the compressed kernel and the regular kernel.
  */
 
-static void ident_pmd_init(struct x86_mapping_info *info, pmd_t 
 *pmd_page,
-                          unsigned long addr, unsigned long end)
+static void ident_pte_init(struct x86_mapping_info *info, pte_t 
 *pte_page,
+                          unsigned long addr, unsigned long end,
+                          unsigned long flags)
 {
-       addr &= PMD_MASK;
-       for (; addr < end; addr += PMD_SIZE) {
+       addr &= PAGE_MASK;
+       for (; addr < end; addr += PAGE_SIZE) {
+               pte_t *pte = pte_page + pte_index(addr);
+
+               set_pte(pte, __pte((addr - info->offset) | flags));
+       }
+}
+
+pte_t *ident_split_large_pmd(struct x86_mapping_info *info,
+                            pmd_t *pmdp, unsigned long page_addr)
+{
+       unsigned long pmd_addr, page_flags;
+       pte_t *pte;
+
+       pte = (pte_t *)info->alloc_pgt_page(info->context);
+       if (!pte)
+               return NULL;
+
+       pmd_addr = page_addr & PMD_MASK;
+
+       /* Not a large page - clear PSE flag */
+       page_flags = pmd_flags(*pmdp) & ~_PSE;
+       ident_pte_init(info, pte, pmd_addr, pmd_addr + PMD_SIZE, 
 page_flags);
+
+       return pte;
+}
+
+static int ident_pmd_init(struct x86_mapping_info *info, pmd_t 
 *pmd_page,
+                         unsigned long addr, unsigned long end,
+                         unsigned long flags)
+{
+       unsigned long next;
+       bool new_table = 0;
+
+       for (; addr < end; addr = next) {
                pmd_t *pmd = pmd_page + pmd_index(addr);
+               pte_t *pte;
 
-               if (pmd_present(*pmd))
+               next = (addr & PMD_MASK) + PMD_SIZE;
+               if (next > end)
+                       next = end;
+
+               /*
+                * Use 2M pages if 4k pages are not allowed or
+                * we are not mapping extra, i.e. address and size are 

aligned.

arch/x86/mm/ident_map.c +4 -0
+                */
+
+               if (!info->allow_4kpages ||
+                   (!(addr & ~PMD_MASK) && next == addr + PMD_SIZE)) 

{

arch/x86/mm/ident_map.c +5 -0
+
+                       pmd_t pmdval;
+
+                       addr &= PMD_MASK;
+                       pmdval = __pmd((addr - info->offset) | flags | 

_PSE);

arch/x86/mm/ident_map.c +5 -0
+                       set_pmd(pmd, pmdval);
                        continue;
+               }
+
+               /*
+                * If currently mapped page is large, we need to split 

it.

arch/x86/mm/ident_map.c +6 -1
+                * The case when we don't can remap 2M page to 2M page
+                * with different flags is already covered above.
+                *
+                * If there's nothing mapped to desired address,
+                * we need to allocate new page table.
+                */
 
-               set_pmd(pmd, __pmd((addr - info->offset) | 

info->page_flag));

arch/x86/mm/ident_map.c +5 -0
+               if (pmd_large(*pmd)) {
+                       pte = ident_split_large_pmd(info, pmd, addr);
+                       new_table = 1;
+               } else if (!pmd_present(*pmd)) {
+                       pte = (pte_t 

*)info->alloc_pgt_page(info->context);

arch/x86/mm/ident_map.c +13 -0
+                       new_table = 1;
+               } else {
+                       pte = pte_offset_kernel(pmd, 0);
+                       new_table = 0;
+               }
+
+               if (!pte)
+                       return -ENOMEM;
+
+               ident_pte_init(info, pte, addr, next, flags);
+
+               if (new_table)
+                       set_pmd(pmd, __pmd(__pa(pte) | 
info->kernpg_flag));
        }
arch/x86/mm/ident_map.c +18 -0
+
+       return 0;
 }
 
+
+pmd_t *ident_split_large_pud(struct x86_mapping_info *info,
+                            pud_t *pudp, unsigned long page_addr)
+{
+       unsigned long pud_addr, page_flags;
+       pmd_t *pmd;
+
+       pmd = (pmd_t *)info->alloc_pgt_page(info->context);
+       if (!pmd)
+               return NULL;
+
+       pud_addr = page_addr & PUD_MASK;
+
+       /* Not a large page - clear PSE flag */
+       page_flags = pud_flags(*pudp) & ~_PSE;
+       ident_pmd_init(info, pmd, pud_addr, pud_addr + PUD_SIZE, 

page_flags);

arch/x86/mm/ident_map.c +5 -0
+
+       return pmd;
+}
+
+
 static int ident_pud_init(struct x86_mapping_info *info, pud_t 

*pud_page,
unsigned long addr, unsigned long end)

 {
        unsigned long next;
arch/x86/mm/ident_map.c +3 -0
+       bool new_table = 0;
+       int result;
 
        for (; addr < end; addr = next) {
                pud_t *pud = pud_page + pud_index(addr);
@@ -31,28 +134,39 @@ static int ident_pud_init(struct x86_mapping_info 
 *info, pud_t *pud_page,
                if (next > end)
                        next = end;
 
+               /* Use 1G pages only if forced, even if they are 

supported. */

                if (info->direct_gbpages) {
                        pud_t pudval;
arch/x86/mm/ident_map.c +1 -4
-
-                       if (pud_present(*pud))
-                               continue;
+                       unsigned long flags;
 
                        addr &= PUD_MASK;
-                       pudval = __pud((addr - info->offset) | 

info->page_flag);

arch/x86/mm/ident_map.c +8 -1
+                       flags = info->page_flag | _PSE;
+                       pudval = __pud((addr - info->offset) | flags);
+
                        set_pud(pud, pudval);
                        continue;
                }
 
-               if (pud_present(*pud)) {
+               if (pud_large(*pud)) {
+                       pmd = ident_split_large_pud(info, pud, addr);
+                       new_table = 1;
+               } else if (!pud_present(*pud)) {
+                       pmd = (pmd_t 

*)info->alloc_pgt_page(info->context);

arch/x86/mm/ident_map.c +6 -5
+                       new_table = 1;
+               } else {
                        pmd = pmd_offset(pud, 0);
-                       ident_pmd_init(info, pmd, addr, next);
-                       continue;
+                       new_table = 0;
                }
-               pmd = (pmd_t *)info->alloc_pgt_page(info->context);
+
                if (!pmd)
                        return -ENOMEM;
-               ident_pmd_init(info, pmd, addr, next);
-               set_pud(pud, __pud(__pa(pmd) | info->kernpg_flag));
+
+               result = ident_pmd_init(info, pmd, addr, next, 

info->page_flag);

arch/x86/mm/ident_map.c +5 -0
+               if (result)
+                       return result;
+
+               if (new_table)
+                       set_pud(pud, __pud(__pa(pmd) | 
info->kernpg_flag));
        }

        return 0;
arch/x86/mm/ident_map.c +1 -0
@@ -63,6 +177,7 @@ static int ident_p4d_init(struct x86_mapping_info 
 *info, p4d_t *p4d_page,
 {
        unsigned long next;
        int result;
+       bool new_table = 0;
 
        for (; addr < end; addr = next) {
                p4d_t *p4d = p4d_page + p4d_index(addr);
arch/x86/mm/ident_map.c +6 -7
@@ -72,15 +187,14 @@ static int ident_p4d_init(struct x86_mapping_info 
 *info, p4d_t *p4d_page,
                if (next > end)
                        next = end;
 
-               if (p4d_present(*p4d)) {
+               if (!p4d_present(*p4d)) {
+                       pud = (pud_t 
 *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
                        pud = pud_offset(p4d, 0);
-                       result = ident_pud_init(info, pud, addr, 
 next);
-                       if (result)
-                               return result;
-
-                       continue;
+                       new_table = 0;
                }
-               pud = (pud_t *)info->alloc_pgt_page(info->context);
+
                if (!pud)
                        return -ENOMEM;
arch/x86/mm/ident_map.c +16 -9
@@ -88,19 +202,22 @@ static int ident_p4d_init(struct x86_mapping_info 
 *info, p4d_t *p4d_page,
                if (result)
                        return result;
 
-               set_p4d(p4d, __p4d(__pa(pud) | info->kernpg_flag));
+               if (new_table)
+                       set_p4d(p4d, __p4d(__pa(pud) | 
 info->kernpg_flag));
        }
 
        return 0;
 }
 
-int kernel_ident_mapping_init(struct x86_mapping_info *info, pgd_t 
 *pgd_page,
-                             unsigned long pstart, unsigned long 
 pend)
+int kernel_ident_mapping_init(struct x86_mapping_info *info,
+                             pgd_t *pgd_page, unsigned long pstart,
+                             unsigned long pend)
 {
        unsigned long addr = pstart + info->offset;
        unsigned long end = pend + info->offset;
        unsigned long next;
        int result;
+       bool new_table;
 
        /* Set the default pagetable flags if not supplied */
        if (!info->kernpg_flag)
@@ -117,20 +234,24 @@ int kernel_ident_mapping_init(struct 
 x86_mapping_info *info, pgd_t *pgd_page,
                if (next > end)
                        next = end;
 
-               if (pgd_present(*pgd)) {
+               if (!pgd_present(*pgd)) {
+                       p4d = (p4d_t 
 *)info->alloc_pgt_page(info->context);
+                       new_table = 1;
+               } else {
                        p4d = p4d_offset(pgd, 0);
-                       result = ident_p4d_init(info, p4d, addr, 
 next);
-                       if (result)
-                               return result;
-                       continue;
+                       new_table = 0;
                }
 
-               p4d = (p4d_t *)info->alloc_pgt_page(info->context);
                if (!p4d)
                        return -ENOMEM;
+
                result = ident_p4d_init(info, p4d, addr, next);
                if (result)
                        return result;
+
+               if (!new_table)
+                       continue;
+
                if (pgtable_l5_enabled()) {
                        set_pgd(pgd, __pgd(__pa(p4d) | 
info->kernpg_flag));
                } else {

--
2.37.4

#17 lore raw

Re: [PATCH v4 06/26] x86/boot: Setup memory protection for bzImage code

In reply to Ard Biesheuvel
Quoted 7 lines · Ard Biesheuvel
Quoted 6 lines · Evgeniy Baskov

Use 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.

Quoted 8 lines
Quoted 4 lines

This patch breaks the 'nokaslr' command line option (at least with SeaBIOS) unless I apply the hunk below:

Oh, I didn't think of that option.. Thanks! I will also add the check to the identity mapping, so the warning won't be emitted with 'nokaslr'.

Quoted 29 lines
arch/x86/boot/compressed/misc.c +2 -1
@@ -329,7 +329,8 @@ static size_t parse_elf(void *output, unsigned
 long output_len,
 
        handle_relocations(output, output_len, virt_addr);
 
-       if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE))
+       if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE) ||
+           cmdline_find_option_bool("nokaslr"))
                goto skip_protect;
 
        for (i = 0; i < ehdr.e_phnum; i++) {
arch/x86/boot/compressed/misc.c +4 -2
@@ -481,8 +482,10 @@ asmlinkage __visible void *extract_kernel(void
 *rmode, memptr heap,
         * If KASLR is disabled input and output regions may overlap.
         * In this case we need to map region excutable as well.
         */
-       unsigned long map_flags = MAP_ALLOC | MAP_WRITE |
-                       (IS_ENABLED(CONFIG_RANDOMIZE_BASE) ? 0 : 
 MAP_EXEC);
+       unsigned long map_flags = MAP_ALLOC | MAP_WRITE;
+       if (!IS_ENABLED(CONFIG_RANDOMIZE_BASE) ||
+           cmdline_find_option_bool("nokaslr"))
+               map_flags |= MAP_EXEC;
        phys_addr = kernel_add_identity_map(phys_addr,

phys_addr + needed_size, map_flags);

maintainer
#52 lore raw

Re: [PATCH v4 19/26] x86/build: Cleanup tools/build.c

In reply to Evgeniy Baskov
Quoted 96 lines · Evgeniy Baskov

Use 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 +40 -9
index bd247692b701..fbc5315af032 100644
@@ -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);

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 102

Quoted 10 lines
arch/x86/boot/tools/build.c +10 -0
+       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

Can we drop this conditional?

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 105

Quoted 3 lines
arch/x86/boot/tools/build.c +3 -0
+#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)

Please drop the alignment flags - they don't apply to executable only object files.

Quoted 12 lines
arch/x86/boot/tools/build.c +8 -0
+#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;

arch/x86/boot/tools/build.c static unsigned long _end; · line 125

Quoted 5 lines
arch/x86/boot/tools/build.c +1 -1
@@ -70,7 +122,7 @@ static unsigned long _end;
 
 /*----------------------------------------------------------------------*/
 
-static const u32 crctab32[] = {
+static const uint32_t crctab32[] = {

Replacing all the type names makes this patch very messy. Can we back that out please?

Quoted 482 lines
arch/x86/boot/tools/build.c +183 -133
        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, &section->virtual_size);
 
                        /* section header vma field */
-                       put_unaligned_le32(vma, section + 0xc);
+                       put_unaligned_le32(vma, &section->virtual_address);
 
                        /* section header 'size of initialised data' field */
-                       put_unaligned_le32(datasz, section + 0x10);
+                       put_unaligned_le32(datasz, &section->raw_data_size);
 
                        /* section header 'file offset' field */
-                       put_unaligned_le32(offset, section + 0x14);
+                       put_unaligned_le32(offset, &section->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
@@ -298,7 +399,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
 #endif
        put_unaligned_le32(addr, &buf[0x264]);
@@ -310,7 +411,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)
@@ -338,20 +439,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);
@@ -367,82 +463,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
@@ -458,45 +571,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;
 }
--

2.37.4

maintainer
#37 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

In reply to Evgeniy Baskov
Quoted 28 lines · Evgeniy Baskov

Doing 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.

---
 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 +0 -0
index ead6007df1e5..0be75e5072ae 100644
@@ -152,11 +152,57 @@ SYM_FUNC_END(startup_32)
 

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 162

Quoted 10 lines
arch/x86/boot/compressed/head_32.S +8 -0
 #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.
+ */

Please drop this comment

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 165

Quoted 3 lines
arch/x86/boot/compressed/head_32.S +3 -0
+       call    1f
+1:     popl    %ebx
+       addl    $_GLOBAL_OFFSET_TABLE_+(.-1b), %ebx

Please drop this and ...

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 170

Quoted 5 lines
arch/x86/boot/compressed/head_32.S +5 -0
+
+       /* Clear BSS */
+       xorl    %eax, %eax
+       leal    _bss@GOTOFF(%ebx), %edi
+       leal    _ebss@GOTOFF(%ebx), %ecx

just use (_bss - 1b) here (etc)

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 177

Quoted 7 lines
arch/x86/boot/compressed/head_32.S +5 -0
+       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 */

What does this do?

Quoted 33 lines
arch/x86/boot/compressed/head_32.S +27 -2
        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

...

#53 lore raw

Re: [PATCH v4 19/26] x86/build: Cleanup tools/build.c

In reply to Ard Biesheuvel
Quoted 104 lines · Ard Biesheuvel
Quoted 103 lines · Evgeniy Baskov

Use 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 +44 -9
index bd247692b701..fbc5315af032 100644
@@ -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)
Quoted 8 lines

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 102

Quoted 6 lines
arch/x86/boot/tools/build.c +6 -0
+{
+       pe_opt_hdr *hdr = get_pe_opt_header(buf);
+       return (struct data_directory *)(hdr + 1);
+}
+
+#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES

Can we drop this conditional?

Without CONFIG_EFI_DXE_MEM_ATTRIBUTES memory attributes are not getting applies anywhere, so this would break 'nokaslr' on UEFI implementations that honor section attributes.

KASLR is already broken without that option on implementations that disallow execution of the free memory though. But unlike free memory, sections are more likely to get protected, I think.

Quoted 8 lines
Quoted 5 lines
arch/x86/boot/tools/build.c +2 -0
+#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)

Please drop the alignment flags - they don't apply to executable only object files.

Got it, will remove them in v5.

Quoted 15 lines
Quoted 15 lines
arch/x86/boot/tools/build.c +8 -0
+#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;
 
 
Quoted 7 lines

arch/x86/boot/tools/build.c static unsigned long _end; · line 125

Quoted 4 lines
arch/x86/boot/tools/build.c +1 -1
 /*----------------------------------------------------------------------*/
 
-static const u32 crctab32[] = {
+static const uint32_t crctab32[] = {

Replacing all the type names makes this patch very messy. Can we back that out please?

Ok, I will revert them.

Quoted 531 lines
Quoted 531 lines
arch/x86/boot/tools/build.c +0 -0
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
        0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
        0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
arch/x86/boot/tools/build.c +2 -2
@@ -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);
arch/x86/boot/tools/build.c +62 -13
@@ -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, 
 &section->virtual_size);
 
                        /* section header vma field */
-                       put_unaligned_le32(vma, section + 0xc);
+                       put_unaligned_le32(vma, 
 &section->virtual_address);
 
                        /* section header 'size of initialised data' 

field */

arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(datasz, section + 0x10);
+                       put_unaligned_le32(datasz, 

&section->raw_data_size);

                        /* section header 'file offset' field */
arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(offset, section + 0x14);
+                       put_unaligned_le32(offset, 

&section->data_addr);

                        break;
                }
arch/x86/boot/tools/build.c +1 -2
-               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) {

arch/x86/boot/tools/build.c +0 -2
-       u32 setup_offset = 0x200;
-       u32 reloc_offset = size - PECOFF_RELOC_RESERVE - 

PECOFF_COMPAT_RESERVE;

arch/x86/boot/tools/build.c +2 -0
+       uint32_t setup_offset = SECTOR_SIZE;
+       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE - 

PECOFF_COMPAT_RESERVE;
#ifdef CONFIG_EFI_MIXED

arch/x86/boot/tools/build.c +2 -2
-       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);

arch/x86/boot/tools/build.c +0 -0
@@ -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.

         */
arch/x86/boot/tools/build.c +1 -2
-       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);

arch/x86/boot/tools/build.c +5 -6
@@ -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

arch/x86/boot/tools/build.c +3 -3
@@ -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);
arch/x86/boot/tools/build.c +4 -2
+
+       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
@@ -298,7 +399,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
 #endif
        put_unaligned_le32(addr, &buf[0x264]);
arch/x86/boot/tools/build.c +1 -1
@@ -310,7 +411,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)

arch/x86/boot/tools/build.c +60 -55
@@ -338,20 +439,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);
@@ -367,82 +463,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 */

arch/x86/boot/tools/build.c +4 -6
-       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 */

arch/x86/boot/tools/build.c +4 -0
+       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 

*/

arch/x86/boot/tools/build.c +7 -3
-       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

arch/x86/boot/tools/build.c +21 -32
@@ -458,45 +571,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;
 }
--

2.37.4

maintainer
#39 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

In reply to Evgeniy Baskov
Quoted 10 lines · Evgeniy Baskov

Doing 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.

OK I just realized that there is a problem with this approach: since we now decompress the image while running in the EFI stub (i.e., before ExitBootServices()), we cannot just randomly pick a EFI_CONVENTIONAL_MEMORY region to place the kernel, we need to allocate the pages using the boot services. Otherwise, subsequent allocations (or concurrent ones occurring in the firmware in event handlers etc) may land right in the middle, which is unlikely to be what we want.

Quoted 592 lines
---
 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
index ead6007df1e5..0be75e5072ae 100644
@@ -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
index 2dd8be0583d2..7cfef7bd0424 100644
@@ -529,12 +529,64 @@ SYM_CODE_END(startup_64)
        .org 0x390
 #endif
 SYM_FUNC_START(efi64_stub_entry)
+       /* Preserve first parameter */
+       movq    %rdi, %r10
+
+       /* Clear BSS */
+       xorl    %eax, %eax
+       leaq    _bss(%rip), %rdi
+       leaq    _ebss(%rip), %rcx
+       subq    %rdi, %rcx
+       shrq    $3, %rcx
+       rep     stosq
+
        and     $~0xf, %rsp                     /* realign the stack */
        movq    %rdx, %rbx                      /* save boot_params pointer */
+       movq    %r10, %rdi
        call    efi_main
-       movq    %rbx,%rsi
-       leaq    rva(startup_64)(%rax), %rax
-       jmp     *%rax
+
+       cld
+       cli
+
+       movq    %rbx, %rdi /* boot_params */
+       movq    %rax, %rsi /* decompressed kernel address */
+
+       /* Make sure we have GDT with 32-bit code segment */
+       leaq    gdt64(%rip), %rax
+       addq    %rax, 2(%rax)
+       lgdt    (%rax)
+
+       /* Setup data segments. */
+       xorl    %eax, %eax
+       movl    %eax, %ds
+       movl    %eax, %es
+       movl    %eax, %ss
+       movl    %eax, %fs
+       movl    %eax, %gs
+
+       pushq   %rsi
+       pushq   %rdi
+
+       call    load_stage1_idt
+       call    enable_nx_if_supported
+
+       call    trampoline_pgtable_init
+       movq    %rax, %rdx
+
+
+       /* Swap %rsi and %rsi */
+       popq    %rsi
+       popq    %rdi
+
+       /* Save the trampoline address in RCX */
+       movq    trampoline_32bit(%rip), %rcx
+
+       /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
+       pushq   $__KERNEL32_CS
+       leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rcx), %rax
+       pushq   %rax
+       lretq
+
 SYM_FUNC_END(efi64_stub_entry)
 SYM_FUNC_ALIAS(efi_stub_entry, efi64_stub_entry)
 #endif
drivers/firmware/efi/Kconfig +2 -0
index 043ca31c114e..f50c2a84a754 100644
@@ -58,6 +58,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
index be8b8c6e8b40..99b81c95344c 100644
@@ -88,7 +88,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.o arm64-stub.o arm64-entry.o smbios.o
-lib-$(CONFIG_X86)              += x86-stub.o
+lib-$(CONFIG_X86)              += x86-stub.o x86-extract-direct.o
 lib-$(CONFIG_RISCV)            += riscv.o riscv-stub.o
 lib-$(CONFIG_LOONGARCH)                += loongarch.o loongarch-stub.o
 
drivers/firmware/efi/libstub/x86-extract-direct.c new file +208 -0
new file mode 100644
index 000000000000..4ecbc4a9b3ed
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/acpi.h>
+#include <linux/efi.h>
+#include <linux/elf.h>
+#include <linux/stddef.h>
+
+#include <asm/efi.h>
+#include <asm/e820/types.h>
+#include <asm/desc.h>
+#include <asm/boot.h>
+#include <asm/bootparam_utils.h>
+#include <asm/shared/extract.h>
+#include <asm/shared/pgtable.h>
+
+#include "efistub.h"
+#include "x86-stub.h"
+
+static efi_handle_t image_handle;
+
+static void do_puthex(unsigned long value)
+{
+       efi_printk("%08lx", value);
+}
+
+static void do_putstr(const char *msg)
+{
+       efi_printk("%s", msg);
+}
+
+static unsigned long do_map_range(unsigned long start,
+                                 unsigned long end,
+                                 unsigned int flags)
+{
+       efi_status_t status;
+
+       unsigned long size = end - start;
+
+       if (flags & MAP_ALLOC) {
+               unsigned long addr;
+
+               status = efi_low_alloc_above(size, CONFIG_PHYSICAL_ALIGN,
+                                            &addr, start);
+               if (status != EFI_SUCCESS) {
+                       efi_err("Unable to allocate memory for uncompressed kernel");
+                       efi_exit(image_handle, EFI_OUT_OF_RESOURCES);
+               }
+
+               if (start != addr) {
+                       efi_debug("Unable to allocate at given address"
+                                 " (desired=0x%lx, actual=0x%lx)",
+                                 (unsigned long)start, addr);
+                       start = addr;
+               }
+       }
+
+       if ((flags & (MAP_PROTECT | MAP_ALLOC)) &&
+           IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               unsigned long attr = 0;
+
+               if (!(flags & MAP_EXEC))
+                       attr |= EFI_MEMORY_XP;
+
+               if (!(flags & MAP_WRITE))
+                       attr |= EFI_MEMORY_RO;
+
+               status = efi_adjust_memory_range_protection(start, size, attr);
+               if (status != EFI_SUCCESS)
+                       efi_err("Unable to protect memory range");
+       }
+
+       return start;
+}
+
+/*
+ * Trampoline takes 3 pages and can be loaded in first megabyte of memory
+ * with its end placed between 0 and 640k where BIOS might start.
+ * (see arch/x86/boot/compressed/pgtable_64.c)
+ */
+
+#ifdef CONFIG_64BIT
+static efi_status_t prepare_trampoline(void)
+{
+       efi_status_t status;
+
+       status = efi_allocate_pages(TRAMPOLINE_32BIT_SIZE,
+                                   (unsigned long *)&trampoline_32bit,
+                                   TRAMPOLINE_32BIT_PLACEMENT_MAX);
+
+       if (status != EFI_SUCCESS)
+               return status;
+
+       unsigned long trampoline_start = (unsigned long)trampoline_32bit;
+
+       memset(trampoline_32bit, 0, TRAMPOLINE_32BIT_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               /* First page of trampoline is a top level page table */
+               efi_adjust_memory_range_protection(trampoline_start,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       /* Second page of trampoline is the code (with a padding) */
+
+       void *caddr = (void *)trampoline_32bit + TRAMPOLINE_32BIT_CODE_OFFSET;
+
+       memcpy(caddr, trampoline_32bit_src, TRAMPOLINE_32BIT_CODE_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               efi_adjust_memory_range_protection((unsigned long)caddr,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_RO);
+
+               /* And the last page of trampoline is the stack */
+
+               efi_adjust_memory_range_protection(trampoline_start + 2 * PAGE_SIZE,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       return EFI_SUCCESS;
+}
+#else
+static inline efi_status_t prepare_trampoline(void)
+{
+       return EFI_SUCCESS;
+}
+#endif
+
+static efi_status_t init_loader_data(efi_handle_t handle,
+                                    struct boot_params *params,
+                                    struct efi_boot_memmap **map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+       efi_status_t status;
+
+       status = efi_get_memory_map(map, false);
+
+       if (status != EFI_SUCCESS) {
+               efi_err("Unable to get EFI memory map...\n");
+               return status;
+       }
+
+       const char *signature = efi_is_64bit() ? EFI64_LOADER_SIGNATURE
+                                              : EFI32_LOADER_SIGNATURE;
+
+       memcpy(&efi->efi_loader_signature, signature, sizeof(__u32));
+
+       efi->efi_memdesc_size = (*map)->desc_size;
+       efi->efi_memdesc_version = (*map)->desc_ver;
+       efi->efi_memmap_size = (*map)->map_size;
+
+       efi_set_u64_split((unsigned long)(*map)->map,
+                         &efi->efi_memmap, &efi->efi_memmap_hi);
+
+       efi_set_u64_split((unsigned long)efi_system_table,
+                         &efi->efi_systab, &efi->efi_systab_hi);
+
+       image_handle = handle;
+
+       return EFI_SUCCESS;
+}
+
+static void free_loader_data(struct boot_params *params, struct efi_boot_memmap *map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+
+       efi_bs_call(free_pool, map);
+
+       efi->efi_memdesc_size = 0;
+       efi->efi_memdesc_version = 0;
+       efi->efi_memmap_size = 0;
+       efi_set_u64_split(0, &efi->efi_memmap, &efi->efi_memmap_hi);
+}
+
+extern unsigned char input_data[];
+extern unsigned int input_len, output_len;
+
+unsigned long extract_kernel_direct(efi_handle_t handle, struct boot_params *params)
+{
+
+       void *res;
+       efi_status_t status;
+       struct efi_extract_callbacks cb = { 0 };
+
+       status = prepare_trampoline();
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       /* Prepare environment for do_extract_kernel() call */
+       struct efi_boot_memmap *map = NULL;
+       status = init_loader_data(handle, params, &map);
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       cb.puthex = do_puthex;
+       cb.putstr = do_putstr;
+       cb.map_range = do_map_range;
+
+       res = efi_extract_kernel(params, &cb, input_data, input_len, output_len);
+
+       free_loader_data(params, map);
+
+       return (unsigned long)res;
+}
drivers/firmware/efi/libstub/x86-stub.c +10 -109
index 7fb1eff88a18..1d1ab1911fd3 100644
@@ -17,6 +17,7 @@
 #include <asm/boot.h>
 
 #include "efistub.h"
+#include "x86-stub.h"
 
 /* Maximum physical address for 64-bit kernel with 4-level paging */
 #define MAXMEM_X86_64_4LEVEL (1ull << 46)
@@ -24,7 +25,7 @@
 const efi_system_table_t *efi_system_table;
 const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
-static efi_loaded_image_t *image = NULL;
+static efi_loaded_image_t *image __section(".data");
 
 static efi_status_t
 preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)
@@ -212,55 +213,9 @@ static void retrieve_apple_device_properties(struct boot_params *boot_params)
        }
 }
 
-/*
- * Trampoline takes 2 pages and can be loaded in first megabyte of memory
- * with its end placed between 128k and 640k where BIOS might start.
- * (see arch/x86/boot/compressed/pgtable_64.c)
- *
- * We cannot find exact trampoline placement since memory map
- * can be modified by UEFI, and it can alter the computed address.
- */
-
-#define TRAMPOLINE_PLACEMENT_BASE ((128 - 8)*1024)
-#define TRAMPOLINE_PLACEMENT_SIZE (640*1024 - (128 - 8)*1024)
-
-void startup_32(struct boot_params *boot_params);
-
-static void
-setup_memory_protection(unsigned long image_base, unsigned long image_size)
-{
-       /*
-        * Allow execution of possible trampoline used
-        * for switching between 4- and 5-level page tables
-        * and relocated kernel image.
-        */
-
-       efi_adjust_memory_range_protection(TRAMPOLINE_PLACEMENT_BASE,
-                                          TRAMPOLINE_PLACEMENT_SIZE, 0);
-
-#ifdef CONFIG_64BIT
-       if (image_base != (unsigned long)startup_32)
-               efi_adjust_memory_range_protection(image_base, image_size, 0);
-#else
-       /*
-        * Clear protection flags on a whole range of possible
-        * addresses used for KASLR. We don't need to do that
-        * on x86_64, since KASLR/extraction is performed after
-        * dedicated identity page tables are built and we only
-        * need to remove possible protection on relocated image
-        * itself disregarding further relocations.
-        */
-       efi_adjust_memory_range_protection(LOAD_PHYSICAL_ADDR,
-                                          KERNEL_IMAGE_SIZE - LOAD_PHYSICAL_ADDR,
-                                          0);
-#endif
-}
-
 static const efi_char16_t apple[] = L"Apple";
 
-static void setup_quirks(struct boot_params *boot_params,
-                        unsigned long image_base,
-                        unsigned long image_size)
+static void setup_quirks(struct boot_params *boot_params)
 {
        efi_char16_t *fw_vendor = (efi_char16_t *)(unsigned long)
                efi_table_attr(efi_system_table, fw_vendor);
@@ -269,9 +224,6 @@ static void setup_quirks(struct boot_params *boot_params,
                if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))
                        retrieve_apple_device_properties(boot_params);
        }
-
-       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES))
-               setup_memory_protection(image_base, image_size);
 }
 
 /*
@@ -384,7 +336,7 @@ static void setup_graphics(struct boot_params *boot_params)
 }
 
 
-static void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
+void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
 {
        efi_bs_call(exit, handle, status, 0, NULL);
        for(;;)
@@ -707,8 +659,7 @@ static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)
 }
 
 /*
- * On success, we return the address of startup_32, which has potentially been
- * relocated by efi_relocate_kernel.
+ * On success, we return extracted kernel entry point.
  * On failure, we exit to the firmware via efi_exit instead of returning.
  */
 asmlinkage unsigned long efi_main(efi_handle_t handle,
@@ -733,60 +684,6 @@ asmlinkage unsigned long efi_main(efi_handle_t handle,
                efi_dxe_table = NULL;
        }
 
-       /*
-        * If the kernel isn't already loaded at a suitable address,
-        * relocate it.
-        *
-        * It must be loaded above LOAD_PHYSICAL_ADDR.
-        *
-        * The maximum address for 64-bit is 1 << 46 for 4-level paging. This
-        * is defined as the macro MAXMEM, but unfortunately that is not a
-        * compile-time constant if 5-level paging is configured, so we instead
-        * define our own macro for use here.
-        *
-        * For 32-bit, the maximum address is complicated to figure out, for
-        * now use KERNEL_IMAGE_SIZE, which will be 512MiB, the same as what
-        * KASLR uses.
-        *
-        * Also relocate it if image_offset is zero, i.e. the kernel wasn't
-        * loaded by LoadImage, but rather by a bootloader that called the
-        * handover entry. The reason we must always relocate in this case is
-        * to handle the case of systemd-boot booting a unified kernel image,
-        * which is a PE executable that contains the bzImage and an initrd as
-        * COFF sections. The initrd section is placed after the bzImage
-        * without ensuring that there are at least init_size bytes available
-        * for the bzImage, and thus the compressed kernel's startup code may
-        * overwrite the initrd unless it is moved out of the way.
-        */
-
-       buffer_start = ALIGN(bzimage_addr - image_offset,
-                            hdr->kernel_alignment);
-       buffer_end = buffer_start + hdr->init_size;
-
-       if ((buffer_start < LOAD_PHYSICAL_ADDR)                              ||
-           (IS_ENABLED(CONFIG_X86_32) && buffer_end > KERNEL_IMAGE_SIZE)    ||
-           (IS_ENABLED(CONFIG_X86_64) && buffer_end > MAXMEM_X86_64_4LEVEL) ||
-           (image_offset == 0)) {
-               extern char _bss[];
-
-               status = efi_relocate_kernel(&bzimage_addr,
-                                            (unsigned long)_bss - bzimage_addr,
-                                            hdr->init_size,
-                                            hdr->pref_address,
-                                            hdr->kernel_alignment,
-                                            LOAD_PHYSICAL_ADDR);
-               if (status != EFI_SUCCESS) {
-                       efi_err("efi_relocate_kernel() failed!\n");
-                       goto fail;
-               }
-               /*
-                * Now that we've copied the kernel elsewhere, we no longer
-                * have a set up block before startup_32(), so reset image_offset
-                * to zero in case it was set earlier.
-                */
-               image_offset = 0;
-       }
-
 #ifdef CONFIG_CMDLINE_BOOL
        status = efi_parse_options(CONFIG_CMDLINE);
        if (status != EFI_SUCCESS) {
@@ -843,7 +740,11 @@ asmlinkage unsigned long efi_main(efi_handle_t handle,
 
        setup_efi_pci(boot_params);
 
-       setup_quirks(boot_params, bzimage_addr, buffer_end - buffer_start);
+       setup_quirks(boot_params);
+
+       bzimage_addr = extract_kernel_direct(handle, boot_params);
+       if (!bzimage_addr)
+               goto fail;
 
        status = exit_boot(boot_params, handle);
        if (status != EFI_SUCCESS) {
drivers/firmware/efi/libstub/x86-stub.h new file +14 -1
new file mode 100644
index 000000000000..baecc7c6e602
@@ -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
--

2.37.4

maintainer
#54 lore raw

Re: [PATCH v4 19/26] x86/build: Cleanup tools/build.c

In reply to Evgeniy Baskov
Quoted 115 lines · Evgeniy Baskov
Quoted 104 lines · Ard Biesheuvel
Quoted 103 lines · Evgeniy Baskov

Use 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 +44 -9
index bd247692b701..fbc5315af032 100644
@@ -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)
Quoted 8 lines

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 102

Quoted 6 lines
arch/x86/boot/tools/build.c +6 -0
+{
+       pe_opt_hdr *hdr = get_pe_opt_header(buf);
+       return (struct data_directory *)(hdr + 1);
+}
+
+#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES

Can we drop this conditional?

Quoted 4 lines

Without CONFIG_EFI_DXE_MEM_ATTRIBUTES memory attributes are not getting applies anywhere, so this would break 'nokaslr' on UEFI implementations that honor section attributes.

How so? This only affects the mappings that are created by UEFI for the decompressor binary, right?

Quoted 4 lines

KASLR is already broken without that option on implementations that disallow execution of the free memory though. But unlike free memory, sections are more likely to get protected, I think.

We need to allocate those pages properly in any case (see my other reply) so it is no longer free memory.

Quoted 567 lines
Quoted 8 lines
Quoted 5 lines
arch/x86/boot/tools/build.c +2 -0
+#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)

Please drop the alignment flags - they don't apply to executable only object files.

Got it, will remove them in v5.

Quoted 15 lines
Quoted 15 lines
arch/x86/boot/tools/build.c +8 -0
+#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;
 
 
Quoted 7 lines

arch/x86/boot/tools/build.c static unsigned long _end; · line 125

Quoted 4 lines
arch/x86/boot/tools/build.c +1 -1
 /*----------------------------------------------------------------------*/
 
-static const u32 crctab32[] = {
+static const uint32_t crctab32[] = {

Replacing all the type names makes this patch very messy. Can we back that out please?

Ok, I will revert them.

Quoted 531 lines
Quoted 531 lines
arch/x86/boot/tools/build.c +0 -0
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
        0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
        0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
arch/x86/boot/tools/build.c +2 -2
@@ -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);
arch/x86/boot/tools/build.c +62 -13
@@ -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,
 &section->virtual_size);
 
                        /* section header vma field */
-                       put_unaligned_le32(vma, section + 0xc);
+                       put_unaligned_le32(vma,
 &section->virtual_address);
 
                        /* section header 'size of initialised data'

field */

arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(datasz, section + 0x10);
+                       put_unaligned_le32(datasz,

&section->raw_data_size);

                        /* section header 'file offset' field */
arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(offset, section + 0x14);
+                       put_unaligned_le32(offset,

&section->data_addr);

                        break;
                }
arch/x86/boot/tools/build.c +1 -2
-               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) {

arch/x86/boot/tools/build.c +0 -2
-       u32 setup_offset = 0x200;
-       u32 reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;

arch/x86/boot/tools/build.c +2 -0
+       uint32_t setup_offset = SECTOR_SIZE;
+       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;
#ifdef CONFIG_EFI_MIXED

arch/x86/boot/tools/build.c +2 -2
-       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);

arch/x86/boot/tools/build.c +0 -0
@@ -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.

         */
arch/x86/boot/tools/build.c +1 -2
-       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);

arch/x86/boot/tools/build.c +5 -6
@@ -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

arch/x86/boot/tools/build.c +3 -3
@@ -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);
arch/x86/boot/tools/build.c +4 -2
+
+       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
@@ -298,7 +399,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
 #endif
        put_unaligned_le32(addr, &buf[0x264]);
arch/x86/boot/tools/build.c +1 -1
@@ -310,7 +411,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)

arch/x86/boot/tools/build.c +60 -55
@@ -338,20 +439,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);
@@ -367,82 +463,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 */

arch/x86/boot/tools/build.c +4 -6
-       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 */

arch/x86/boot/tools/build.c +4 -0
+       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

*/

arch/x86/boot/tools/build.c +7 -3
-       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

arch/x86/boot/tools/build.c +21 -32
@@ -458,45 +571,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;
 }
--

2.37.4

#38 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

In reply to Ard Biesheuvel
Quoted 30 lines · Ard Biesheuvel
Quoted 29 lines · Evgeniy Baskov

Doing 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.

---
 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 +0 -0
index ead6007df1e5..0be75e5072ae 100644
@@ -152,11 +152,57 @@ SYM_FUNC_END(startup_32)
 
Quoted 12 lines

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 162

Quoted 10 lines
arch/x86/boot/compressed/head_32.S +8 -0
 #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.
+ */

Please drop this comment

Will do.

Quoted 7 lines

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 165

Quoted 4 lines
arch/x86/boot/compressed/head_32.S +3 -0
+       call    1f
+1:     popl    %ebx
+       addl    $_GLOBAL_OFFSET_TABLE_+(.-1b), %ebx

Please drop this and ...

Quoted 7 lines

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 170

Quoted 5 lines
arch/x86/boot/compressed/head_32.S +5 -0
+
+       /* Clear BSS */
+       xorl    %eax, %eax
+       leal    _bss@GOTOFF(%ebx), %edi
+       leal    _ebss@GOTOFF(%ebx), %ecx

just use (_bss - 1b) here (etc)

I was trying to be consistent with the code below, but it will indeed be better to do this like that. I guess, this will be fine to stop putting GOT address to the %ebx, since the extraction code does not use calls via PLT?

Quoted 10 lines

arch/x86/boot/compressed/head_32.S SYM_FUNC_END(startup_32) · line 177

Quoted 8 lines
arch/x86/boot/compressed/head_32.S +5 -0
+       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 */

What does this do?

Hmm... It seems to be a remnant of the previous implementation that I forgot to remove. I will remove that in the v5.

Quoted 28 lines
Quoted 28 lines
arch/x86/boot/compressed/head_32.S +0 -1
        call    efi_main
-       /* efi_main returns the possibly relocated address of 

startup_32 */

arch/x86/boot/compressed/head_32.S +23 -1
-       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 */
Quoted 8 lines
Quoted 7 lines
arch/x86/boot/compressed/head_32.S +4 -0
+       pushl   $0
+       popfl
+
+       jmp     *%ecx
 SYM_FUNC_END(efi32_stub_entry)
 SYM_FUNC_ALIAS(efi_stub_entry, efi32_stub_entry)
 #endif

...

Thanks,
Evgeniy Baskov

#40 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

In reply to Ard Biesheuvel
Quoted 12 lines · Ard Biesheuvel
Quoted 10 lines · Evgeniy Baskov

Doing 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.

Quoted 8 lines

OK I just realized that there is a problem with this approach: since we now decompress the image while running in the EFI stub (i.e., before ExitBootServices()), we cannot just randomly pick a EFI_CONVENTIONAL_MEMORY region to place the kernel, we need to allocate the pages using the boot services. Otherwise, subsequent allocations (or concurrent ones occurring in the firmware in event handlers etc) may land right in the middle, which is unlikely to be what we want.

It does allocate pages for the kernel.
I've marked the place below.

Quoted 226 lines
Quoted 226 lines

---
 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 +21 -1
index ead6007df1e5..0be75e5072ae 100644
@@ -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 */

arch/x86/boot/compressed/head_32.S +27 -1
-       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 +11 -0
index 2dd8be0583d2..7cfef7bd0424 100644
@@ -529,12 +529,64 @@ SYM_CODE_END(startup_64)
        .org 0x390
 #endif
 SYM_FUNC_START(efi64_stub_entry)
+       /* Preserve first parameter */
+       movq    %rdi, %r10
+
+       /* Clear BSS */
+       xorl    %eax, %eax
+       leaq    _bss(%rip), %rdi
+       leaq    _ebss(%rip), %rcx
+       subq    %rdi, %rcx
+       shrq    $3, %rcx
+       rep     stosq
+
        and     $~0xf, %rsp                     /* realign the stack 
 */
        movq    %rdx, %rbx                      /* save boot_params 

pointer */

arch/x86/boot/compressed/head_64.S +39 -3
+       movq    %r10, %rdi
        call    efi_main
-       movq    %rbx,%rsi
-       leaq    rva(startup_64)(%rax), %rax
-       jmp     *%rax
+
+       cld
+       cli
+
+       movq    %rbx, %rdi /* boot_params */
+       movq    %rax, %rsi /* decompressed kernel address */
+
+       /* Make sure we have GDT with 32-bit code segment */
+       leaq    gdt64(%rip), %rax
+       addq    %rax, 2(%rax)
+       lgdt    (%rax)
+
+       /* Setup data segments. */
+       xorl    %eax, %eax
+       movl    %eax, %ds
+       movl    %eax, %es
+       movl    %eax, %ss
+       movl    %eax, %fs
+       movl    %eax, %gs
+
+       pushq   %rsi
+       pushq   %rdi
+
+       call    load_stage1_idt
+       call    enable_nx_if_supported
+
+       call    trampoline_pgtable_init
+       movq    %rax, %rdx
+
+
+       /* Swap %rsi and %rsi */
+       popq    %rsi
+       popq    %rdi
+
+       /* Save the trampoline address in RCX */
+       movq    trampoline_32bit(%rip), %rcx
+
+       /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far 

return */

arch/x86/boot/compressed/head_64.S +5 -0
+       pushq   $__KERNEL32_CS
+       leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rcx), %rax
+       pushq   %rax
+       lretq
+
 SYM_FUNC_END(efi64_stub_entry)
 SYM_FUNC_ALIAS(efi_stub_entry, efi64_stub_entry)
 #endif
drivers/firmware/efi/Kconfig +2 -0
index 043ca31c114e..f50c2a84a754 100644
@@ -58,6 +58,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 +0 -0
index be8b8c6e8b40..99b81c95344c 100644
@@ -88,7 +88,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.o arm64-stub.o arm64-entry.o 

smbios.o

drivers/firmware/efi/libstub/Makefile +1 -1
-lib-$(CONFIG_X86)              += x86-stub.o
+lib-$(CONFIG_X86)              += x86-stub.o x86-extract-direct.o
 lib-$(CONFIG_RISCV)            += riscv.o riscv-stub.o
 lib-$(CONFIG_LOONGARCH)                += loongarch.o 

loongarch-stub.o

drivers/firmware/efi/libstub/x86-extract-direct.c new file +36 -0
new file mode 100644
index 000000000000..4ecbc4a9b3ed
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/acpi.h>
+#include <linux/efi.h>
+#include <linux/elf.h>
+#include <linux/stddef.h>
+
+#include <asm/efi.h>
+#include <asm/e820/types.h>
+#include <asm/desc.h>
+#include <asm/boot.h>
+#include <asm/bootparam_utils.h>
+#include <asm/shared/extract.h>
+#include <asm/shared/pgtable.h>
+
+#include "efistub.h"
+#include "x86-stub.h"
+
+static efi_handle_t image_handle;
+
+static void do_puthex(unsigned long value)
+{
+       efi_printk("%08lx", value);
+}
+
+static void do_putstr(const char *msg)
+{
+       efi_printk("%s", msg);
+}
+
+static unsigned long do_map_range(unsigned long start,
+                                 unsigned long end,
+                                 unsigned int flags)
+{
+       efi_status_t status;
+
Quoted 8 lines
Quoted 8 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+       unsigned long size = end - start;
+
+       if (flags & MAP_ALLOC) {
+               unsigned long addr;
+
+               status = efi_low_alloc_above(size, 

CONFIG_PHYSICAL_ALIGN,
+ &addr, start);

Memory for the kernel image is allocated here.
This function is getting called from the boot/compressed/misc.c with MAP_ALLOC flag when the address for the kernel is picked.

Quoted 421 lines
Quoted 421 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +2 -0
+               if (status != EFI_SUCCESS) {
+                       efi_err("Unable to allocate memory for 

uncompressed kernel");

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+                       efi_exit(image_handle, EFI_OUT_OF_RESOURCES);
+               }
+
+               if (start != addr) {
+                       efi_debug("Unable to allocate at given 

address"

drivers/firmware/efi/libstub/x86-extract-direct.c new file +17 -0
+                                 " (desired=0x%lx, actual=0x%lx)",
+                                 (unsigned long)start, addr);
+                       start = addr;
+               }
+       }
+
+       if ((flags & (MAP_PROTECT | MAP_ALLOC)) &&
+           IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               unsigned long attr = 0;
+
+               if (!(flags & MAP_EXEC))
+                       attr |= EFI_MEMORY_XP;
+
+               if (!(flags & MAP_WRITE))
+                       attr |= EFI_MEMORY_RO;
+
+               status = efi_adjust_memory_range_protection(start, 

size, attr);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +9 -0
+               if (status != EFI_SUCCESS)
+                       efi_err("Unable to protect memory range");
+       }
+
+       return start;
+}
+
+/*
+ * Trampoline takes 3 pages and can be loaded in first megabyte of 

memory
+ * with its end placed between 0 and 640k where BIOS might start.
+ * (see arch/x86/boot/compressed/pgtable_64.c)
+ */

drivers/firmware/efi/libstub/x86-extract-direct.c new file +8 -0
+
+#ifdef CONFIG_64BIT
+static efi_status_t prepare_trampoline(void)
+{
+       efi_status_t status;
+
+       status = efi_allocate_pages(TRAMPOLINE_32BIT_SIZE,
+                                   (unsigned long 

*)&trampoline_32bit,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+                                   TRAMPOLINE_32BIT_PLACEMENT_MAX);
+
+       if (status != EFI_SUCCESS)
+               return status;
+
+       unsigned long trampoline_start = (unsigned 

long)trampoline_32bit;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+
+       memset(trampoline_32bit, 0, TRAMPOLINE_32BIT_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               /* First page of trampoline is a top level page table 

*/

drivers/firmware/efi/libstub/x86-extract-direct.c new file +8 -0
+               efi_adjust_memory_range_protection(trampoline_start,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       /* Second page of trampoline is the code (with a padding) */
+
+       void *caddr = (void *)trampoline_32bit + 

TRAMPOLINE_32BIT_CODE_OFFSET;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +2 -0
+
+       memcpy(caddr, trampoline_32bit_src, 

TRAMPOLINE_32BIT_CODE_SIZE);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +3 -0
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               efi_adjust_memory_range_protection((unsigned 

long)caddr,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_RO);
+
+               /* And the last page of trampoline is the stack */
+
+               efi_adjust_memory_range_protection(trampoline_start + 

2 * PAGE_SIZE,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +28 -0
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       return EFI_SUCCESS;
+}
+#else
+static inline efi_status_t prepare_trampoline(void)
+{
+       return EFI_SUCCESS;
+}
+#endif
+
+static efi_status_t init_loader_data(efi_handle_t handle,
+                                    struct boot_params *params,
+                                    struct efi_boot_memmap **map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+       efi_status_t status;
+
+       status = efi_get_memory_map(map, false);
+
+       if (status != EFI_SUCCESS) {
+               efi_err("Unable to get EFI memory map...\n");
+               return status;
+       }
+
+       const char *signature = efi_is_64bit() ? 

EFI64_LOADER_SIGNATURE
+ :
EFI32_LOADER_SIGNATURE;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +19 -0
+
+       memcpy(&efi->efi_loader_signature, signature, sizeof(__u32));
+
+       efi->efi_memdesc_size = (*map)->desc_size;
+       efi->efi_memdesc_version = (*map)->desc_ver;
+       efi->efi_memmap_size = (*map)->map_size;
+
+       efi_set_u64_split((unsigned long)(*map)->map,
+                         &efi->efi_memmap, &efi->efi_memmap_hi);
+
+       efi_set_u64_split((unsigned long)efi_system_table,
+                         &efi->efi_systab, &efi->efi_systab_hi);
+
+       image_handle = handle;
+
+       return EFI_SUCCESS;
+}
+
+static void free_loader_data(struct boot_params *params, struct 

efi_boot_memmap *map)

drivers/firmware/efi/libstub/x86-extract-direct.c new file +15 -0
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+
+       efi_bs_call(free_pool, map);
+
+       efi->efi_memdesc_size = 0;
+       efi->efi_memdesc_version = 0;
+       efi->efi_memmap_size = 0;
+       efi_set_u64_split(0, &efi->efi_memmap, &efi->efi_memmap_hi);
+}
+
+extern unsigned char input_data[];
+extern unsigned int input_len, output_len;
+
+unsigned long extract_kernel_direct(efi_handle_t handle, struct 

boot_params *params)

drivers/firmware/efi/libstub/x86-extract-direct.c new file +23 -0
+{
+
+       void *res;
+       efi_status_t status;
+       struct efi_extract_callbacks cb = { 0 };
+
+       status = prepare_trampoline();
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       /* Prepare environment for do_extract_kernel() call */
+       struct efi_boot_memmap *map = NULL;
+       status = init_loader_data(handle, params, &map);
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       cb.puthex = do_puthex;
+       cb.putstr = do_putstr;
+       cb.map_range = do_map_range;
+
+       res = efi_extract_kernel(params, &cb, input_data, input_len, 

output_len);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+
+       free_loader_data(params, map);
+
+       return (unsigned long)res;
+}
drivers/firmware/efi/libstub/x86-stub.c +2 -1
index 7fb1eff88a18..1d1ab1911fd3 100644
@@ -17,6 +17,7 @@
 #include <asm/boot.h>
 
 #include "efistub.h"
+#include "x86-stub.h"
 
 /* Maximum physical address for 64-bit kernel with 4-level paging */
 #define MAXMEM_X86_64_4LEVEL (1ull << 46)
@@ -24,7 +25,7 @@
 const efi_system_table_t *efi_system_table;
 const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
-static efi_loaded_image_t *image = NULL;
+static efi_loaded_image_t *image __section(".data");
 
 static efi_status_t
 preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct 

pci_setup_rom **__rom)

drivers/firmware/efi/libstub/x86-stub.c +0 -2
@@ -212,55 +213,9 @@ static void 
 retrieve_apple_device_properties(struct boot_params *boot_params)
        }
 }
 
-/*
- * Trampoline takes 2 pages and can be loaded in first megabyte of 

memory
- * with its end placed between 128k and 640k where BIOS might start.
- * (see arch/x86/boot/compressed/pgtable_64.c)
- *
- * We cannot find exact trampoline placement since memory map
- * can be modified by UEFI, and it can alter the computed address.
- */

drivers/firmware/efi/libstub/x86-stub.c +0 -8
-
-#define TRAMPOLINE_PLACEMENT_BASE ((128 - 8)*1024)
-#define TRAMPOLINE_PLACEMENT_SIZE (640*1024 - (128 - 8)*1024)
-
-void startup_32(struct boot_params *boot_params);
-
-static void
-setup_memory_protection(unsigned long image_base, unsigned long 

image_size)

drivers/firmware/efi/libstub/x86-stub.c +0 -9
-{
-       /*
-        * Allow execution of possible trampoline used
-        * for switching between 4- and 5-level page tables
-        * and relocated kernel image.
-        */
-
-       efi_adjust_memory_range_protection(TRAMPOLINE_PLACEMENT_BASE,
-                                          TRAMPOLINE_PLACEMENT_SIZE, 

0);

drivers/firmware/efi/libstub/x86-stub.c +0 -4
-
-#ifdef CONFIG_64BIT
-       if (image_base != (unsigned long)startup_32)
-               efi_adjust_memory_range_protection(image_base, 

image_size, 0);

drivers/firmware/efi/libstub/x86-stub.c +0 -11
-#else
-       /*
-        * Clear protection flags on a whole range of possible
-        * addresses used for KASLR. We don't need to do that
-        * on x86_64, since KASLR/extraction is performed after
-        * dedicated identity page tables are built and we only
-        * need to remove possible protection on relocated image
-        * itself disregarding further relocations.
-        */
-       efi_adjust_memory_range_protection(LOAD_PHYSICAL_ADDR,
-                                          KERNEL_IMAGE_SIZE - 

LOAD_PHYSICAL_ADDR,

drivers/firmware/efi/libstub/x86-stub.c +1 -10
-                                          0);
-#endif
-}
-
 static const efi_char16_t apple[] = L"Apple";
 
-static void setup_quirks(struct boot_params *boot_params,
-                        unsigned long image_base,
-                        unsigned long image_size)
+static void setup_quirks(struct boot_params *boot_params)
 {
        efi_char16_t *fw_vendor = (efi_char16_t *)(unsigned long)
                efi_table_attr(efi_system_table, fw_vendor);
@@ -269,9 +224,6 @@ static void setup_quirks(struct boot_params 
 *boot_params,
                if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))
                        retrieve_apple_device_properties(boot_params);
        }
-
-       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES))
-               setup_memory_protection(image_base, image_size);
 }
 

/*

drivers/firmware/efi/libstub/x86-stub.c +1 -1
@@ -384,7 +336,7 @@ static void setup_graphics(struct boot_params 
 *boot_params)
 }
 
 
-static void __noreturn efi_exit(efi_handle_t handle, efi_status_t 
 status)
+void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
 {
        efi_bs_call(exit, handle, status, 0, NULL);
        for(;;)
drivers/firmware/efi/libstub/x86-stub.c +0 -1
@@ -707,8 +659,7 @@ static efi_status_t exit_boot(struct boot_params 
 *boot_params, void *handle)
 }
 
 /*
- * On success, we return the address of startup_32, which has 

potentially been
- * relocated by efi_relocate_kernel.
+ * On success, we return extracted kernel entry point.
* On failure, we exit to the firmware via efi_exit instead of
returning.
*/
asmlinkage unsigned long efi_main(efi_handle_t handle,

drivers/firmware/efi/libstub/x86-stub.c +0 -7
@@ -733,60 +684,6 @@ asmlinkage unsigned long efi_main(efi_handle_t 
 handle,
                efi_dxe_table = NULL;
        }
 
-       /*
-        * If the kernel isn't already loaded at a suitable address,
-        * relocate it.
-        *
-        * It must be loaded above LOAD_PHYSICAL_ADDR.
-        *
-        * The maximum address for 64-bit is 1 << 46 for 4-level 

paging. This
- * is defined as the macro MAXMEM, but unfortunately that is
not a
- * compile-time constant if 5-level paging is configured, so
we instead

drivers/firmware/efi/libstub/x86-stub.c +0 -3
-        * define our own macro for use here.
-        *
-        * For 32-bit, the maximum address is complicated to figure 

out, for
- * now use KERNEL_IMAGE_SIZE, which will be 512MiB, the same
as what

drivers/firmware/efi/libstub/x86-stub.c +0 -3
-        * KASLR uses.
-        *
-        * Also relocate it if image_offset is zero, i.e. the kernel 

wasn't
- * loaded by LoadImage, but rather by a bootloader that called
the
- * handover entry. The reason we must always relocate in this
case is
- * to handle the case of systemd-boot booting a unified kernel
image,
- * which is a PE executable that contains the bzImage and an
initrd as
- * COFF sections. The initrd section is placed after the
bzImage
- * without ensuring that there are at least init_size bytes
available
- * for the bzImage, and thus the compressed kernel's startup
code may

drivers/firmware/efi/libstub/x86-stub.c +0 -9
-        * overwrite the initrd unless it is moved out of the way.
-        */
-
-       buffer_start = ALIGN(bzimage_addr - image_offset,
-                            hdr->kernel_alignment);
-       buffer_end = buffer_start + hdr->init_size;
-
-       if ((buffer_start < LOAD_PHYSICAL_ADDR)                        
      ||
-           (IS_ENABLED(CONFIG_X86_32) && buffer_end > 

KERNEL_IMAGE_SIZE) ||
- (IS_ENABLED(CONFIG_X86_64) && buffer_end >
MAXMEM_X86_64_4LEVEL) ||

drivers/firmware/efi/libstub/x86-stub.c +0 -5
-           (image_offset == 0)) {
-               extern char _bss[];
-
-               status = efi_relocate_kernel(&bzimage_addr,
-                                            (unsigned long)_bss - 

bzimage_addr,

drivers/firmware/efi/libstub/x86-stub.c +0 -10
-                                            hdr->init_size,
-                                            hdr->pref_address,
-                                            hdr->kernel_alignment,
-                                            LOAD_PHYSICAL_ADDR);
-               if (status != EFI_SUCCESS) {
-                       efi_err("efi_relocate_kernel() failed!\n");
-                       goto fail;
-               }
-               /*
-                * Now that we've copied the kernel elsewhere, we no 

longer
- * have a set up block before startup_32(), so reset
image_offset

drivers/firmware/efi/libstub/x86-stub.c +5 -6
-                * to zero in case it was set earlier.
-                */
-               image_offset = 0;
-       }
-
 #ifdef CONFIG_CMDLINE_BOOL
        status = efi_parse_options(CONFIG_CMDLINE);
        if (status != EFI_SUCCESS) {
@@ -843,7 +740,11 @@ asmlinkage unsigned long efi_main(efi_handle_t 
 handle,
 
        setup_efi_pci(boot_params);
 
-       setup_quirks(boot_params, bzimage_addr, buffer_end - 
 buffer_start);
+       setup_quirks(boot_params);
+
+       bzimage_addr = extract_kernel_direct(handle, boot_params);
+       if (!bzimage_addr)
+               goto fail;
 
        status = exit_boot(boot_params, handle);
        if (status != EFI_SUCCESS) {
drivers/firmware/efi/libstub/x86-stub.h new file +11 -0
new file mode 100644
index 000000000000..baecc7c6e602
@@ -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);

drivers/firmware/efi/libstub/x86-stub.h new file +3 -1
+void startup_32(struct boot_params *boot_params);
+
+#endif
--

2.37.4

maintainer
#41 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

Quoted 23 lines · Evgeniy Baskov
Quoted 12 lines · Ard Biesheuvel
Quoted 10 lines · Evgeniy Baskov

Doing 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.

Quoted 8 lines

OK I just realized that there is a problem with this approach: since we now decompress the image while running in the EFI stub (i.e., before ExitBootServices()), we cannot just randomly pick a EFI_CONVENTIONAL_MEMORY region to place the kernel, we need to allocate the pages using the boot services. Otherwise, subsequent allocations (or concurrent ones occurring in the firmware in event handlers etc) may land right in the middle, which is unlikely to be what we want.

Quoted 3 lines

It does allocate pages for the kernel.
I've marked the place below.

Ah excellent, thanks for clearing that up.

Quoted 668 lines
Quoted 231 lines
Quoted 231 lines

---
 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 +21 -1
index ead6007df1e5..0be75e5072ae 100644
@@ -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 */

arch/x86/boot/compressed/head_32.S +27 -1
-       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 +11 -0
index 2dd8be0583d2..7cfef7bd0424 100644
@@ -529,12 +529,64 @@ SYM_CODE_END(startup_64)
        .org 0x390
 #endif
 SYM_FUNC_START(efi64_stub_entry)
+       /* Preserve first parameter */
+       movq    %rdi, %r10
+
+       /* Clear BSS */
+       xorl    %eax, %eax
+       leaq    _bss(%rip), %rdi
+       leaq    _ebss(%rip), %rcx
+       subq    %rdi, %rcx
+       shrq    $3, %rcx
+       rep     stosq
+
        and     $~0xf, %rsp                     /* realign the stack
 */
        movq    %rdx, %rbx                      /* save boot_params

pointer */

arch/x86/boot/compressed/head_64.S +39 -3
+       movq    %r10, %rdi
        call    efi_main
-       movq    %rbx,%rsi
-       leaq    rva(startup_64)(%rax), %rax
-       jmp     *%rax
+
+       cld
+       cli
+
+       movq    %rbx, %rdi /* boot_params */
+       movq    %rax, %rsi /* decompressed kernel address */
+
+       /* Make sure we have GDT with 32-bit code segment */
+       leaq    gdt64(%rip), %rax
+       addq    %rax, 2(%rax)
+       lgdt    (%rax)
+
+       /* Setup data segments. */
+       xorl    %eax, %eax
+       movl    %eax, %ds
+       movl    %eax, %es
+       movl    %eax, %ss
+       movl    %eax, %fs
+       movl    %eax, %gs
+
+       pushq   %rsi
+       pushq   %rdi
+
+       call    load_stage1_idt
+       call    enable_nx_if_supported
+
+       call    trampoline_pgtable_init
+       movq    %rax, %rdx
+
+
+       /* Swap %rsi and %rsi */
+       popq    %rsi
+       popq    %rdi
+
+       /* Save the trampoline address in RCX */
+       movq    trampoline_32bit(%rip), %rcx
+
+       /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far

return */

arch/x86/boot/compressed/head_64.S +5 -0
+       pushq   $__KERNEL32_CS
+       leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rcx), %rax
+       pushq   %rax
+       lretq
+
 SYM_FUNC_END(efi64_stub_entry)
 SYM_FUNC_ALIAS(efi_stub_entry, efi64_stub_entry)
 #endif
drivers/firmware/efi/Kconfig +2 -0
index 043ca31c114e..f50c2a84a754 100644
@@ -58,6 +58,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 +0 -0
index be8b8c6e8b40..99b81c95344c 100644
@@ -88,7 +88,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.o arm64-stub.o arm64-entry.o

smbios.o

drivers/firmware/efi/libstub/Makefile +1 -1
-lib-$(CONFIG_X86)              += x86-stub.o
+lib-$(CONFIG_X86)              += x86-stub.o x86-extract-direct.o
 lib-$(CONFIG_RISCV)            += riscv.o riscv-stub.o
 lib-$(CONFIG_LOONGARCH)                += loongarch.o

loongarch-stub.o

drivers/firmware/efi/libstub/x86-extract-direct.c new file +36 -0
new file mode 100644
index 000000000000..4ecbc4a9b3ed
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/acpi.h>
+#include <linux/efi.h>
+#include <linux/elf.h>
+#include <linux/stddef.h>
+
+#include <asm/efi.h>
+#include <asm/e820/types.h>
+#include <asm/desc.h>
+#include <asm/boot.h>
+#include <asm/bootparam_utils.h>
+#include <asm/shared/extract.h>
+#include <asm/shared/pgtable.h>
+
+#include "efistub.h"
+#include "x86-stub.h"
+
+static efi_handle_t image_handle;
+
+static void do_puthex(unsigned long value)
+{
+       efi_printk("%08lx", value);
+}
+
+static void do_putstr(const char *msg)
+{
+       efi_printk("%s", msg);
+}
+
+static unsigned long do_map_range(unsigned long start,
+                                 unsigned long end,
+                                 unsigned int flags)
+{
+       efi_status_t status;
+
Quoted 8 lines
Quoted 8 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+       unsigned long size = end - start;
+
+       if (flags & MAP_ALLOC) {
+               unsigned long addr;
+
+               status = efi_low_alloc_above(size,

CONFIG_PHYSICAL_ALIGN,
+ &addr, start);

Memory for the kernel image is allocated here.
This function is getting called from the boot/compressed/misc.c with MAP_ALLOC flag
when the address for the kernel is picked.

Quoted 423 lines
Quoted 423 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +2 -0
+               if (status != EFI_SUCCESS) {
+                       efi_err("Unable to allocate memory for

uncompressed kernel");

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+                       efi_exit(image_handle, EFI_OUT_OF_RESOURCES);
+               }
+
+               if (start != addr) {
+                       efi_debug("Unable to allocate at given

address"

drivers/firmware/efi/libstub/x86-extract-direct.c new file +17 -0
+                                 " (desired=0x%lx, actual=0x%lx)",
+                                 (unsigned long)start, addr);
+                       start = addr;
+               }
+       }
+
+       if ((flags & (MAP_PROTECT | MAP_ALLOC)) &&
+           IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               unsigned long attr = 0;
+
+               if (!(flags & MAP_EXEC))
+                       attr |= EFI_MEMORY_XP;
+
+               if (!(flags & MAP_WRITE))
+                       attr |= EFI_MEMORY_RO;
+
+               status = efi_adjust_memory_range_protection(start,

size, attr);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +9 -0
+               if (status != EFI_SUCCESS)
+                       efi_err("Unable to protect memory range");
+       }
+
+       return start;
+}
+
+/*
+ * Trampoline takes 3 pages and can be loaded in first megabyte of

memory
+ * with its end placed between 0 and 640k where BIOS might start.
+ * (see arch/x86/boot/compressed/pgtable_64.c)
+ */

drivers/firmware/efi/libstub/x86-extract-direct.c new file +8 -0
+
+#ifdef CONFIG_64BIT
+static efi_status_t prepare_trampoline(void)
+{
+       efi_status_t status;
+
+       status = efi_allocate_pages(TRAMPOLINE_32BIT_SIZE,
+                                   (unsigned long

*)&trampoline_32bit,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+                                   TRAMPOLINE_32BIT_PLACEMENT_MAX);
+
+       if (status != EFI_SUCCESS)
+               return status;
+
+       unsigned long trampoline_start = (unsigned

long)trampoline_32bit;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+
+       memset(trampoline_32bit, 0, TRAMPOLINE_32BIT_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               /* First page of trampoline is a top level page table

*/

drivers/firmware/efi/libstub/x86-extract-direct.c new file +8 -0
+               efi_adjust_memory_range_protection(trampoline_start,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       /* Second page of trampoline is the code (with a padding) */
+
+       void *caddr = (void *)trampoline_32bit +

TRAMPOLINE_32BIT_CODE_OFFSET;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +2 -0
+
+       memcpy(caddr, trampoline_32bit_src,

TRAMPOLINE_32BIT_CODE_SIZE);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +3 -0
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               efi_adjust_memory_range_protection((unsigned

long)caddr,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +6 -0
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_RO);
+
+               /* And the last page of trampoline is the stack */
+
+               efi_adjust_memory_range_protection(trampoline_start +

2 * PAGE_SIZE,

drivers/firmware/efi/libstub/x86-extract-direct.c new file +28 -0
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       return EFI_SUCCESS;
+}
+#else
+static inline efi_status_t prepare_trampoline(void)
+{
+       return EFI_SUCCESS;
+}
+#endif
+
+static efi_status_t init_loader_data(efi_handle_t handle,
+                                    struct boot_params *params,
+                                    struct efi_boot_memmap **map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+       efi_status_t status;
+
+       status = efi_get_memory_map(map, false);
+
+       if (status != EFI_SUCCESS) {
+               efi_err("Unable to get EFI memory map...\n");
+               return status;
+       }
+
+       const char *signature = efi_is_64bit() ?

EFI64_LOADER_SIGNATURE
+ :
EFI32_LOADER_SIGNATURE;

drivers/firmware/efi/libstub/x86-extract-direct.c new file +19 -0
+
+       memcpy(&efi->efi_loader_signature, signature, sizeof(__u32));
+
+       efi->efi_memdesc_size = (*map)->desc_size;
+       efi->efi_memdesc_version = (*map)->desc_ver;
+       efi->efi_memmap_size = (*map)->map_size;
+
+       efi_set_u64_split((unsigned long)(*map)->map,
+                         &efi->efi_memmap, &efi->efi_memmap_hi);
+
+       efi_set_u64_split((unsigned long)efi_system_table,
+                         &efi->efi_systab, &efi->efi_systab_hi);
+
+       image_handle = handle;
+
+       return EFI_SUCCESS;
+}
+
+static void free_loader_data(struct boot_params *params, struct

efi_boot_memmap *map)

drivers/firmware/efi/libstub/x86-extract-direct.c new file +15 -0
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+
+       efi_bs_call(free_pool, map);
+
+       efi->efi_memdesc_size = 0;
+       efi->efi_memdesc_version = 0;
+       efi->efi_memmap_size = 0;
+       efi_set_u64_split(0, &efi->efi_memmap, &efi->efi_memmap_hi);
+}
+
+extern unsigned char input_data[];
+extern unsigned int input_len, output_len;
+
+unsigned long extract_kernel_direct(efi_handle_t handle, struct

boot_params *params)

drivers/firmware/efi/libstub/x86-extract-direct.c new file +23 -0
+{
+
+       void *res;
+       efi_status_t status;
+       struct efi_extract_callbacks cb = { 0 };
+
+       status = prepare_trampoline();
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       /* Prepare environment for do_extract_kernel() call */
+       struct efi_boot_memmap *map = NULL;
+       status = init_loader_data(handle, params, &map);
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       cb.puthex = do_puthex;
+       cb.putstr = do_putstr;
+       cb.map_range = do_map_range;
+
+       res = efi_extract_kernel(params, &cb, input_data, input_len,

output_len);

drivers/firmware/efi/libstub/x86-extract-direct.c new file +5 -0
+
+       free_loader_data(params, map);
+
+       return (unsigned long)res;
+}
drivers/firmware/efi/libstub/x86-stub.c +2 -1
index 7fb1eff88a18..1d1ab1911fd3 100644
@@ -17,6 +17,7 @@
 #include <asm/boot.h>
 
 #include "efistub.h"
+#include "x86-stub.h"
 
 /* Maximum physical address for 64-bit kernel with 4-level paging */
 #define MAXMEM_X86_64_4LEVEL (1ull << 46)
@@ -24,7 +25,7 @@
 const efi_system_table_t *efi_system_table;
 const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
-static efi_loaded_image_t *image = NULL;
+static efi_loaded_image_t *image __section(".data");
 
 static efi_status_t
 preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct

pci_setup_rom **__rom)

drivers/firmware/efi/libstub/x86-stub.c +0 -2
@@ -212,55 +213,9 @@ static void
 retrieve_apple_device_properties(struct boot_params *boot_params)
        }
 }
 
-/*
- * Trampoline takes 2 pages and can be loaded in first megabyte of

memory
- * with its end placed between 128k and 640k where BIOS might start.
- * (see arch/x86/boot/compressed/pgtable_64.c)
- *
- * We cannot find exact trampoline placement since memory map
- * can be modified by UEFI, and it can alter the computed address.
- */

drivers/firmware/efi/libstub/x86-stub.c +0 -8
-
-#define TRAMPOLINE_PLACEMENT_BASE ((128 - 8)*1024)
-#define TRAMPOLINE_PLACEMENT_SIZE (640*1024 - (128 - 8)*1024)
-
-void startup_32(struct boot_params *boot_params);
-
-static void
-setup_memory_protection(unsigned long image_base, unsigned long

image_size)

drivers/firmware/efi/libstub/x86-stub.c +0 -9
-{
-       /*
-        * Allow execution of possible trampoline used
-        * for switching between 4- and 5-level page tables
-        * and relocated kernel image.
-        */
-
-       efi_adjust_memory_range_protection(TRAMPOLINE_PLACEMENT_BASE,
-                                          TRAMPOLINE_PLACEMENT_SIZE,

0);

drivers/firmware/efi/libstub/x86-stub.c +0 -4
-
-#ifdef CONFIG_64BIT
-       if (image_base != (unsigned long)startup_32)
-               efi_adjust_memory_range_protection(image_base,

image_size, 0);

drivers/firmware/efi/libstub/x86-stub.c +0 -11
-#else
-       /*
-        * Clear protection flags on a whole range of possible
-        * addresses used for KASLR. We don't need to do that
-        * on x86_64, since KASLR/extraction is performed after
-        * dedicated identity page tables are built and we only
-        * need to remove possible protection on relocated image
-        * itself disregarding further relocations.
-        */
-       efi_adjust_memory_range_protection(LOAD_PHYSICAL_ADDR,
-                                          KERNEL_IMAGE_SIZE -

LOAD_PHYSICAL_ADDR,

drivers/firmware/efi/libstub/x86-stub.c +1 -10
-                                          0);
-#endif
-}
-
 static const efi_char16_t apple[] = L"Apple";
 
-static void setup_quirks(struct boot_params *boot_params,
-                        unsigned long image_base,
-                        unsigned long image_size)
+static void setup_quirks(struct boot_params *boot_params)
 {
        efi_char16_t *fw_vendor = (efi_char16_t *)(unsigned long)
                efi_table_attr(efi_system_table, fw_vendor);
@@ -269,9 +224,6 @@ static void setup_quirks(struct boot_params
 *boot_params,
                if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))
                        retrieve_apple_device_properties(boot_params);
        }
-
-       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES))
-               setup_memory_protection(image_base, image_size);
 }
 

/*

drivers/firmware/efi/libstub/x86-stub.c +1 -1
@@ -384,7 +336,7 @@ static void setup_graphics(struct boot_params
 *boot_params)
 }
 
 
-static void __noreturn efi_exit(efi_handle_t handle, efi_status_t
 status)
+void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
 {
        efi_bs_call(exit, handle, status, 0, NULL);
        for(;;)
drivers/firmware/efi/libstub/x86-stub.c +0 -1
@@ -707,8 +659,7 @@ static efi_status_t exit_boot(struct boot_params
 *boot_params, void *handle)
 }
 
 /*
- * On success, we return the address of startup_32, which has

potentially been
- * relocated by efi_relocate_kernel.
+ * On success, we return extracted kernel entry point.
* On failure, we exit to the firmware via efi_exit instead of
returning.
*/
asmlinkage unsigned long efi_main(efi_handle_t handle,

drivers/firmware/efi/libstub/x86-stub.c +0 -7
@@ -733,60 +684,6 @@ asmlinkage unsigned long efi_main(efi_handle_t
 handle,
                efi_dxe_table = NULL;
        }
 
-       /*
-        * If the kernel isn't already loaded at a suitable address,
-        * relocate it.
-        *
-        * It must be loaded above LOAD_PHYSICAL_ADDR.
-        *
-        * The maximum address for 64-bit is 1 << 46 for 4-level

paging. This
- * is defined as the macro MAXMEM, but unfortunately that is
not a
- * compile-time constant if 5-level paging is configured, so
we instead

drivers/firmware/efi/libstub/x86-stub.c +0 -3
-        * define our own macro for use here.
-        *
-        * For 32-bit, the maximum address is complicated to figure

out, for
- * now use KERNEL_IMAGE_SIZE, which will be 512MiB, the same
as what

drivers/firmware/efi/libstub/x86-stub.c +0 -3
-        * KASLR uses.
-        *
-        * Also relocate it if image_offset is zero, i.e. the kernel

wasn't
- * loaded by LoadImage, but rather by a bootloader that called
the
- * handover entry. The reason we must always relocate in this
case is
- * to handle the case of systemd-boot booting a unified kernel
image,
- * which is a PE executable that contains the bzImage and an
initrd as
- * COFF sections. The initrd section is placed after the
bzImage
- * without ensuring that there are at least init_size bytes
available
- * for the bzImage, and thus the compressed kernel's startup
code may

drivers/firmware/efi/libstub/x86-stub.c +0 -9
-        * overwrite the initrd unless it is moved out of the way.
-        */
-
-       buffer_start = ALIGN(bzimage_addr - image_offset,
-                            hdr->kernel_alignment);
-       buffer_end = buffer_start + hdr->init_size;
-
-       if ((buffer_start < LOAD_PHYSICAL_ADDR)
      ||
-           (IS_ENABLED(CONFIG_X86_32) && buffer_end >

KERNEL_IMAGE_SIZE) ||
- (IS_ENABLED(CONFIG_X86_64) && buffer_end >
MAXMEM_X86_64_4LEVEL) ||

drivers/firmware/efi/libstub/x86-stub.c +0 -5
-           (image_offset == 0)) {
-               extern char _bss[];
-
-               status = efi_relocate_kernel(&bzimage_addr,
-                                            (unsigned long)_bss -

bzimage_addr,

drivers/firmware/efi/libstub/x86-stub.c +0 -10
-                                            hdr->init_size,
-                                            hdr->pref_address,
-                                            hdr->kernel_alignment,
-                                            LOAD_PHYSICAL_ADDR);
-               if (status != EFI_SUCCESS) {
-                       efi_err("efi_relocate_kernel() failed!\n");
-                       goto fail;
-               }
-               /*
-                * Now that we've copied the kernel elsewhere, we no

longer
- * have a set up block before startup_32(), so reset
image_offset

drivers/firmware/efi/libstub/x86-stub.c +5 -6
-                * to zero in case it was set earlier.
-                */
-               image_offset = 0;
-       }
-
 #ifdef CONFIG_CMDLINE_BOOL
        status = efi_parse_options(CONFIG_CMDLINE);
        if (status != EFI_SUCCESS) {
@@ -843,7 +740,11 @@ asmlinkage unsigned long efi_main(efi_handle_t
 handle,
 
        setup_efi_pci(boot_params);
 
-       setup_quirks(boot_params, bzimage_addr, buffer_end -
 buffer_start);
+       setup_quirks(boot_params);
+
+       bzimage_addr = extract_kernel_direct(handle, boot_params);
+       if (!bzimage_addr)
+               goto fail;
 
        status = exit_boot(boot_params, handle);
        if (status != EFI_SUCCESS) {
drivers/firmware/efi/libstub/x86-stub.h new file +11 -0
new file mode 100644
index 000000000000..baecc7c6e602
@@ -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);

drivers/firmware/efi/libstub/x86-stub.h new file +3 -1
+void startup_32(struct boot_params *boot_params);
+
+#endif
--

2.37.4

#55 lore raw

Re: [PATCH v4 19/26] x86/build: Cleanup tools/build.c

In reply to Ard Biesheuvel
Quoted 116 lines · Ard Biesheuvel
Quoted 115 lines · Evgeniy Baskov
Quoted 112 lines · Ard Biesheuvel
Quoted 99 lines · Evgeniy Baskov

Use 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 +40 -9
index bd247692b701..fbc5315af032 100644
@@ -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);

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 104

Quoted 10 lines
arch/x86/boot/tools/build.c +10 -0
+       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

Can we drop this conditional?

Quoted 7 lines
Quoted 4 lines

Without CONFIG_EFI_DXE_MEM_ATTRIBUTES memory attributes are not getting applies anywhere, so this would break 'nokaslr' on UEFI implementations that honor section attributes.

How so? This only affects the mappings that are created by UEFI for the decompressor binary, right?

I was thinking about the in-place decompression, but now I've realized that I was wrong since in-place decompression cannot happen when booting via the stub. I'll remove the ifdef.

Quoted 8 lines
Quoted 5 lines

KASLR is already broken without that option on implementations that disallow execution of the free memory though. But unlike free memory, sections are more likely to get protected, I think.

We need to allocate those pages properly in any case (see my other reply) so it is no longer free memory.

It should be fine, as I explained.

The only thing that is a little unexpected is that the kernel might shift even with 'nokaslr' when the LOAD_PHYSICAL_ADDR is already taken by some firmware allocation (or by us). This should cause no real problems, since the kernel is required to be relocatable for the EFISTUB.

Quoted 568 lines
Quoted 568 lines
Quoted 9 lines
Quoted 6 lines
arch/x86/boot/tools/build.c +2 -0
+#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)

Please drop the alignment flags - they don't apply to executable only object files.

Got it, will remove them in v5.

Quoted 15 lines
Quoted 15 lines
arch/x86/boot/tools/build.c +8 -0
+#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;
 
 
Quoted 7 lines

arch/x86/boot/tools/build.c static unsigned long _end; · line 125

Quoted 4 lines
arch/x86/boot/tools/build.c +1 -1
 /*----------------------------------------------------------------------*/
 
-static const u32 crctab32[] = {
+static const uint32_t crctab32[] = {

Replacing all the type names makes this patch very messy. Can we back that out please?

Ok, I will revert them.

Quoted 531 lines
Quoted 531 lines
arch/x86/boot/tools/build.c +0 -0
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
        0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
        0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
arch/x86/boot/tools/build.c +2 -2
@@ -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);
arch/x86/boot/tools/build.c +62 -13
@@ -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,
 &section->virtual_size);
 
                        /* section header vma field */
-                       put_unaligned_le32(vma, section + 0xc);
+                       put_unaligned_le32(vma,
 &section->virtual_address);
 
                        /* section header 'size of initialised data'

field */

arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(datasz, section + 0x10);
+                       put_unaligned_le32(datasz,

&section->raw_data_size);

                        /* section header 'file offset' field */
arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(offset, section + 0x14);
+                       put_unaligned_le32(offset,

&section->data_addr);

                        break;
                }
arch/x86/boot/tools/build.c +1 -2
-               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) {

arch/x86/boot/tools/build.c +0 -2
-       u32 setup_offset = 0x200;
-       u32 reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;

arch/x86/boot/tools/build.c +2 -0
+       uint32_t setup_offset = SECTOR_SIZE;
+       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;
#ifdef CONFIG_EFI_MIXED

arch/x86/boot/tools/build.c +2 -2
-       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);

arch/x86/boot/tools/build.c +0 -0
@@ -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.

         */
arch/x86/boot/tools/build.c +1 -2
-       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);

arch/x86/boot/tools/build.c +5 -6
@@ -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

arch/x86/boot/tools/build.c +3 -3
@@ -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);
arch/x86/boot/tools/build.c +4 -2
+
+       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
@@ -298,7 +399,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
 #endif
        put_unaligned_le32(addr, &buf[0x264]);
arch/x86/boot/tools/build.c +1 -1
@@ -310,7 +411,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)

arch/x86/boot/tools/build.c +60 -55
@@ -338,20 +439,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);
@@ -367,82 +463,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 */

arch/x86/boot/tools/build.c +4 -6
-       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 */

arch/x86/boot/tools/build.c +4 -0
+       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

*/

arch/x86/boot/tools/build.c +7 -3
-       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

arch/x86/boot/tools/build.c +21 -32
@@ -458,45 +571,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;
 }
--

2.37.4

maintainer
#56 lore raw

Re: [PATCH v4 19/26] x86/build: Cleanup tools/build.c

Quoted 123 lines · Evgeniy Baskov
Quoted 121 lines · Ard Biesheuvel
Quoted 119 lines · Evgeniy Baskov
Quoted 104 lines · Ard Biesheuvel
Quoted 103 lines · Evgeniy Baskov

Use 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 +44 -9
index bd247692b701..fbc5315af032 100644
@@ -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)
Quoted 8 lines

arch/x86/boot/tools/build.c u8 buf[SETUP_SECT_MAX*512]; · line 102

Quoted 6 lines
arch/x86/boot/tools/build.c +6 -0
+{
+       pe_opt_hdr *hdr = get_pe_opt_header(buf);
+       return (struct data_directory *)(hdr + 1);
+}
+
+#ifdef CONFIG_EFI_DXE_MEM_ATTRIBUTES

Can we drop this conditional?

Without CONFIG_EFI_DXE_MEM_ATTRIBUTES memory attributes are not getting applies anywhere, so this would break 'nokaslr' on UEFI implementations that honor section attributes.

Quoted 7 lines
Quoted 2 lines

How so? This only affects the mappings that are created by UEFI for the decompressor binary, right?

I was thinking about the in-place decompression, but now I've realized that I was wrong since in-place decompression cannot happen when booting via the stub. I'll remove the ifdef.

Indeed. And I realized that all the image_offset handling can now be dropped as well.

Quoted 9 lines
Quoted 8 lines
Quoted 5 lines

KASLR is already broken without that option on implementations that disallow execution of the free memory though. But unlike free memory, sections are more likely to get protected, I think.

We need to allocate those pages properly in any case (see my other reply) so it is no longer free memory.

Quoted 8 lines

It should be fine, as I explained.

The only thing that is a little unexpected is that the kernel might shift even with 'nokaslr' when the LOAD_PHYSICAL_ADDR is already taken by some firmware allocation (or by us). This should cause no real problems, since the kernel is required to be relocatable for the EFISTUB.

OK, good to know.

Quoted 568 lines
Quoted 568 lines
Quoted 568 lines
Quoted 9 lines
Quoted 6 lines
arch/x86/boot/tools/build.c +2 -0
+#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)

Please drop the alignment flags - they don't apply to executable only object files.

Got it, will remove them in v5.

Quoted 15 lines
Quoted 15 lines
arch/x86/boot/tools/build.c +8 -0
+#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;
 
 
Quoted 7 lines

arch/x86/boot/tools/build.c static unsigned long _end; · line 125

Quoted 4 lines
arch/x86/boot/tools/build.c +1 -1
 /*----------------------------------------------------------------------*/
 
-static const u32 crctab32[] = {
+static const uint32_t crctab32[] = {

Replacing all the type names makes this patch very messy. Can we back that out please?

Ok, I will revert them.

Quoted 531 lines
Quoted 531 lines
arch/x86/boot/tools/build.c +0 -0
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
        0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
        0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
arch/x86/boot/tools/build.c +2 -2
@@ -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);
arch/x86/boot/tools/build.c +62 -13
@@ -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,
 &section->virtual_size);
 
                        /* section header vma field */
-                       put_unaligned_le32(vma, section + 0xc);
+                       put_unaligned_le32(vma,
 &section->virtual_address);
 
                        /* section header 'size of initialised data'

field */

arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(datasz, section + 0x10);
+                       put_unaligned_le32(datasz,

&section->raw_data_size);

                        /* section header 'file offset' field */
arch/x86/boot/tools/build.c +1 -1
-                       put_unaligned_le32(offset, section + 0x14);
+                       put_unaligned_le32(offset,

&section->data_addr);

                        break;
                }
arch/x86/boot/tools/build.c +1 -2
-               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) {

arch/x86/boot/tools/build.c +0 -2
-       u32 setup_offset = 0x200;
-       u32 reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;

arch/x86/boot/tools/build.c +2 -0
+       uint32_t setup_offset = SECTOR_SIZE;
+       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE -

PECOFF_COMPAT_RESERVE;
#ifdef CONFIG_EFI_MIXED

arch/x86/boot/tools/build.c +2 -2
-       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);

arch/x86/boot/tools/build.c +0 -0
@@ -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.

         */
arch/x86/boot/tools/build.c +1 -2
-       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);

arch/x86/boot/tools/build.c +5 -6
@@ -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

arch/x86/boot/tools/build.c +3 -3
@@ -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);
arch/x86/boot/tools/build.c +4 -2
+
+       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
@@ -298,7 +399,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
 #endif
        put_unaligned_le32(addr, &buf[0x264]);
arch/x86/boot/tools/build.c +1 -1
@@ -310,7 +411,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)

arch/x86/boot/tools/build.c +60 -55
@@ -338,20 +439,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);
@@ -367,82 +463,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 */

arch/x86/boot/tools/build.c +4 -6
-       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 */

arch/x86/boot/tools/build.c +4 -0
+       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

*/

arch/x86/boot/tools/build.c +7 -3
-       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

arch/x86/boot/tools/build.c +21 -32
@@ -458,45 +571,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;
 }
--

2.37.4

maintainer
#2 lore raw

Re: [PATCH v4 01/26] x86/boot: Align vmlinuz sections on page size

In reply to Evgeniy Baskov
Quoted 18 lines · Evgeniy Baskov

To 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 +0 -0
index 112b2375d021..6be90f1a1198 100644

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 33

Quoted 7 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
@@ -27,21 +27,27 @@ SECTIONS
                HEAD_TEXT
                _ehead = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata..compressed : {
+               _compressed = .;
                *(.rodata..compressed)

Can you just move this bit into the rodata section below?

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 37

Quoted 4 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
+               _ecompressed = .;
        }
+       . = ALIGN(PAGE_SIZE);
        .text : {

Please use

.text : ALIGN(PAGE_SIZE) {

which marks the section as being page aligned, rather than just being placed on a 4k boundary.

Quoted 19 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -1
                _text = .;      /* Text */
                *(.text)
                *(.text.*)
                _etext = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata : {
                _rodata = . ;
                *(.rodata)       /* read-only data */
                *(.rodata.*)
                _erodata = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .data : {
                _data = . ;
                *(.data)
--

2.37.4

maintainer Reviewed-by on v4 2/26
#6 lore raw

Re: [PATCH v4 02/26] x86/build: Remove RWX sections and align on 4KB

In reply to Evgeniy Baskov
Quoted 16 lines · Evgeniy Baskov

Avoid 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.

Quoted 3 lines

One nit: the series modifies both the decompressor linker script and the core kernel one, so please make it very explicit in the commit log which one is being modified, and why it matters for this particular context.

Quoted 49 lines
---
 arch/x86/kernel/vmlinux.lds.S | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)
arch/x86/kernel/vmlinux.lds.S +8 -8
index 2e0ee14229bf..2e56d694c491 100644
@@ -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);          /* ___ */
 }
 
@@ -227,9 +226,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
@@ -241,6 +241,7 @@ SECTIONS
        .altinstr_aux : AT(ADDR(.altinstr_aux) - LOAD_OFFSET) {
                *(.altinstr_aux)
        }
+       :init
 
        INIT_DATA_SECTION(16)
 
--

2.37.4

maintainer Acked-by on v4 3/26
#9 lore raw

Re: [PATCH v4 03/26] x86/boot: Set cr0 to known state in trampoline

In reply to Evgeniy Baskov
Quoted 7 lines · Evgeniy Baskov

Ensure WP bit to be set to prevent boot code from writing to non-writable memory pages.

Quoted 23 lines
---
 arch/x86/boot/compressed/head_64.S | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)
arch/x86/boot/compressed/head_64.S +2 -4
index a75712991df3..9f2e8f50fc71 100644
@@ -660,9 +660,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
--

2.37.4

maintainer
#30 lore raw

Re: [PATCH v4 12/26] x86/boot: Make kernel_add_identity_map() a pointer

In reply to Evgeniy Baskov
Quoted 19 lines · Evgeniy Baskov

Convert 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 +0 -0
index ba5108c58a4e..1aee524d3c2b 100644

arch/x86/boot/compressed/ident_map_64.c bool has_nx; /* set in head_64.S */ · line 95

Quoted 7 lines
arch/x86/boot/compressed/ident_map_64.c +1 -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,

Please use a more discriminating name here - the trailing _ is rather hard to spot.

Quoted 21 lines
arch/x86/boot/compressed/ident_map_64.c +3 -0
+                                      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 +0 -0
index aa4a22bc9cf9..c9c235d65d16 100644
@@ -275,6 +275,22 @@ static void parse_elf(void *output, unsigned long output_len,
        free(phdrs);
 }
 

arch/x86/boot/compressed/misc.c static void parse_elf(void *output, unsigned long output_len, · line 287

Quoted 10 lines
arch/x86/boot/compressed/misc.c +10 -0
+/*
+ * 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,

This function is never called, it only has its address taken, so the 'inline' makes no sense here.

Quoted 10 lines
arch/x86/boot/compressed/misc.c +6 -0
+                                                         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

arch/x86/boot/compressed/misc.c asmlinkage __visible void *extract_kernel(void *rmode, memptr heap, · line 332

Quoted 5 lines
arch/x86/boot/compressed/misc.c +2 -0
@@ -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,

initialization

Quoted 38 lines
arch/x86/boot/compressed/misc.c +6 -0
+        * 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 -13
index 38d31bec062d..0076b2845b4b 100644
@@ -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;
 
--

2.37.4

maintainer
#33 lore raw

Re: [PATCH v4 13/26] x86/boot: Split trampoline and pt init code

In reply to Evgeniy Baskov
Quoted 78 lines · Evgeniy Baskov

When 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 +7 -27
index c7cf5a1059a8..1f7169248612 100644
@@ -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);

arch/x86/boot/compressed/pgtable_64.c struct paging_config paging_prepare(void *rmode) · line 175

Quoted 10 lines
arch/x86/boot/compressed/pgtable_64.c +8 -0
        }
 
+out:
+       return l5_required;
+}
+
+struct paging_config paging_prepare(void *rmode)
+{
+       struct paging_config paging_config = {};
+       bool early_trampoline_alloc = 0;

false

arch/x86/boot/compressed/pgtable_64.c struct paging_config paging_prepare(void *rmode) · line 188

Quoted 13 lines
arch/x86/boot/compressed/pgtable_64.c +13 -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;
+

false again

And it never becomes true, nor is it used anywhere else. Can we get rid of it?

arch/x86/boot/compressed/pgtable_64.c struct paging_config paging_prepare(void *rmode) · line 194

Quoted 6 lines
arch/x86/boot/compressed/pgtable_64.c +6 -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.

Can you please reflow comments so they takes up fewer lines?

Quoted 18 lines
arch/x86/boot/compressed/pgtable_64.c +12 -1
+        */
+       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;
 }
--

2.37.4

maintainer
#45 lore raw

Re: [PATCH v4 17/26] x86/boot: Reduce size of the DOS stub

In reply to Evgeniy Baskov
Quoted 8 lines · Evgeniy Baskov

This 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.

I'd prefer to rip this out altogether.

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=9510f6f04f579b9a3f54ad762c75ab2d905e37d8

(and refer to the other thread in linux-efi@)

Quoted 46 lines
---
 arch/x86/boot/header.S | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)
arch/x86/boot/header.S +6 -9
index 9338c68e7413..9fec80bc504b 100644
@@ -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
@@ -90,10 +89,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:
--

2.37.4

maintainer Acked-by on v4 18/26
#50 lore raw

Re: [PATCH v4 18/26] tools/include: Add simplified version of pe.h

In reply to Evgeniy Baskov
Quoted 7 lines · Evgeniy Baskov

This is needed to remove magic numbers from x86 bzImage building tool (arch/x86/boot/tools/build.c).

Quoted 164 lines
---
 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 -1
new file mode 100644
index 000000000000..41c09ec371d8
@@ -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 */
--

2.37.4

maintainer Reviewed-by on v4 9/26
#26 lore raw

Re: [PATCH v4 09/26] x86/boot: Remove mapping from page fault handler

In reply to Evgeniy Baskov
Quoted 9 lines · Evgeniy Baskov

After 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.

Quoted 49 lines
---
 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 -17
index fec795a4ce23..ba5108c58a4e 100644
@@ -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);
 }
--

2.37.4

maintainer
#42 lore raw

Re: [PATCH v4 15/26] efi/x86: Support extracting kernel from libstub

In reply to Evgeniy Baskov
Quoted 10 lines · Evgeniy Baskov

Doing 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.

Some more comments - apologies for the multi stage approach ...

Quoted 12 lines
---
 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

...

drivers/firmware/efi/Kconfig config EFI_DXE_MEM_ATTRIBUTES · line 62

Quoted 10 lines
drivers/firmware/efi/Kconfig +2 -0
index 043ca31c114e..f50c2a84a754 100644
@@ -58,6 +58,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.

images

Quoted 48 lines
drivers/firmware/efi/Kconfig +0 -0
 config EFI_PARAMS_FROM_FDT
        bool
drivers/firmware/efi/libstub/Makefile +1 -1
index be8b8c6e8b40..99b81c95344c 100644
@@ -88,7 +88,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.o arm64-stub.o arm64-entry.o smbios.o
-lib-$(CONFIG_X86)              += x86-stub.o
+lib-$(CONFIG_X86)              += x86-stub.o x86-extract-direct.o
 lib-$(CONFIG_RISCV)            += riscv.o riscv-stub.o
 lib-$(CONFIG_LOONGARCH)                += loongarch.o loongarch-stub.o
 
drivers/firmware/efi/libstub/x86-extract-direct.c new file +26 -0
new file mode 100644
index 000000000000..4ecbc4a9b3ed
@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <linux/acpi.h>
+#include <linux/efi.h>
+#include <linux/elf.h>
+#include <linux/stddef.h>
+
+#include <asm/efi.h>
+#include <asm/e820/types.h>
+#include <asm/desc.h>
+#include <asm/boot.h>
+#include <asm/bootparam_utils.h>
+#include <asm/shared/extract.h>
+#include <asm/shared/pgtable.h>
+
+#include "efistub.h"
+#include "x86-stub.h"
+
+static efi_handle_t image_handle;
+
+static void do_puthex(unsigned long value)
+{
+       efi_printk("%08lx", value);
+}
+
+static void do_putstr(const char *msg)

drivers/firmware/efi/libstub/x86-extract-direct.c line 36

Quoted 10 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +10 -0
+{
+       efi_printk("%s", msg);
+}
+
+static unsigned long do_map_range(unsigned long start,
+                                 unsigned long end,
+                                 unsigned int flags)
+{
+       efi_status_t status;
+

Please drop this newline.

drivers/firmware/efi/libstub/x86-extract-direct.c line 48

Quoted 12 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +12 -0
+       unsigned long size = end - start;
+
+       if (flags & MAP_ALLOC) {
+               unsigned long addr;
+
+               status = efi_low_alloc_above(size, CONFIG_PHYSICAL_ALIGN,
+                                            &addr, start);
+               if (status != EFI_SUCCESS) {
+                       efi_err("Unable to allocate memory for uncompressed kernel");
+                       efi_exit(image_handle, EFI_OUT_OF_RESOURCES);
+               }
+

OK, so this is the place where the chosen address for deompressing the kernel is actually allocated and carved out in the EFI memory map. Could you add a comment here so other folks won't be confused like I was how this is put together?

Quoted 36 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +36 -0
+               if (start != addr) {
+                       efi_debug("Unable to allocate at given address"
+                                 " (desired=0x%lx, actual=0x%lx)",
+                                 (unsigned long)start, addr);
+                       start = addr;
+               }
+       }
+
+       if ((flags & (MAP_PROTECT | MAP_ALLOC)) &&
+           IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               unsigned long attr = 0;
+
+               if (!(flags & MAP_EXEC))
+                       attr |= EFI_MEMORY_XP;
+
+               if (!(flags & MAP_WRITE))
+                       attr |= EFI_MEMORY_RO;
+
+               status = efi_adjust_memory_range_protection(start, size, attr);
+               if (status != EFI_SUCCESS)
+                       efi_err("Unable to protect memory range");
+       }
+
+       return start;
+}
+
+/*
+ * Trampoline takes 3 pages and can be loaded in first megabyte of memory
+ * with its end placed between 0 and 640k where BIOS might start.
+ * (see arch/x86/boot/compressed/pgtable_64.c)
+ */
+
+#ifdef CONFIG_64BIT
+static efi_status_t prepare_trampoline(void)
+{
+       efi_status_t status;

drivers/firmware/efi/libstub/x86-extract-direct.c line 94

Quoted 10 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +10 -0
+
+       status = efi_allocate_pages(TRAMPOLINE_32BIT_SIZE,
+                                   (unsigned long *)&trampoline_32bit,
+                                   TRAMPOLINE_32BIT_PLACEMENT_MAX);
+
+       if (status != EFI_SUCCESS)
+               return status;
+
+       unsigned long trampoline_start = (unsigned long)trampoline_32bit;
+

Please put all variable declarations at the start of the block

drivers/firmware/efi/libstub/x86-extract-direct.c line 107

Quoted 13 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +13 -0
+       memset(trampoline_32bit, 0, TRAMPOLINE_32BIT_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               /* First page of trampoline is a top level page table */
+               efi_adjust_memory_range_protection(trampoline_start,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       /* Second page of trampoline is the code (with a padding) */
+
+       void *caddr = (void *)trampoline_32bit + TRAMPOLINE_32BIT_CODE_OFFSET;
+

same here

Quoted 30 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +30 -0
+       memcpy(caddr, trampoline_32bit_src, TRAMPOLINE_32BIT_CODE_SIZE);
+
+       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES)) {
+               efi_adjust_memory_range_protection((unsigned long)caddr,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_RO);
+
+               /* And the last page of trampoline is the stack */
+
+               efi_adjust_memory_range_protection(trampoline_start + 2 * PAGE_SIZE,
+                                                  PAGE_SIZE,
+                                                  EFI_MEMORY_XP);
+       }
+
+       return EFI_SUCCESS;
+}
+#else
+static inline efi_status_t prepare_trampoline(void)
+{
+       return EFI_SUCCESS;
+}
+#endif
+
+static efi_status_t init_loader_data(efi_handle_t handle,
+                                    struct boot_params *params,
+                                    struct efi_boot_memmap **map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+       efi_status_t status;
+

drivers/firmware/efi/libstub/x86-extract-direct.c line 147

Quoted 10 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +10 -0
+       status = efi_get_memory_map(map, false);
+
+       if (status != EFI_SUCCESS) {
+               efi_err("Unable to get EFI memory map...\n");
+               return status;
+       }
+
+       const char *signature = efi_is_64bit() ? EFI64_LOADER_SIGNATURE
+                                              : EFI32_LOADER_SIGNATURE;
+

Move this to the start

Quoted 36 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +36 -0
+       memcpy(&efi->efi_loader_signature, signature, sizeof(__u32));
+
+       efi->efi_memdesc_size = (*map)->desc_size;
+       efi->efi_memdesc_version = (*map)->desc_ver;
+       efi->efi_memmap_size = (*map)->map_size;
+
+       efi_set_u64_split((unsigned long)(*map)->map,
+                         &efi->efi_memmap, &efi->efi_memmap_hi);
+
+       efi_set_u64_split((unsigned long)efi_system_table,
+                         &efi->efi_systab, &efi->efi_systab_hi);
+
+       image_handle = handle;
+
+       return EFI_SUCCESS;
+}
+
+static void free_loader_data(struct boot_params *params, struct efi_boot_memmap *map)
+{
+       struct efi_info *efi = (void *)&params->efi_info;
+
+       efi_bs_call(free_pool, map);
+
+       efi->efi_memdesc_size = 0;
+       efi->efi_memdesc_version = 0;
+       efi->efi_memmap_size = 0;
+       efi_set_u64_split(0, &efi->efi_memmap, &efi->efi_memmap_hi);
+}
+
+extern unsigned char input_data[];
+extern unsigned int input_len, output_len;
+
+unsigned long extract_kernel_direct(efi_handle_t handle, struct boot_params *params)
+{
+
+       void *res;

drivers/firmware/efi/libstub/x86-extract-direct.c line 193

Quoted 10 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +10 -0
+       efi_status_t status;
+       struct efi_extract_callbacks cb = { 0 };
+
+       status = prepare_trampoline();
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       /* Prepare environment for do_extract_kernel() call */
+       struct efi_boot_memmap *map = NULL;

Move this to the start.

Quoted 219 lines
drivers/firmware/efi/libstub/x86-extract-direct.c new file +15 -0
+       status = init_loader_data(handle, params, &map);
+
+       if (status != EFI_SUCCESS)
+               return 0;
+
+       cb.puthex = do_puthex;
+       cb.putstr = do_putstr;
+       cb.map_range = do_map_range;
+
+       res = efi_extract_kernel(params, &cb, input_data, input_len, output_len);
+
+       free_loader_data(params, map);
+
+       return (unsigned long)res;
+}
drivers/firmware/efi/libstub/x86-stub.c +10 -109
index 7fb1eff88a18..1d1ab1911fd3 100644
@@ -17,6 +17,7 @@
 #include <asm/boot.h>
 
 #include "efistub.h"
+#include "x86-stub.h"
 
 /* Maximum physical address for 64-bit kernel with 4-level paging */
 #define MAXMEM_X86_64_4LEVEL (1ull << 46)
@@ -24,7 +25,7 @@
 const efi_system_table_t *efi_system_table;
 const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
-static efi_loaded_image_t *image = NULL;
+static efi_loaded_image_t *image __section(".data");
 
 static efi_status_t
 preserve_pci_rom_image(efi_pci_io_protocol_t *pci, struct pci_setup_rom **__rom)
@@ -212,55 +213,9 @@ static void retrieve_apple_device_properties(struct boot_params *boot_params)
        }
 }
 
-/*
- * Trampoline takes 2 pages and can be loaded in first megabyte of memory
- * with its end placed between 128k and 640k where BIOS might start.
- * (see arch/x86/boot/compressed/pgtable_64.c)
- *
- * We cannot find exact trampoline placement since memory map
- * can be modified by UEFI, and it can alter the computed address.
- */
-
-#define TRAMPOLINE_PLACEMENT_BASE ((128 - 8)*1024)
-#define TRAMPOLINE_PLACEMENT_SIZE (640*1024 - (128 - 8)*1024)
-
-void startup_32(struct boot_params *boot_params);
-
-static void
-setup_memory_protection(unsigned long image_base, unsigned long image_size)
-{
-       /*
-        * Allow execution of possible trampoline used
-        * for switching between 4- and 5-level page tables
-        * and relocated kernel image.
-        */
-
-       efi_adjust_memory_range_protection(TRAMPOLINE_PLACEMENT_BASE,
-                                          TRAMPOLINE_PLACEMENT_SIZE, 0);
-
-#ifdef CONFIG_64BIT
-       if (image_base != (unsigned long)startup_32)
-               efi_adjust_memory_range_protection(image_base, image_size, 0);
-#else
-       /*
-        * Clear protection flags on a whole range of possible
-        * addresses used for KASLR. We don't need to do that
-        * on x86_64, since KASLR/extraction is performed after
-        * dedicated identity page tables are built and we only
-        * need to remove possible protection on relocated image
-        * itself disregarding further relocations.
-        */
-       efi_adjust_memory_range_protection(LOAD_PHYSICAL_ADDR,
-                                          KERNEL_IMAGE_SIZE - LOAD_PHYSICAL_ADDR,
-                                          0);
-#endif
-}
-
 static const efi_char16_t apple[] = L"Apple";
 
-static void setup_quirks(struct boot_params *boot_params,
-                        unsigned long image_base,
-                        unsigned long image_size)
+static void setup_quirks(struct boot_params *boot_params)
 {
        efi_char16_t *fw_vendor = (efi_char16_t *)(unsigned long)
                efi_table_attr(efi_system_table, fw_vendor);
@@ -269,9 +224,6 @@ static void setup_quirks(struct boot_params *boot_params,
                if (IS_ENABLED(CONFIG_APPLE_PROPERTIES))
                        retrieve_apple_device_properties(boot_params);
        }
-
-       if (IS_ENABLED(CONFIG_EFI_DXE_MEM_ATTRIBUTES))
-               setup_memory_protection(image_base, image_size);
 }
 
 /*
@@ -384,7 +336,7 @@ static void setup_graphics(struct boot_params *boot_params)
 }
 
 
-static void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
+void __noreturn efi_exit(efi_handle_t handle, efi_status_t status)
 {
        efi_bs_call(exit, handle, status, 0, NULL);
        for(;;)
@@ -707,8 +659,7 @@ static efi_status_t exit_boot(struct boot_params *boot_params, void *handle)
 }
 
 /*
- * On success, we return the address of startup_32, which has potentially been
- * relocated by efi_relocate_kernel.
+ * On success, we return extracted kernel entry point.
  * On failure, we exit to the firmware via efi_exit instead of returning.
  */
 asmlinkage unsigned long efi_main(efi_handle_t handle,
@@ -733,60 +684,6 @@ asmlinkage unsigned long efi_main(efi_handle_t handle,
                efi_dxe_table = NULL;
        }
 
-       /*
-        * If the kernel isn't already loaded at a suitable address,
-        * relocate it.
-        *
-        * It must be loaded above LOAD_PHYSICAL_ADDR.
-        *
-        * The maximum address for 64-bit is 1 << 46 for 4-level paging. This
-        * is defined as the macro MAXMEM, but unfortunately that is not a
-        * compile-time constant if 5-level paging is configured, so we instead
-        * define our own macro for use here.
-        *
-        * For 32-bit, the maximum address is complicated to figure out, for
-        * now use KERNEL_IMAGE_SIZE, which will be 512MiB, the same as what
-        * KASLR uses.
-        *
-        * Also relocate it if image_offset is zero, i.e. the kernel wasn't
-        * loaded by LoadImage, but rather by a bootloader that called the
-        * handover entry. The reason we must always relocate in this case is
-        * to handle the case of systemd-boot booting a unified kernel image,
-        * which is a PE executable that contains the bzImage and an initrd as
-        * COFF sections. The initrd section is placed after the bzImage
-        * without ensuring that there are at least init_size bytes available
-        * for the bzImage, and thus the compressed kernel's startup code may
-        * overwrite the initrd unless it is moved out of the way.
-        */
-
-       buffer_start = ALIGN(bzimage_addr - image_offset,
-                            hdr->kernel_alignment);
-       buffer_end = buffer_start + hdr->init_size;
-
-       if ((buffer_start < LOAD_PHYSICAL_ADDR)                              ||
-           (IS_ENABLED(CONFIG_X86_32) && buffer_end > KERNEL_IMAGE_SIZE)    ||
-           (IS_ENABLED(CONFIG_X86_64) && buffer_end > MAXMEM_X86_64_4LEVEL) ||
-           (image_offset == 0)) {
-               extern char _bss[];
-
-               status = efi_relocate_kernel(&bzimage_addr,
-                                            (unsigned long)_bss - bzimage_addr,
-                                            hdr->init_size,
-                                            hdr->pref_address,
-                                            hdr->kernel_alignment,
-                                            LOAD_PHYSICAL_ADDR);
-               if (status != EFI_SUCCESS) {
-                       efi_err("efi_relocate_kernel() failed!\n");
-                       goto fail;
-               }
-               /*
-                * Now that we've copied the kernel elsewhere, we no longer
-                * have a set up block before startup_32(), so reset image_offset
-                * to zero in case it was set earlier.
-                */
-               image_offset = 0;
-       }
-
 #ifdef CONFIG_CMDLINE_BOOL
        status = efi_parse_options(CONFIG_CMDLINE);
        if (status != EFI_SUCCESS) {
@@ -843,7 +740,11 @@ asmlinkage unsigned long efi_main(efi_handle_t handle,
 
        setup_efi_pci(boot_params);
 
-       setup_quirks(boot_params, bzimage_addr, buffer_end - buffer_start);
+       setup_quirks(boot_params);
+
+       bzimage_addr = extract_kernel_direct(handle, boot_params);
+       if (!bzimage_addr)
+               goto fail;
 
        status = exit_boot(boot_params, handle);
        if (status != EFI_SUCCESS) {
drivers/firmware/efi/libstub/x86-stub.h new file +14 -1
new file mode 100644
index 000000000000..baecc7c6e602
@@ -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
--

2.37.4

maintainer
#58 lore raw

Re: [PATCH v4 20/26] x86/build: Make generated PE more spec compliant

In reply to Evgeniy Baskov
Quoted 18 lines · Evgeniy Baskov

Currently 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.

Quoted 5 lines

[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

I would prefer it if we didn't rewrite the build tool this way.

Having the sections in header.S in the order they appear in the binary is rather useful, and I don't think we should manipulate the section flags based on whether CONFIG_DXE_MEM_ATTRIBUTES is set. I also don't think we need more than .text / .,data (as discussed in the other thread on linux-efi@)

Furthermore, I had a look at the audk PE loader [0], and I think it is being overly pedantic.

The PE/COFF spec does not require that all sections are virtually contiguous, and it does not require that the file content is completely covered by either the header or by a section.

So what I would prefer to do is the following:

Sections:

Idx Name          Size     VMA              Type
  0 .reloc        00000200 0000000000002000 DATA
  1 .compat       00000200 0000000000003000 DATA
  2 .text         00bee000 0000000000004000 TEXT
  3 .data         00002200 0000000000bf2000 DATA

using 4k section alignment and 512 byte file alignment, and a header size of 0x200 as before (This requires my patch that allows the setup header to remain unmapped when running the stub [1])

The reloc and compat payloads are placed at the end of the setup data as before, but increased in size to 512 bytes each, and then mapped non-1:1 into the RVA space.

This works happily with both the existing PE loader as well as the audk one, but with the pedantic flags disabled.

[0] https://github.com/acidanthera/audk
[1] https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=84412899c16c65af13dac305aa01a5a85e08c69e

Quoted 570 lines
---
 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
index 9e38ffaadb5d..bed78c82238e 100644
@@ -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
index 9fec80bc504b..07e31ddb074f 100644
@@ -94,6 +94,7 @@ bugger_off_msg:
        .set    bugger_off_msg_size, . - bugger_off_msg
 
 #ifdef CONFIG_EFI_STUB
+       .align 8
 pe_header:
        .long   PE_MAGIC
 
@@ -107,7 +108,7 @@ coff_header:
        .set    pe_opt_magic, PE_OPT_MAGIC_PE32PLUS
        .word   IMAGE_FILE_MACHINE_AMD64
 #endif
-       .word   section_count                   # nr_sections
+       .word   0                               # nr_sections
        .long   0                               # TimeDateStamp
        .long   0                               # PointerToSymbolTable
        .long   1                               # NumberOfSymbols
@@ -131,7 +132,7 @@ optional_header:
        # Filled in by build.c
        .long   0x0000                          # AddressOfEntryPoint
 
-       .long   0x0200                          # BaseOfCode
+       .long   0x1000                          # BaseOfCode
 #ifdef CONFIG_X86_32
        .long   0                               # data
 #endif
@@ -144,8 +145,8 @@ extra_header_fields:
 #else
        .quad   image_base                      # ImageBase
 #endif
-       .long   0x20                            # SectionAlignment
-       .long   0x20                            # FileAlignment
+       .long   0x1000                          # SectionAlignment
+       .long   0x200                           # FileAlignment
        .word   0                               # MajorOperatingSystemVersion
        .word   0                               # MinorOperatingSystemVersion
        .word   LINUX_EFISTUB_MAJOR_VERSION     # MajorImageVersion
@@ -188,91 +189,14 @@ extra_header_fields:
        .quad   0                               # CertificationTable
        .quad   0                               # BaseRelocationTable
 
-       # Section table
-section_table:
-       #
-       # The offset & size fields are filled in by build.c.
-       #
-       .ascii  ".setup"
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # Size of initialized data
-                                               # on disk
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_CODE              | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_EXECUTE           | \
-               IMAGE_SCN_ALIGN_16BYTES         # Characteristics
-
-       #
-       # The EFI application loader requires a relocation section
-       # because EFI applications must be relocatable. The .reloc
-       # offset & size fields are filled in by build.c.
        #
-       .ascii  ".reloc"
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0
-       .long   0                               # SizeOfRawData
-       .long   0                               # PointerToRawData
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_INITIALIZED_DATA  | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_DISCARDABLE       | \
-               IMAGE_SCN_ALIGN_1BYTES          # Characteristics
-
-#ifdef CONFIG_EFI_MIXED
-       #
-       # The offset & size fields are filled in by build.c.
+       # Section table
+       # It is generated by build.c and here we just need
+       # to reserve some space for sections
        #
-       .asciz  ".compat"
-       .long   0
-       .long   0x0
-       .long   0                               # Size of initialized data
-                                               # on disk
-       .long   0x0
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_INITIALIZED_DATA  | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_DISCARDABLE       | \
-               IMAGE_SCN_ALIGN_1BYTES          # Characteristics
-#endif
+section_table:
+       .fill 40*5, 1, 0
 
-       #
-       # The offset & size fields are filled in by build.c.
-       #
-       .ascii  ".text"
-       .byte   0
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # Size of initialized data
-                                               # on disk
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_CODE              | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_EXECUTE           | \
-               IMAGE_SCN_ALIGN_16BYTES         # Characteristics
-
-       .set    section_count, (. - section_table) / 40
 #endif /* CONFIG_EFI_STUB */
 
        # Kernel attributes; used by setup.  This is part 1 of the
arch/x86/boot/tools/build.c +145 -125
index fbc5315af032..ac6159b76a13 100644
@@ -61,8 +61,10 @@ uint8_t buf[SETUP_SECT_MAX*SECTOR_SIZE];
 
 #ifdef CONFIG_EFI_MIXED
 #define PECOFF_COMPAT_RESERVE 0x20
+#define COMPAT_SECTION_SIZE 0x8
 #else
 #define PECOFF_COMPAT_RESERVE 0x0
+#define COMPAT_SECTION_SIZE 0x0
 #endif
 
 #define RELOC_SECTION_SIZE 10
@@ -117,6 +119,7 @@ static unsigned long efi_pe_entry;
 static unsigned long efi32_pe_entry;
 static unsigned long kernel_info;
 static unsigned long startup_64;
+static unsigned long _rodata;
 static unsigned long _ehead;
 static unsigned long _end;
 
@@ -258,122 +261,177 @@ static void *map_output_file(const char *path, size_t size)
 
 #ifdef CONFIG_EFI_STUB
 
-static void update_pecoff_section_header_fields(char *section_name, uint32_t vma,
-                                               uint32_t size, uint32_t datasz,
-                                               uint32_t offset)
+static unsigned int reloc_offset;
+static unsigned int compat_offset;
+
+#define MAX_SECTIONS 5
+
+static void emit_pecoff_section(const char *section_name, unsigned int size,
+                               unsigned int bss, unsigned int *file_offset,
+                               unsigned int *mem_offset, uint32_t flags)
 {
-       unsigned int pe_header;
+       unsigned int section_memsz, section_filesz;
+       unsigned int name_len;
        unsigned short num_sections;
+       struct pe_hdr *hdr = get_pe_header(buf);
        struct section_header *section;
 
-       struct pe_hdr *hdr = get_pe_header(buf);
        num_sections = get_unaligned_le16(&hdr->sections);
-       section = get_sections(buf);
+       if (num_sections >= MAX_SECTIONS)
+               die("Not enough space to generate all sections");
 
-       while (num_sections > 0) {
-               if (strncmp(section->name, section_name, 8) == 0) {
-                       /* section header size field */
-                       put_unaligned_le32(size, &section->virtual_size);
+       section = get_sections(buf) + num_sections;
 
-                       /* section header vma field */
-                       put_unaligned_le32(vma, &section->virtual_address);
+       if ((size & (FILE_ALIGNMENT - 1)) || (bss & (FILE_ALIGNMENT - 1)))
+               die("Section '%s' is improperly aligned", section_name);
 
-                       /* section header 'size of initialised data' field */
-                       put_unaligned_le32(datasz, &section->raw_data_size);
+       section_memsz = round_up(size + bss, SECTION_ALIGNMENT);
+       section_filesz = round_up(size, FILE_ALIGNMENT);
 
-                       /* section header 'file offset' field */
-                       put_unaligned_le32(offset, &section->data_addr);
+       /* Zero out all section fields */
+       memset(section, 0, sizeof(*section));
 
-                       break;
-               }
-               section++;
-               num_sections--;
-       }
-}
+       name_len = strlen(section_name);
+       if (name_len > sizeof(section->name))
+               name_len = sizeof(section_name);
 
-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);
+       /* Section header size field */
+       memcpy(section->name, section_name, name_len);
+
+       put_unaligned_le32(section_memsz, &section->virtual_size);
+       put_unaligned_le32(*mem_offset, &section->virtual_address);
+       put_unaligned_le32(section_filesz, &section->raw_data_size);
+       put_unaligned_le32(*file_offset, &section->data_addr);
+       put_unaligned_le32(flags, &section->flags);
+
+       put_unaligned_le16(num_sections + 1, &hdr->sections);
+
+       *mem_offset += section_memsz;
+       *file_offset += section_filesz;
 }
 
-static void update_pecoff_setup_and_reloc(unsigned int size)
+#define BASE_RVA 0x1000
+
+static unsigned int text_rva;
+
+static unsigned int update_pecoff_sections(unsigned int setup_size,
+                                          unsigned int file_size,
+                                          unsigned int virt_size,
+                                          unsigned int text_size)
 {
-       uint32_t setup_offset = SECTOR_SIZE;
-       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE - PECOFF_COMPAT_RESERVE;
-#ifdef CONFIG_EFI_MIXED
-       uint32_t compat_offset = reloc_offset + PECOFF_RELOC_RESERVE;
-#endif
-       uint32_t setup_size = reloc_offset - setup_offset;
+       /* First section starts at 512 byes, after PE header */
+       unsigned int mem_offset = BASE_RVA, file_offset = SECTOR_SIZE;
+       unsigned int compat_size, reloc_size;
+       unsigned int bss_size, text_rva_diff, reloc_rva;
+       pe_opt_hdr  *opt_hdr = get_pe_opt_header(buf);
+       struct pe_hdr *hdr = get_pe_header(buf);
+       struct data_dirent *base_reloc;
+
+       if (get_unaligned_le32(&hdr->sections))
+               die("Some sections present in PE file");
 
-       update_pecoff_section_header(".setup", setup_offset, setup_size);
-       update_pecoff_section_header(".reloc", reloc_offset, PECOFF_RELOC_RESERVE);
+       reloc_size = round_up(RELOC_SECTION_SIZE, FILE_ALIGNMENT);
+       compat_size = round_up(COMPAT_SECTION_SIZE, FILE_ALIGNMENT);
+       virt_size = round_up(virt_size, SECTION_ALIGNMENT);
 
        /*
-        * Modify .reloc section contents with a single entry. The
-        * relocation is applied to offset 10 of the relocation section.
+        * Update sections offsets.
+        * NOTE: Order is important
         */
-       put_unaligned_le32(reloc_offset + RELOC_SECTION_SIZE, &buf[reloc_offset]);
-       put_unaligned_le32(RELOC_SECTION_SIZE, &buf[reloc_offset + 4]);
 
+       bss_size = virt_size - file_size;
+
+       emit_pecoff_section(".setup", setup_size - SECTOR_SIZE, 0,
+                           &file_offset, &mem_offset, SCN_RO |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA);
+
+       text_rva_diff = mem_offset - file_offset;
+       text_rva = mem_offset;
+       emit_pecoff_section(".text", text_size, 0,
+                           &file_offset, &mem_offset, SCN_RX |
+                           IMAGE_SCN_CNT_CODE);
+
+       /* Check that kernel sections mapping is contiguous */
+       if (text_rva_diff != mem_offset - file_offset)
+               die("Kernel sections mapping is wrong: %#x != %#x",
+                   mem_offset - file_offset, text_rva_diff);
+
+       emit_pecoff_section(".data", file_size - text_size, bss_size,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA);
+
+       reloc_offset = file_offset;
+       reloc_rva = mem_offset;
+       emit_pecoff_section(".reloc", reloc_size, 0,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA |
+                           IMAGE_SCN_MEM_DISCARDABLE);
+
+       compat_offset = file_offset;
 #ifdef CONFIG_EFI_MIXED
-       update_pecoff_section_header(".compat", compat_offset, PECOFF_COMPAT_RESERVE);
+       emit_pecoff_section(".comat", compat_size, 0,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA |
+                           IMAGE_SCN_MEM_DISCARDABLE);
+#endif
 
+       if (file_size + setup_size + reloc_size + compat_size != file_offset)
+               die("file_size(%#x) != filesz(%#x)",
+                   file_size + setup_size + reloc_size + compat_size, file_offset);
+
+       /* Size of code. */
+       put_unaligned_le32(round_up(text_size, SECTION_ALIGNMENT), &opt_hdr->text_size);
        /*
-        * Put the IA-32 machine type (0x14c) and the associated entry point
-        * address in the .compat section, so loaders can figure out which other
-        * execution modes this image supports.
+        * Size of data.
+        * Exclude text size and first sector, which contains PE header.
         */
-       buf[compat_offset] = 0x1;
-       buf[compat_offset + 1] = 0x8;
-       put_unaligned_le16(IMAGE_FILE_MACHINE_I386, &buf[compat_offset + 2]);
-       put_unaligned_le32(efi32_pe_entry + size, &buf[compat_offset + 4]);
-#endif
-}
+       put_unaligned_le32(mem_offset - round_up(text_size, SECTION_ALIGNMENT),
+                          &opt_hdr->data_size);
 
-static unsigned int update_pecoff_sections(unsigned int text_start, unsigned int text_sz,
-                              unsigned int init_sz)
-{
-       unsigned int file_sz = text_start + text_sz;
-       unsigned int bss_sz = init_sz - file_sz;
-       pe_opt_hdr *hdr = get_pe_opt_header(buf);
+       /* Size of image. */
+       put_unaligned_le32(mem_offset, &opt_hdr->image_size);
 
        /*
-        * The PE/COFF loader may load the image at an address which is
-        * misaligned with respect to the kernel_alignment field in the setup
-        * header.
-        *
-        * In order to avoid relocating the kernel to correct the misalignment,
-        * add slack to allow the buffer to be aligned within the declared size
-        * of the image.
+        * Address of entry point for PE/COFF executable
         */
-       bss_sz  += CONFIG_PHYSICAL_ALIGN;
-       init_sz += CONFIG_PHYSICAL_ALIGN;
+       put_unaligned_le32(text_rva + efi_pe_entry, &opt_hdr->entry_point);
 
        /*
-        * Size of code: Subtract the size of the first sector (512 bytes)
-        * which includes the header.
+        * BaseOfCode for PE/COFF executable
         */
-       put_unaligned_le32(file_sz - SECTOR_SIZE + bss_sz, &hdr->text_size);
-
-       /* Size of image */
-       put_unaligned_le32(init_sz, &hdr->image_size);
+       put_unaligned_le32(text_rva, &opt_hdr->code_base);
 
        /*
-        * Address of entry point for PE/COFF executable
+        * Since we have generated .reloc section, we need to
+        * fill-in Reloc directory
         */
-       put_unaligned_le32(text_start + efi_pe_entry, &hdr->entry_point);
+       base_reloc = &get_data_dirs(buf)->base_relocations;
+       put_unaligned_le32(reloc_rva, &base_reloc->virtual_address);
+       put_unaligned_le32(RELOC_SECTION_SIZE, &base_reloc->size);
 
-       update_pecoff_section_header_fields(".text", text_start, text_sz + bss_sz,
-                                           text_sz, text_start);
-
-       return text_start + file_sz;
+       return file_offset;
 }
 
-static int reserve_pecoff_reloc_section(int c)
+static void generate_pecoff_section_data(uint8_t *output)
 {
-       /* Reserve 0x20 bytes for .reloc section */
-       memset(buf+c, 0, PECOFF_RELOC_RESERVE);
-       return PECOFF_RELOC_RESERVE;
+       /*
+        * Modify .reloc section contents with a two entries. The
+        * relocation is applied to offset 10 of the relocation section.
+        */
+       put_unaligned_le32(reloc_offset + RELOC_SECTION_SIZE, &output[reloc_offset]);
+       put_unaligned_le32(RELOC_SECTION_SIZE, &output[reloc_offset + 4]);
+
+#ifdef CONFIG_EFI_MIXED
+       /*
+        * Put the IA-32 machine type (0x14c) and the associated entry point
+        * address in the .compat section, so loaders can figure out which other
+        * execution modes this image supports.
+        */
+       output[compat_offset] = 0x1;
+       output[compat_offset + 1] = 0x8;
+       put_unaligned_le16(IMAGE_FILE_MACHINE_I386, &output[compat_offset + 2]);
+       put_unaligned_le32(efi32_pe_entry + text_rva, &output[compat_offset + 4]);
+#endif
 }
 
 static void efi_stub_update_defaults(void)
@@ -407,26 +465,10 @@ static void efi_stub_entry_update(void)
 
 #else
 
-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_update_defaults(void) {}
-static inline void efi_stub_entry_update(void) {}
+static void efi_stub_update_defaults(void) {}
 
-static inline int reserve_pecoff_reloc_section(int c)
-{
-       return 0;
-}
 #endif /* CONFIG_EFI_STUB */
 
-static int reserve_pecoff_compat_section(int c)
-{
-       /* Reserve 0x20 bytes for .compat section */
-       memset(buf+c, 0, PECOFF_COMPAT_RESERVE);
-       return PECOFF_COMPAT_RESERVE;
-}
-
 /*
  * Parse zoffset.h and find the entry points. We could just #include zoffset.h
  * but that would mean tools/build would have to be rebuilt every time. It's
@@ -456,6 +498,7 @@ static void parse_zoffset(char *fname)
                PARSE_ZOFS(p, efi32_pe_entry);
                PARSE_ZOFS(p, kernel_info);
                PARSE_ZOFS(p, startup_64);
+               PARSE_ZOFS(p, _rodata);
                PARSE_ZOFS(p, _ehead);
                PARSE_ZOFS(p, _end);
 
@@ -489,10 +532,6 @@ static unsigned int read_setup(char *path)
 
        fclose(file);
 
-       /* 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_size = round_up(file_size, SECTOR_SIZE);
@@ -515,7 +554,6 @@ 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;
@@ -540,8 +578,7 @@ int main(int argc, char **argv)
 
 #ifdef CONFIG_EFI_STUB
        /* 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);
+       kern_size = round_up(kern_file_size + 4, FILE_ALIGNMENT);
 #else
        /* Number of 16-byte paragraphs, including space for a 4-byte CRC */
        kern_size = round_up(kern_file_size + 4, PARAGRAPH_SIZE);
@@ -554,33 +591,12 @@ int main(int argc, char **argv)
        /* Update kernel_info offset. */
        put_unaligned_le32(kernel_info, &buf[0x268]);
 
-       init_size = get_unaligned_le32(&buf[0x260]);
-
 #ifdef CONFIG_EFI_STUB
-       /*
-        * The decompression buffer will start at ImageBase. When relocating
-        * the compressed kernel to its end, we must ensure that the head
-        * section does not get overwritten.  The head section occupies
-        * [i, i + _ehead), and the destination is [init_sz - _end, init_sz).
-        *
-        * At present these should never overlap, because 'i' is at most 32k
-        * because of SETUP_SECT_MAX, '_ehead' is less than 1k, and the
-        * calculation of INIT_SIZE in boot/header.S ensures that
-        * 'init_sz - _end' is at least 64k.
-        *
-        * For future-proofing, increase init_sz if necessary.
-        */
-
-       if (init_size - _end < setup_size + _ehead) {
-               init_size = round_up(setup_size + _ehead + _end, SECTION_ALIGNMENT);
-               put_unaligned_le32(init_size, &buf[0x260]);
-       }
 
-       total_size = update_pecoff_sections(setup_size, kern_size, init_size);
+       total_size = update_pecoff_sections(setup_size, kern_size, _end, _rodata);
 
        efi_stub_entry_update();
 #else
-       (void)init_size;
        total_size = setup_size + kern_size;
 #endif
 
@@ -590,6 +606,10 @@ int main(int argc, char **argv)
        memcpy(output + setup_size, kernel, kern_file_size);
        memset(output + setup_size + kern_file_size, 0, kern_size - kern_file_size);
 
+#ifdef CONFIG_EFI_STUB
+       generate_pecoff_section_data(output);
+#endif
+
        /* Calculate and write kernel checksum. */
        crc = partial_crc32(output, total_size - 4, crc);
        put_unaligned_le32(crc, &output[total_size - 4]);
drivers/firmware/efi/libstub/x86-stub.c +5 -3
index 1d1ab1911fd3..1f0a2e7075c3 100644
@@ -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));
 
        /*
--

2.37.4

maintainer
#65 lore raw

Re: [PATCH v4 21/26] efi/x86: Explicitly set sections memory attributes

In reply to Evgeniy Baskov
Quoted 9 lines · Evgeniy Baskov

Explicitly 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.

I don't think we need this patch. Firmware that cares about W^X will map the PE image with R-X for text/rodata and RW- for data/bss, which is sufficient, and firmware that doesn't is a lost cause anyway.

Quoted 86 lines
---
 drivers/firmware/efi/libstub/x86-stub.c | 54 +++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
drivers/firmware/efi/libstub/x86-stub.c +54 -1
index 1f0a2e7075c3..60697fcd8950 100644
@@ -27,6 +27,12 @@ const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
 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) {
--

2.37.4

maintainer
#71 lore raw

Re: [PATCH v4 23/26] efi/libstub: Use memory attribute protocol

In reply to Evgeniy Baskov
Quoted 7 lines · Evgeniy Baskov

Add 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.

Quoted 6 lines

Move DXE services initialization code closer to the place they are used to match EFI_MEMORY_ATTRIBUTE_PROTOCOL initialization code.

I'm not convinced about the use of the DXE services for this, and I think we should replace this patch with changes that base all the new protection code on the EFI memory attributes protocol only.

We introduced that DXE code to remove protections from memory that was mapped read-only and/or non-executable, and described as such in the GCD memory map.

Using it to manipulate restricted permissions like this is quite a different thing, and sadly (at least in EDK2), the GCD system memory map is not kept in sync with the updated permissions, i.e, the W^X protections for loaded images and the NX protection for arbitrary page allocations are both based on the PI CPU arch protocol, which manipulates the page tables directly, but does not record the modified attributes in the GCD or EFI memory maps, as this would result in massive fragmentation and break lots of other things.

That means that, except for the specific use case for which we introduced the DXE services calls, the only reliable way to figure out what permission attributes a certain range of memory is using is the EFI memory attributes protocol, and I don't think we should use anything else for tightening down these protections.

Quoted 260 lines
---
 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
index 3e47e5931f04..07d54c88c62e 100644
@@ -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
@@ -129,66 +132,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;
                }
 
@@ -230,3 +214,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 -18
index 60697fcd8950..06a62b121521 100644
@@ -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;
 u32 image_offset __section(".data");
 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
--

2.37.4

#3 lore raw

Re: [PATCH v4 01/26] x86/boot: Align vmlinuz sections on page size

In reply to Ard Biesheuvel
Quoted 14 lines · Ard Biesheuvel
Quoted 13 lines · Evgeniy Baskov

To 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(+)
Quoted 14 lines

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 33

Quoted 12 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
index 112b2375d021..6be90f1a1198 100644
@@ -27,21 +27,27 @@ SECTIONS
                HEAD_TEXT
                _ehead = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata..compressed : {
+               _compressed = .;
                *(.rodata..compressed)

Can you just move this bit into the rodata section below?

I don't think that easily possible, as the layout need to stay compatible with in-place extraction for non-UEFI boot. For that execution path the code in .head.text moves everything behind it to the end of the extraction buffer and extraction code overwrites compressed kernel blob progressively during extraction. And that is why we have effectively have two code sections...

Quoted 6 lines

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 37

Quoted 5 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
+               _ecompressed = .;
        }
+       . = ALIGN(PAGE_SIZE);
        .text : {
Quoted 6 lines

Please use

.text : ALIGN(PAGE_SIZE) {

which marks the section as being page aligned, rather than just being placed on a 4k boundary.

Will fix in v5.

Quoted 20 lines
Quoted 20 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -1
                _text = .;      /* Text */
                *(.text)
                *(.text.*)
                _etext = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata : {
                _rodata = . ;
                *(.rodata)       /* read-only data */
                *(.rodata.*)
                _erodata = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .data : {
                _data = . ;
                *(.data)
--

2.37.4

#7 lore raw

Re: [PATCH v4 02/26] x86/build: Remove RWX sections and align on 4KB

In reply to Ard Biesheuvel
Quoted 21 lines · Ard Biesheuvel
Quoted 16 lines · Evgeniy Baskov

Avoid 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.

Quoted 3 lines
Quoted 7 lines

One nit: the series modifies both the decompressor linker script and the core kernel one, so please make it very explicit in the commit log which one is being modified, and why it matters for this particular context.

Thanks! I'll amend the log.

Quoted 51 lines
Quoted 51 lines
---
 arch/x86/kernel/vmlinux.lds.S | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)
arch/x86/kernel/vmlinux.lds.S +7 -7
index 2e0ee14229bf..2e56d694c491 100644
@@ -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);          /* ___ */
 }
 
@@ -227,9 +226,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

arch/x86/kernel/vmlinux.lds.S +1 -1
@@ -241,6 +241,7 @@ SECTIONS
        .altinstr_aux : AT(ADDR(.altinstr_aux) - LOAD_OFFSET) {
                *(.altinstr_aux)
        }
+       :init
 
        INIT_DATA_SECTION(16)
 
--

2.37.4

#31 lore raw

Re: [PATCH v4 12/26] x86/boot: Make kernel_add_identity_map() a pointer

In reply to Ard Biesheuvel
Quoted 15 lines · Ard Biesheuvel
Quoted 14 lines · Evgeniy Baskov

Convert 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(-)
Quoted 15 lines

arch/x86/boot/compressed/ident_map_64.c bool has_nx; /* set in head_64.S */ · line 95

Quoted 12 lines
arch/x86/boot/compressed/ident_map_64.c +1 -3
index ba5108c58a4e..1aee524d3c2b 100644
@@ -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,

Please use a more discriminating name here - the trailing _ is rather hard to spot.

Got it. The kernel_add_identity_map_impl() will fit better, I think.

Quoted 23 lines
Quoted 23 lines
arch/x86/boot/compressed/ident_map_64.c +3 -0
+                                      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 +0 -0
index aa4a22bc9cf9..c9c235d65d16 100644
@@ -275,6 +275,22 @@ static void parse_elf(void *output, unsigned long 
 output_len,
        free(phdrs);
 }
 
Quoted 15 lines

arch/x86/boot/compressed/misc.c static void parse_elf(void *output, unsigned long output_len,

Quoted 11 lines
arch/x86/boot/compressed/misc.c +10 -0
+/*
+ * 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,

This function is never called, it only has its address taken, so the 'inline' makes no sense here.

Indeed. I'll remove the inline.

Quoted 16 lines
Quoted 16 lines
arch/x86/boot/compressed/misc.c +2 -0
+                                                         unsigned 
 long end,
+                                                         unsigned int 

flags)

arch/x86/boot/compressed/misc.c +4 -0
+{
+       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

arch/x86/boot/compressed/misc.c +0 -0
@@ -312,6 +328,14 @@ asmlinkage __visible void *extract_kernel(void 
 *rmode, memptr heap,
 
Quoted 7 lines

arch/x86/boot/compressed/misc.c asmlinkage __visible void *extract_kernel(void *rmode, memptr heap,

Quoted 5 lines
arch/x86/boot/compressed/misc.c +2 -0
        init_default_io_ops();
 
+       /*
+        * On 64-bit this pointer is set during page table 
 uninitialization,

initialization

Thanks!

Quoted 44 lines
Quoted 44 lines
arch/x86/boot/compressed/misc.c +1 -0
+        * but on 32-bit it remains uninitialized, since paging is 

disabled.

arch/x86/boot/compressed/misc.c +3 -0
+        */
+       if (IS_ENABLED(CONFIG_X86_32))
+               kernel_add_identity_map = 

kernel_add_identity_map_dummy;

arch/x86/boot/compressed/misc.c +2 -0
+
+
        /*
         * Detect TDX guest environment.
         *
arch/x86/boot/compressed/misc.h +3 -12
index 38d31bec062d..0076b2845b4b 100644
@@ -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;

--
2.37.4

#34 lore raw

Re: [PATCH v4 13/26] x86/boot: Split trampoline and pt init code

In reply to Ard Biesheuvel
Quoted 123 lines · Ard Biesheuvel
Quoted 91 lines · Evgeniy Baskov

When 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 +1 -4
index c7cf5a1059a8..1f7169248612 100644
@@ -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(). */

arch/x86/boot/compressed/pgtable_64.c +0 -21
-       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);

arch/x86/boot/compressed/pgtable_64.c +4 -0
+       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.

arch/x86/boot/compressed/pgtable_64.c +0 -0
@@ -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))

arch/x86/boot/compressed/pgtable_64.c +2 -1
+       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.

arch/x86/boot/compressed/pgtable_64.c +0 -0
@@ -185,6 +165,45 @@ struct paging_config paging_prepare(void *rmode)
                       (void *)src, PAGE_SIZE);

arch/x86/boot/compressed/pgtable_64.c struct paging_config paging_prepare(void *rmode) · line 175

Quoted 10 lines
arch/x86/boot/compressed/pgtable_64.c +8 -0
        }
 
+out:
+       return l5_required;
+}
+
+struct paging_config paging_prepare(void *rmode)
+{
+       struct paging_config paging_config = {};
+       bool early_trampoline_alloc = 0;

false

Quoted 13 lines
arch/x86/boot/compressed/pgtable_64.c +2 -0
+
+       /* Initialize boot_params. Required for 

cmdline_find_option_bool(). */

arch/x86/boot/compressed/pgtable_64.c +9 -0
+       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;

arch/x86/boot/compressed/pgtable_64.c

Quoted 2 lines
arch/x86/boot/compressed/pgtable_64.c +2 -0
+       early_trampoline_alloc = 0;
+

false again

Quoted 1 line

And it never becomes true, nor is it used anywhere else. Can we get rid of it?

Yes, probably it is just a leftover of the approach I used before. I'll remove that.

Quoted 10 lines

arch/x86/boot/compressed/pgtable_64.c struct paging_config paging_prepare(void *rmode) · line 194

Quoted 7 lines
arch/x86/boot/compressed/pgtable_64.c +6 -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.

Can you please reflow comments so they takes up fewer lines?

Will fix.

Quoted 22 lines
Quoted 22 lines
arch/x86/boot/compressed/pgtable_64.c +2 -0
+        */
+       memcpy(trampoline_save, trampoline_32bit, 

TRAMPOLINE_32BIT_SIZE);

arch/x86/boot/compressed/pgtable_64.c +6 -0
+
+       /* 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);

arch/x86/boot/compressed/pgtable_64.c +2 -0
+
+       paging_config.l5_required = 

trampoline_pgtable_init(boot_params);
+
out:

        return paging_config;

}
--
2.37.4

maintainer
#4 lore raw

Re: [PATCH v4 01/26] x86/boot: Align vmlinuz sections on page size

In reply to Evgeniy Baskov
Quoted 32 lines · Evgeniy Baskov
Quoted 14 lines · Ard Biesheuvel
Quoted 13 lines · Evgeniy Baskov

To 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(+)
Quoted 15 lines

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 33

Quoted 13 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
index 112b2375d021..6be90f1a1198 100644
@@ -27,21 +27,27 @@ SECTIONS
                HEAD_TEXT
                _ehead = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata..compressed : {
+               _compressed = .;
                *(.rodata..compressed)

Can you just move this bit into the rodata section below?

Quoted 8 lines

I don't think that easily possible, as the layout need to stay compatible with in-place extraction for non-UEFI boot. For that execution path the code in .head.text moves everything behind it to the end of the extraction buffer and extraction code overwrites compressed kernel blob progressively during extraction. And that is why we have effectively have two code sections...

A right - thanks for explaining that to me.

So in the end, I think it doesn't matter in any case if we just stick to a single .text section with R-X attributes and a single .data section with RW- attributes.

Quoted 35 lines
Quoted 6 lines

arch/x86/boot/compressed/vmlinux.lds.S SECTIONS · line 37

Quoted 5 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -0
+               _ecompressed = .;
        }
+       . = ALIGN(PAGE_SIZE);
        .text : {
Quoted 6 lines

Please use

.text : ALIGN(PAGE_SIZE) {

which marks the section as being page aligned, rather than just being placed on a 4k boundary.

Will fix in v5.

Quoted 20 lines
Quoted 20 lines
arch/x86/boot/compressed/vmlinux.lds.S +2 -1
                _text = .;      /* Text */
                *(.text)
                *(.text.*)
                _etext = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .rodata : {
                _rodata = . ;
                *(.rodata)       /* read-only data */
                *(.rodata.*)
                _erodata = . ;
        }
+       . = ALIGN(PAGE_SIZE);
        .data : {
                _data = . ;
                *(.data)
--

2.37.4

#46 lore raw

Re: [PATCH v4 17/26] x86/boot: Reduce size of the DOS stub

In reply to Ard Biesheuvel
Quoted 6 lines · Ard Biesheuvel
Quoted 5 lines · Evgeniy Baskov

This 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.

Quoted 7 lines
Quoted 3 lines

I'd prefer to rip this out altogether.

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=9510f6f04f579b9a3f54ad762c75ab2d905e37d8

Sounds great! Can I replace this patch with yours in v5?

Quoted 2 lines

(and refer to the other thread in linux-efi@)

Which thread exactly? The one about the removal of real-mode code?

Quoted 47 lines
Quoted 47 lines
---
 arch/x86/boot/header.S | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)
arch/x86/boot/header.S +6 -9
index 9338c68e7413..9fec80bc504b 100644
@@ -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
@@ -90,10 +89,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:
--

2.37.4

#59 lore raw

Re: [PATCH v4 20/26] x86/build: Make generated PE more spec compliant

In reply to Ard Biesheuvel
Quoted 53 lines · Ard Biesheuvel
Quoted 18 lines · Evgeniy Baskov

Currently 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.

Quoted 5 lines

[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

I would prefer it if we didn't rewrite the build tool this way.

Having the sections in header.S in the order they appear in the binary is rather useful, and I don't think we should manipulate the section flags based on whether CONFIG_DXE_MEM_ATTRIBUTES is set. I also don't think we need more than .text / .,data (as discussed in the other thread on linux-efi@)

Furthermore, I had a look at the audk PE loader [0], and I think it is being overly pedantic.

The PE/COFF spec does not require that all sections are virtually contiguous, and it does not require that the file content is completely covered by either the header or by a section.

So what I would prefer to do is the following:

Sections:

Idx Name          Size     VMA              Type
  0 .reloc        00000200 0000000000002000 DATA
  1 .compat       00000200 0000000000003000 DATA
  2 .text         00bee000 0000000000004000 TEXT
  3 .data         00002200 0000000000bf2000 DATA

using 4k section alignment and 512 byte file alignment, and a header size of 0x200 as before (This requires my patch that allows the setup header to remain unmapped when running the stub [1])

Quoted 7 lines

The reloc and compat payloads are placed at the end of the setup data as before, but increased in size to 512 bytes each, and then mapped non-1:1 into the RVA space.

This works happily with both the existing PE loader as well as the audk one, but with the pedantic flags disabled.

This makes sense. I'll change this patch to use this layout and to keep sections in headers.S before sending v5. (and I guess I'll make the compressed kernel a part of .text). I have a few questions though:

This layout assumes having the local copy of the bootparams as in your RFC patches, right?

Can I keep the .rodata -- 5th section fits in the section table without much work?

Also, why .reloc is at offset 0x2000 and not just 0x1000, is there anything important I am missing? I understand that is cannot be 0 and should be aligned on page size, but nothing else comes to my mind...

Thanks!

Quoted 649 lines

[0] https://github.com/acidanthera/audk
[1] https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=84412899c16c65af13dac305aa01a5a85e08c69e

Quoted 644 lines
---
 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 +0 -1
index 9e38ffaadb5d..bed78c82238e 100644
@@ -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 +5 -4
index 9fec80bc504b..07e31ddb074f 100644
@@ -94,6 +94,7 @@ bugger_off_msg:
        .set    bugger_off_msg_size, . - bugger_off_msg
 
 #ifdef CONFIG_EFI_STUB
+       .align 8
 pe_header:
        .long   PE_MAGIC
 
@@ -107,7 +108,7 @@ coff_header:
        .set    pe_opt_magic, PE_OPT_MAGIC_PE32PLUS
        .word   IMAGE_FILE_MACHINE_AMD64
 #endif
-       .word   section_count                   # nr_sections
+       .word   0                               # nr_sections
        .long   0                               # TimeDateStamp
        .long   0                               # PointerToSymbolTable
        .long   1                               # NumberOfSymbols
@@ -131,7 +132,7 @@ optional_header:
        # Filled in by build.c
        .long   0x0000                          # AddressOfEntryPoint
 
-       .long   0x0200                          # BaseOfCode
+       .long   0x1000                          # BaseOfCode
 #ifdef CONFIG_X86_32
        .long   0                               # data
 #endif
@@ -144,8 +145,8 @@ extra_header_fields:
 #else
        .quad   image_base                      # ImageBase
 #endif
-       .long   0x20                            # SectionAlignment
-       .long   0x20                            # FileAlignment
+       .long   0x1000                          # SectionAlignment
+       .long   0x200                           # FileAlignment
        .word   0                               # 

MajorOperatingSystemVersion
.word 0 #
MinorOperatingSystemVersion
.word LINUX_EFISTUB_MAJOR_VERSION # MajorImageVersion

arch/x86/boot/header.S +0 -11
@@ -188,91 +189,14 @@ extra_header_fields:
        .quad   0                               # CertificationTable
        .quad   0                               # BaseRelocationTable
 
-       # Section table
-section_table:
-       #
-       # The offset & size fields are filled in by build.c.
-       #
-       .ascii  ".setup"
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # Size of initialized 

data

arch/x86/boot/header.S +3 -38
-                                               # on disk
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_CODE              | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_EXECUTE           | \
-               IMAGE_SCN_ALIGN_16BYTES         # Characteristics
-
-       #
-       # The EFI application loader requires a relocation section
-       # because EFI applications must be relocatable. The .reloc
-       # offset & size fields are filled in by build.c.
        #
-       .ascii  ".reloc"
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0
-       .long   0                               # SizeOfRawData
-       .long   0                               # PointerToRawData
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_INITIALIZED_DATA  | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_DISCARDABLE       | \
-               IMAGE_SCN_ALIGN_1BYTES          # Characteristics
-
-#ifdef CONFIG_EFI_MIXED
-       #
-       # The offset & size fields are filled in by build.c.
+       # Section table
+       # It is generated by build.c and here we just need
+       # to reserve some space for sections
        #
-       .asciz  ".compat"
-       .long   0
-       .long   0x0
-       .long   0                               # Size of initialized 

data

arch/x86/boot/header.S +2 -21
-                                               # on disk
-       .long   0x0
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_INITIALIZED_DATA  | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_DISCARDABLE       | \
-               IMAGE_SCN_ALIGN_1BYTES          # Characteristics
-#endif
+section_table:
+       .fill 40*5, 1, 0
 
-       #
-       # The offset & size fields are filled in by build.c.
-       #
-       .ascii  ".text"
-       .byte   0
-       .byte   0
-       .byte   0
-       .long   0
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # Size of initialized 

data

arch/x86/boot/header.S +0 -12
-                                               # on disk
-       .long   0x0                             # startup_{32,64}
-       .long   0                               # PointerToRelocations
-       .long   0                               # PointerToLineNumbers
-       .word   0                               # NumberOfRelocations
-       .word   0                               # NumberOfLineNumbers
-       .long   IMAGE_SCN_CNT_CODE              | \
-               IMAGE_SCN_MEM_READ              | \
-               IMAGE_SCN_MEM_EXECUTE           | \
-               IMAGE_SCN_ALIGN_16BYTES         # Characteristics
-
-       .set    section_count, (. - section_table) / 40
 #endif /* CONFIG_EFI_STUB */
 
        # Kernel attributes; used by setup.  This is part 1 of the
arch/x86/boot/tools/build.c +19 -13
index fbc5315af032..ac6159b76a13 100644
@@ -61,8 +61,10 @@ uint8_t buf[SETUP_SECT_MAX*SECTOR_SIZE];
 
 #ifdef CONFIG_EFI_MIXED
 #define PECOFF_COMPAT_RESERVE 0x20
+#define COMPAT_SECTION_SIZE 0x8
 #else
 #define PECOFF_COMPAT_RESERVE 0x0
+#define COMPAT_SECTION_SIZE 0x0
 #endif
 
 #define RELOC_SECTION_SIZE 10
@@ -117,6 +119,7 @@ static unsigned long efi_pe_entry;
 static unsigned long efi32_pe_entry;
 static unsigned long kernel_info;
 static unsigned long startup_64;
+static unsigned long _rodata;
 static unsigned long _ehead;
 static unsigned long _end;
 
@@ -258,122 +261,177 @@ static void *map_output_file(const char *path, 
 size_t size)
 
 #ifdef CONFIG_EFI_STUB
 
-static void update_pecoff_section_header_fields(char *section_name, 
 uint32_t vma,
-                                               uint32_t size, 
 uint32_t datasz,
-                                               uint32_t offset)
+static unsigned int reloc_offset;
+static unsigned int compat_offset;
+
+#define MAX_SECTIONS 5
+
+static void emit_pecoff_section(const char *section_name, unsigned 
 int size,
+                               unsigned int bss, unsigned int 
 *file_offset,
+                               unsigned int *mem_offset, uint32_t 
 flags)
 {
-       unsigned int pe_header;
+       unsigned int section_memsz, section_filesz;
+       unsigned int name_len;
        unsigned short num_sections;
+       struct pe_hdr *hdr = get_pe_header(buf);
        struct section_header *section;
 
-       struct pe_hdr *hdr = get_pe_header(buf);
        num_sections = get_unaligned_le16(&hdr->sections);
-       section = get_sections(buf);
+       if (num_sections >= MAX_SECTIONS)
+               die("Not enough space to generate all sections");
 
-       while (num_sections > 0) {
-               if (strncmp(section->name, section_name, 8) == 0) {
-                       /* section header size field */
-                       put_unaligned_le32(size, 
 &section->virtual_size);
+       section = get_sections(buf) + num_sections;
 
-                       /* section header vma field */
-                       put_unaligned_le32(vma, 
 &section->virtual_address);
+       if ((size & (FILE_ALIGNMENT - 1)) || (bss & (FILE_ALIGNMENT - 
 1)))
+               die("Section '%s' is improperly aligned", 
 section_name);
 
-                       /* section header 'size of initialised data' 

field */
- put_unaligned_le32(datasz,
&section->raw_data_size);

arch/x86/boot/tools/build.c +2 -2
+       section_memsz = round_up(size + bss, SECTION_ALIGNMENT);
+       section_filesz = round_up(size, FILE_ALIGNMENT);
 
-                       /* section header 'file offset' field */
-                       put_unaligned_le32(offset, 

&section->data_addr);

arch/x86/boot/tools/build.c +5 -7
+       /* Zero out all section fields */
+       memset(section, 0, sizeof(*section));
 
-                       break;
-               }
-               section++;
-               num_sections--;
-       }
-}
+       name_len = strlen(section_name);
+       if (name_len > sizeof(section->name))
+               name_len = sizeof(section_name);
 
-static void update_pecoff_section_header(char *section_name, uint32_t 

offset, uint32_t size)

arch/x86/boot/tools/build.c +0 -2
-{
-       update_pecoff_section_header_fields(section_name, offset, 

size, size, offset);

arch/x86/boot/tools/build.c +21 -3
+       /* Section header size field */
+       memcpy(section->name, section_name, name_len);
+
+       put_unaligned_le32(section_memsz, &section->virtual_size);
+       put_unaligned_le32(*mem_offset, &section->virtual_address);
+       put_unaligned_le32(section_filesz, &section->raw_data_size);
+       put_unaligned_le32(*file_offset, &section->data_addr);
+       put_unaligned_le32(flags, &section->flags);
+
+       put_unaligned_le16(num_sections + 1, &hdr->sections);
+
+       *mem_offset += section_memsz;
+       *file_offset += section_filesz;
 }
 
-static void update_pecoff_setup_and_reloc(unsigned int size)
+#define BASE_RVA 0x1000
+
+static unsigned int text_rva;
+
+static unsigned int update_pecoff_sections(unsigned int setup_size,
+                                          unsigned int file_size,
+                                          unsigned int virt_size,
+                                          unsigned int text_size)
 {
-       uint32_t setup_offset = SECTOR_SIZE;
-       uint32_t reloc_offset = size - PECOFF_RELOC_RESERVE - 

PECOFF_COMPAT_RESERVE;

arch/x86/boot/tools/build.c +10 -5
-#ifdef CONFIG_EFI_MIXED
-       uint32_t compat_offset = reloc_offset + PECOFF_RELOC_RESERVE;
-#endif
-       uint32_t setup_size = reloc_offset - setup_offset;
+       /* First section starts at 512 byes, after PE header */
+       unsigned int mem_offset = BASE_RVA, file_offset = SECTOR_SIZE;
+       unsigned int compat_size, reloc_size;
+       unsigned int bss_size, text_rva_diff, reloc_rva;
+       pe_opt_hdr  *opt_hdr = get_pe_opt_header(buf);
+       struct pe_hdr *hdr = get_pe_header(buf);
+       struct data_dirent *base_reloc;
+
+       if (get_unaligned_le32(&hdr->sections))
+               die("Some sections present in PE file");
 
-       update_pecoff_section_header(".setup", setup_offset, 

setup_size);
- update_pecoff_section_header(".reloc", reloc_offset,
PECOFF_RELOC_RESERVE);

arch/x86/boot/tools/build.c +3 -2
+       reloc_size = round_up(RELOC_SECTION_SIZE, FILE_ALIGNMENT);
+       compat_size = round_up(COMPAT_SECTION_SIZE, FILE_ALIGNMENT);
+       virt_size = round_up(virt_size, SECTION_ALIGNMENT);
 
        /*
-        * Modify .reloc section contents with a single entry. The
-        * relocation is applied to offset 10 of the relocation 

section.

arch/x86/boot/tools/build.c +2 -1
+        * Update sections offsets.
+        * NOTE: Order is important
         */
-       put_unaligned_le32(reloc_offset + RELOC_SECTION_SIZE, 

&buf[reloc_offset]);
- put_unaligned_le32(RELOC_SECTION_SIZE, &buf[reloc_offset +
4]);

arch/x86/boot/tools/build.c +29 -1
+       bss_size = virt_size - file_size;
+
+       emit_pecoff_section(".setup", setup_size - SECTOR_SIZE, 0,
+                           &file_offset, &mem_offset, SCN_RO |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA);
+
+       text_rva_diff = mem_offset - file_offset;
+       text_rva = mem_offset;
+       emit_pecoff_section(".text", text_size, 0,
+                           &file_offset, &mem_offset, SCN_RX |
+                           IMAGE_SCN_CNT_CODE);
+
+       /* Check that kernel sections mapping is contiguous */
+       if (text_rva_diff != mem_offset - file_offset)
+               die("Kernel sections mapping is wrong: %#x != %#x",
+                   mem_offset - file_offset, text_rva_diff);
+
+       emit_pecoff_section(".data", file_size - text_size, bss_size,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA);
+
+       reloc_offset = file_offset;
+       reloc_rva = mem_offset;
+       emit_pecoff_section(".reloc", reloc_size, 0,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA |
+                           IMAGE_SCN_MEM_DISCARDABLE);
+
+       compat_offset = file_offset;
 #ifdef CONFIG_EFI_MIXED
-       update_pecoff_section_header(".compat", compat_offset, 

PECOFF_COMPAT_RESERVE);

arch/x86/boot/tools/build.c +6 -0
+       emit_pecoff_section(".comat", compat_size, 0,
+                           &file_offset, &mem_offset, SCN_RW |
+                           IMAGE_SCN_CNT_INITIALIZED_DATA |
+                           IMAGE_SCN_MEM_DISCARDABLE);
+#endif
 
+       if (file_size + setup_size + reloc_size + compat_size != 

file_offset)

arch/x86/boot/tools/build.c +2 -0
+               die("file_size(%#x) != filesz(%#x)",
+                   file_size + setup_size + reloc_size + compat_size, 

file_offset);

arch/x86/boot/tools/build.c +3 -0
+
+       /* Size of code. */
+       put_unaligned_le32(round_up(text_size, SECTION_ALIGNMENT), 
&opt_hdr->text_size);
        /*

- * Put the IA-32 machine type (0x14c) and the associated entry
point
- * address in the .compat section, so loaders can figure out
which other

arch/x86/boot/tools/build.c +2 -1
-        * execution modes this image supports.
+        * Size of data.
+        * Exclude text size and first sector, which contains PE 

header.

         */
arch/x86/boot/tools/build.c +1 -4
-       buf[compat_offset] = 0x1;
-       buf[compat_offset + 1] = 0x8;
-       put_unaligned_le16(IMAGE_FILE_MACHINE_I386, &buf[compat_offset 
+ 2]);
-       put_unaligned_le32(efi32_pe_entry + size, &buf[compat_offset + 

4]);

arch/x86/boot/tools/build.c +1 -2
-#endif
-}
+       put_unaligned_le32(mem_offset - round_up(text_size, 

SECTION_ALIGNMENT),

arch/x86/boot/tools/build.c +1 -1
+                          &opt_hdr->data_size);
 
-static unsigned int update_pecoff_sections(unsigned int text_start, 

unsigned int text_sz,

arch/x86/boot/tools/build.c +2 -6
-                              unsigned int init_sz)
-{
-       unsigned int file_sz = text_start + text_sz;
-       unsigned int bss_sz = init_sz - file_sz;
-       pe_opt_hdr *hdr = get_pe_opt_header(buf);
+       /* Size of image. */
+       put_unaligned_le32(mem_offset, &opt_hdr->image_size);
 
        /*
-        * The PE/COFF loader may load the image at an address which 

is
- * misaligned with respect to the kernel_alignment field in
the setup

arch/x86/boot/tools/build.c +0 -3
-        * header.
-        *
-        * In order to avoid relocating the kernel to correct the 

misalignment,
- * add slack to allow the buffer to be aligned within the
declared size

arch/x86/boot/tools/build.c +2 -3
-        * of the image.
+        * Address of entry point for PE/COFF executable
         */
-       bss_sz  += CONFIG_PHYSICAL_ALIGN;
-       init_sz += CONFIG_PHYSICAL_ALIGN;
+       put_unaligned_le32(text_rva + efi_pe_entry, 

&opt_hdr->entry_point);

        /*

- * Size of code: Subtract the size of the first sector (512
bytes)

arch/x86/boot/tools/build.c +1 -2
-        * which includes the header.
+        * BaseOfCode for PE/COFF executable
         */
-       put_unaligned_le32(file_sz - SECTOR_SIZE + bss_sz, 

&hdr->text_size);

arch/x86/boot/tools/build.c +3 -5
-
-       /* Size of image */
-       put_unaligned_le32(init_sz, &hdr->image_size);
+       put_unaligned_le32(text_rva, &opt_hdr->code_base);
 
        /*
-        * Address of entry point for PE/COFF executable
+        * Since we have generated .reloc section, we need to
+        * fill-in Reloc directory
         */
-       put_unaligned_le32(text_start + efi_pe_entry, 

&hdr->entry_point);

arch/x86/boot/tools/build.c +3 -1
+       base_reloc = &get_data_dirs(buf)->base_relocations;
+       put_unaligned_le32(reloc_rva, &base_reloc->virtual_address);
+       put_unaligned_le32(RELOC_SECTION_SIZE, &base_reloc->size);
 
-       update_pecoff_section_header_fields(".text", text_start, 

text_sz + bss_sz,

arch/x86/boot/tools/build.c +5 -7
-                                           text_sz, text_start);
-
-       return text_start + file_sz;
+       return file_offset;
 }
 
-static int reserve_pecoff_reloc_section(int c)
+static void generate_pecoff_section_data(uint8_t *output)
 {
-       /* Reserve 0x20 bytes for .reloc section */
-       memset(buf+c, 0, PECOFF_RELOC_RESERVE);
-       return PECOFF_RELOC_RESERVE;
+       /*
+        * Modify .reloc section contents with a two entries. The
+        * relocation is applied to offset 10 of the relocation 

section.

arch/x86/boot/tools/build.c +2 -0
+        */
+       put_unaligned_le32(reloc_offset + RELOC_SECTION_SIZE, 

&output[reloc_offset]);
+ put_unaligned_le32(RELOC_SECTION_SIZE, &output[reloc_offset +
4]);

arch/x86/boot/tools/build.c +4 -0
+
+#ifdef CONFIG_EFI_MIXED
+       /*
+        * Put the IA-32 machine type (0x14c) and the associated entry 

point
+ * address in the .compat section, so loaders can figure out
which other

arch/x86/boot/tools/build.c +5 -0
+        * execution modes this image supports.
+        */
+       output[compat_offset] = 0x1;
+       output[compat_offset + 1] = 0x8;
+       put_unaligned_le16(IMAGE_FILE_MACHINE_I386, 

&output[compat_offset + 2]);
+ put_unaligned_le32(efi32_pe_entry + text_rva,
&output[compat_offset + 4]);

arch/x86/boot/tools/build.c +2 -17
+#endif
 }
 
 static void efi_stub_update_defaults(void)
@@ -407,26 +465,10 @@ static void efi_stub_entry_update(void)
 
 #else
 
-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_update_defaults(void) {}
-static inline void efi_stub_entry_update(void) {}
+static void efi_stub_update_defaults(void) {}
 
-static inline int reserve_pecoff_reloc_section(int c)
-{
-       return 0;
-}
 #endif /* CONFIG_EFI_STUB */
 
-static int reserve_pecoff_compat_section(int c)
-{
-       /* Reserve 0x20 bytes for .compat section */
-       memset(buf+c, 0, PECOFF_COMPAT_RESERVE);
-       return PECOFF_COMPAT_RESERVE;
-}
-
 /*
  * Parse zoffset.h and find the entry points. We could just #include 

zoffset.h
* but that would mean tools/build would have to be rebuilt every
time. It's

arch/x86/boot/tools/build.c +1 -5
@@ -456,6 +498,7 @@ static void parse_zoffset(char *fname)
                PARSE_ZOFS(p, efi32_pe_entry);
                PARSE_ZOFS(p, kernel_info);
                PARSE_ZOFS(p, startup_64);
+               PARSE_ZOFS(p, _rodata);
                PARSE_ZOFS(p, _ehead);
                PARSE_ZOFS(p, _end);
 
@@ -489,10 +532,6 @@ static unsigned int read_setup(char *path)
 
        fclose(file);
 
-       /* 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_size = round_up(file_size, SECTOR_SIZE);
@@ -515,7 +554,6 @@ 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;
@@ -540,8 +578,7 @@ int main(int argc, char **argv)
 
 #ifdef CONFIG_EFI_STUB
        /* PE specification require 512-byte minimum section file 

alignment */

arch/x86/boot/tools/build.c +1 -2
-       kern_size = round_up(kern_file_size + 4, SECTOR_SIZE);
-       update_pecoff_setup_and_reloc(setup_size);
+       kern_size = round_up(kern_file_size + 4, FILE_ALIGNMENT);
 #else
        /* Number of 16-byte paragraphs, including space for a 4-byte 

CRC */

        kern_size = round_up(kern_file_size + 4, PARAGRAPH_SIZE);
arch/x86/boot/tools/build.c +0 -4
@@ -554,33 +591,12 @@ int main(int argc, char **argv)
        /* Update kernel_info offset. */
        put_unaligned_le32(kernel_info, &buf[0x268]);
 
-       init_size = get_unaligned_le32(&buf[0x260]);
-
 #ifdef CONFIG_EFI_STUB
-       /*
-        * The decompression buffer will start at ImageBase. When 

relocating
- * the compressed kernel to its end, we must ensure that the
head
- * section does not get overwritten. The head section
occupies
- * [i, i + _ehead), and the destination is [init_sz - _end,
init_sz).

arch/x86/boot/tools/build.c +0 -2
-        *
-        * At present these should never overlap, because 'i' is at 

most 32k
- * because of SETUP_SECT_MAX, '_ehead' is less than 1k, and
the

arch/x86/boot/tools/build.c +0 -8
-        * calculation of INIT_SIZE in boot/header.S ensures that
-        * 'init_sz - _end' is at least 64k.
-        *
-        * For future-proofing, increase init_sz if necessary.
-        */
-
-       if (init_size - _end < setup_size + _ehead) {
-               init_size = round_up(setup_size + _ehead + _end, 

SECTION_ALIGNMENT);

arch/x86/boot/tools/build.c +0 -3
-               put_unaligned_le32(init_size, &buf[0x260]);
-       }
 
-       total_size = update_pecoff_sections(setup_size, kern_size, 

init_size);
+ total_size = update_pecoff_sections(setup_size, kern_size,
_end, _rodata);

        efi_stub_entry_update();

#else

arch/x86/boot/tools/build.c +4 -1
-       (void)init_size;
        total_size = setup_size + kern_size;
 #endif
@@ -590,6 +606,10 @@ int main(int argc, char **argv)
        memcpy(output + setup_size, kernel, kern_file_size);
        memset(output + setup_size + kern_file_size, 0, kern_size - 
 kern_file_size);
 
+#ifdef CONFIG_EFI_STUB
+       generate_pecoff_section_data(output);
+#endif
+
        /* Calculate and write kernel checksum. */
        crc = partial_crc32(output, total_size - 4, crc);
        put_unaligned_le32(crc, &output[total_size - 4]);
drivers/firmware/efi/libstub/x86-stub.c +5 -2
index 1d1ab1911fd3..1f0a2e7075c3 100644
@@ -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));

        /*

--
2.37.4

#66 lore raw

Re: [PATCH v4 21/26] efi/x86: Explicitly set sections memory attributes

In reply to Ard Biesheuvel
Quoted 8 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Explicitly 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.

Quoted 6 lines
Quoted 2 lines

I don't think we need this patch. Firmware that cares about W^X will map the PE image with R-X for text/rodata and RW- for data/bss, which is sufficient, and firmware that doesn't is a lost cause anyway.

This patch were here mainly here to make .rodata non-executable and for the UEFI handover protocol, for which attributes are usually not getting applied.

Since the UEFI handover protocol is deprecated, I'll exclude patches from v5 and maybe submit it separately modified to apply attributes only when booting via this protocol.

Quoted 104 lines
Quoted 104 lines

---
 drivers/firmware/efi/libstub/x86-stub.c | 54 
+++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
drivers/firmware/efi/libstub/x86-stub.c +6 -0
index 1f0a2e7075c3..60697fcd8950 100644
@@ -27,6 +27,12 @@ const efi_dxe_services_table_t *efi_dxe_table;
 u32 image_offset __section(".data");
 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)

{

drivers/firmware/efi/libstub/x86-stub.c +12 -0
@@ -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) {

drivers/firmware/efi/libstub/x86-stub.c +8 -0
+               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);

drivers/firmware/efi/libstub/x86-stub.c +3 -0
+       /* .head.text [_head, _ehead] */
+       efi_adjust_memory_range_protection((unsigned long)_head,
+                                          (unsigned long)_ehead - 

(unsigned long)_head,

drivers/firmware/efi/libstub/x86-stub.c +5 -1
+                                          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);

drivers/firmware/efi/libstub/x86-stub.c +3 -0
+       /* .text [_text, _etext] */
+       efi_adjust_memory_range_protection((unsigned long)_text,
+                                          (unsigned long)_etext - 

(unsigned long)_text,

drivers/firmware/efi/libstub/x86-stub.c +4 -0
+                                          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);

drivers/firmware/efi/libstub/x86-stub.c +3 -0
+       /* .data, .bss [_data, _end] */
+       efi_adjust_memory_range_protection((unsigned long)_data,
+                                          (unsigned long)_end - 

(unsigned long)_data,

drivers/firmware/efi/libstub/x86-stub.c +8 -0
+                                          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) {

--
2.37.4

#72 lore raw

Re: [PATCH v4 23/26] efi/libstub: Use memory attribute protocol

In reply to Ard Biesheuvel
Quoted 32 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Add 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.

Quoted 6 lines

Move DXE services initialization code closer to the place they are used to match EFI_MEMORY_ATTRIBUTE_PROTOCOL initialization code.

I'm not convinced about the use of the DXE services for this, and I think we should replace this patch with changes that base all the new protection code on the EFI memory attributes protocol only.

We introduced that DXE code to remove protections from memory that was mapped read-only and/or non-executable, and described as such in the GCD memory map.

Using it to manipulate restricted permissions like this is quite a different thing, and sadly (at least in EDK2), the GCD system memory map is not kept in sync with the updated permissions, i.e, the W^X protections for loaded images and the NX protection for arbitrary page allocations are both based on the PI CPU arch protocol, which manipulates the page tables directly, but does not record the modified attributes in the GCD or EFI memory maps, as this would result in massive fragmentation and break lots of other things.

Quoted 7 lines

That means that, except for the specific use case for which we introduced the DXE services calls, the only reliable way to figure out what permission attributes a certain range of memory is using is the EFI memory attributes protocol, and I don't think we should use anything else for tightening down these protections.

Makes sense. I'll change the patch to only widen the permissions with DXE, so it aligns with the original intention. And only apply stricter permissions with memory attribute protocol.

Thanks!

Quoted 294 lines
Quoted 294 lines

---
 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 +3 -0
index 3e47e5931f04..07d54c88c62e 100644
@@ -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

drivers/firmware/efi/libstub/mem.c +0 -2
@@ -129,66 +132,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
- */

drivers/firmware/efi/libstub/mem.c +0 -3
-efi_status_t efi_adjust_memory_range_protection(unsigned long start,
-                                               unsigned long size,
-                                               unsigned long 

attributes)

drivers/firmware/efi/libstub/mem.c +3 -0
+static void retrieve_dxe_table(void)
+{
+       efi_dxe_table = 

get_efi_config_table(EFI_DXE_SERVICES_TABLE_GUID);

drivers/firmware/efi/libstub/mem.c +2 -0
+       if (efi_dxe_table &&
+           efi_dxe_table->hdr.signature != 

EFI_DXE_SERVICES_TABLE_SIGNATURE) {
+ efi_warn("Ignoring DXE services table: invalid
signature\n");

drivers/firmware/efi/libstub/mem.c +5 -0
+               efi_dxe_table = NULL;
+       }
+}
+
+static efi_status_t adjust_mem_attrib_dxe(efi_physical_addr_t 

rounded_start,
+ efi_physical_addr_t
rounded_end,

drivers/firmware/efi/libstub/mem.c +8 -25
+                                         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",

drivers/firmware/efi/libstub/mem.c +15 -1
-                                start);
+                                (unsigned long)start);
                        return status;
                }
@@ -230,3 +214,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
+ */

drivers/firmware/efi/libstub/mem.c +3 -0
+efi_status_t efi_adjust_memory_range_protection(unsigned long start,
+                                               unsigned long size,
+                                               unsigned long 

attributes)

drivers/firmware/efi/libstub/mem.c +40 -0
+{
+       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

drivers/firmware/efi/libstub/mem.c +13 -0
+        * 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",

drivers/firmware/efi/libstub/mem.c +13 -0
+                        (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",

drivers/firmware/efi/libstub/mem.c +7 -0
+                        (unsigned long)rounded_start,
+                        (unsigned long)rounded_end,
+                        status);
+       }
+
+       return status;
+}
drivers/firmware/efi/libstub/x86-stub.c +0 -5
index 60697fcd8950..06a62b121521 100644
@@ -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;
 u32 image_offset __section(".data");
 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) {

drivers/firmware/efi/libstub/x86-stub.c +0 -5
-               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,

drivers/firmware/efi/libstub/x86-stub.c +0 -3
@@ -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");

drivers/firmware/efi/libstub/x86-stub.c +0 -4
-               efi_dxe_table = NULL;
-       }
-
        setup_sections_memory_protection(bzimage_addr - image_offset);
 
 #ifdef CONFIG_CMDLINE_BOOL
--

2.37.4

maintainer
#47 lore raw

Re: [PATCH v4 17/26] x86/boot: Reduce size of the DOS stub

In reply to Evgeniy Baskov
Quoted 12 lines · Evgeniy Baskov
Quoted 10 lines · Ard Biesheuvel
Quoted 8 lines · Evgeniy Baskov

This 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.

Quoted 6 lines
Quoted 3 lines

I'd prefer to rip this out altogether.

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=9510f6f04f579b9a3f54ad762c75ab2d905e37d8

Sounds great! Can I replace this patch with yours in v5?

Of course.

Quoted 6 lines
Quoted 2 lines

(and refer to the other thread in linux-efi@)

Which thread exactly? The one about the removal of real-mode code?

Yes, this one

https://lore.kernel.org/linux-efi/[email protected]/

maintainer
#60 lore raw

Re: [PATCH v4 20/26] x86/build: Make generated PE more spec compliant

In reply to Evgeniy Baskov
Quoted 65 lines · Evgeniy Baskov
Quoted 55 lines · Ard Biesheuvel
Quoted 18 lines · Evgeniy Baskov

Currently 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.

Quoted 7 lines

[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

I would prefer it if we didn't rewrite the build tool this way.

Having the sections in header.S in the order they appear in the binary is rather useful, and I don't think we should manipulate the section flags based on whether CONFIG_DXE_MEM_ATTRIBUTES is set. I also don't think we need more than .text / .,data (as discussed in the other thread on linux-efi@)

Furthermore, I had a look at the audk PE loader [0], and I think it is being overly pedantic.

The PE/COFF spec does not require that all sections are virtually contiguous, and it does not require that the file content is completely covered by either the header or by a section.

So what I would prefer to do is the following:

Sections:

Idx Name          Size     VMA              Type
  0 .reloc        00000200 0000000000002000 DATA
  1 .compat       00000200 0000000000003000 DATA
  2 .text         00bee000 0000000000004000 TEXT
  3 .data         00002200 0000000000bf2000 DATA

using 4k section alignment and 512 byte file alignment, and a header size of 0x200 as before (This requires my patch that allows the setup header to remain unmapped when running the stub [1])

Quoted 7 lines

The reloc and compat payloads are placed at the end of the setup data as before, but increased in size to 512 bytes each, and then mapped non-1:1 into the RVA space.

This works happily with both the existing PE loader as well as the audk one, but with the pedantic flags disabled.

Quoted 8 lines

This makes sense. I'll change this patch to use this layout and to keep sections in headers.S before sending v5. (and I guess I'll make the compressed kernel a part of .text). I have a few questions though:

This layout assumes having the local copy of the bootparams as in your RFC patches, right?

Indeed. Otherwise, the setup header may not have been copied to memory by the loader.

Quoted 3 lines

Can I keep the .rodata -- 5th section fits in the section table without much work?

You could, but at least the current PE/COFF loader in EDK2 will map it read/write, as it only distinguishes between executable sections and non-executable sections.

Quoted 5 lines

Also, why .reloc is at offset 0x2000 and not just 0x1000, is there anything important I am missing? I understand that is cannot be 0 and should be aligned on page size, but nothing else comes to my mind...

That was just arbitrary, because the raw allocations of reloc and compat are also allocated towards the end. But I guess starting at 0x1000 for .reloc makes more sense so feel free to change that.

maintainer
#67 lore raw

Re: [PATCH v4 21/26] efi/x86: Explicitly set sections memory attributes

In reply to Evgeniy Baskov
Quoted 17 lines · Evgeniy Baskov
Quoted 8 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Explicitly 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.

Quoted 6 lines
Quoted 2 lines

I don't think we need this patch. Firmware that cares about W^X will map the PE image with R-X for text/rodata and RW- for data/bss, which is sufficient, and firmware that doesn't is a lost cause anyway.

Quoted 9 lines

This patch were here mainly here to make .rodata non-executable and for the UEFI handover protocol, for which attributes are usually not getting applied.

Since the UEFI handover protocol is deprecated, I'll exclude patches from
v5 and maybe submit it separately modified to apply attributes only when booting via this protocol.

I think the issue here is that loaders that use the UEFI handover protocol use their own implementations of LoadImage/StartImage as well, and some of those tend to do little more than copy the image into memory and jump to the EFI handover protocol entry point, without even accounting for the image size in memory or clearing the bss.

To be honest, even though I understand the reason these had to be implemented, I'm a bit reluctant to cater for the needs of such loaders, given that these are all downstream distro forks of GRUB (with shim) with varying levels of adherence to the PE/COFF spec.

I'm happy to revisit this later if others feel this is important, but for the moment, I'd prefer it if we could focus on making the x86 image work better with compliant loaders, which is what this series is primarily about.

#61 lore raw

Re: [PATCH v4 20/26] x86/build: Make generated PE more spec compliant

In reply to Ard Biesheuvel
Quoted 78 lines · Ard Biesheuvel
Quoted 65 lines · Evgeniy Baskov
Quoted 55 lines · Ard Biesheuvel
Quoted 18 lines · Evgeniy Baskov

Currently 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.

Quoted 7 lines

[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

I would prefer it if we didn't rewrite the build tool this way.

Having the sections in header.S in the order they appear in the binary is rather useful, and I don't think we should manipulate the section flags based on whether CONFIG_DXE_MEM_ATTRIBUTES is set. I also don't think we need more than .text / .,data (as discussed in the other thread on linux-efi@)

Furthermore, I had a look at the audk PE loader [0], and I think it is being overly pedantic.

The PE/COFF spec does not require that all sections are virtually contiguous, and it does not require that the file content is completely covered by either the header or by a section.

So what I would prefer to do is the following:

Sections:

Idx Name          Size     VMA              Type
  0 .reloc        00000200 0000000000002000 DATA
  1 .compat       00000200 0000000000003000 DATA
  2 .text         00bee000 0000000000004000 TEXT
  3 .data         00002200 0000000000bf2000 DATA

using 4k section alignment and 512 byte file alignment, and a header size of 0x200 as before (This requires my patch that allows the setup header to remain unmapped when running the stub [1])

Quoted 7 lines

The reloc and compat payloads are placed at the end of the setup data as before, but increased in size to 512 bytes each, and then mapped non-1:1 into the RVA space.

This works happily with both the existing PE loader as well as the audk one, but with the pedantic flags disabled.

Quoted 8 lines

This makes sense. I'll change this patch to use this layout and to keep sections in headers.S before sending v5. (and I guess I'll make the compressed kernel a part of .text). I have a few questions though:

This layout assumes having the local copy of the bootparams as in your RFC patches, right?

Indeed. Otherwise, the setup header may not have been copied to memory by the loader.

Quoted 8 lines
Quoted 3 lines

Can I keep the .rodata -- 5th section fits in the section table without much work?

You could, but at least the current PE/COFF loader in EDK2 will map it read/write, as it only distinguishes between executable sections and non-executable sections.

At least it will slightly improve security for some implementations (e.g. audk, while being overly strict support RO sections)

Quoted 9 lines
Quoted 5 lines

Also, why .reloc is at offset 0x2000 and not just 0x1000, is there anything important I am missing? I understand that is cannot be 0 and should be aligned on page size, but nothing else comes to my mind...

That was just arbitrary, because the raw allocations of reloc and compat are also allocated towards the end. But I guess starting at 0x1000 for .reloc makes more sense so feel free to change that.

Thanks for clarifications!

#68 lore raw

Re: [PATCH v4 21/26] efi/x86: Explicitly set sections memory attributes

In reply to Ard Biesheuvel
Quoted 28 lines · Ard Biesheuvel
Quoted 17 lines · Evgeniy Baskov
Quoted 8 lines · Ard Biesheuvel
Quoted 7 lines · Evgeniy Baskov

Explicitly 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.

Quoted 6 lines
Quoted 2 lines

I don't think we need this patch. Firmware that cares about W^X will map the PE image with R-X for text/rodata and RW- for data/bss, which is sufficient, and firmware that doesn't is a lost cause anyway.

Quoted 9 lines

This patch were here mainly here to make .rodata non-executable and for the UEFI handover protocol, for which attributes are usually not getting applied.

Since the UEFI handover protocol is deprecated, I'll exclude patches from
v5 and maybe submit it separately modified to apply attributes only when booting via this protocol.

Quoted 6 lines

I think the issue here is that loaders that use the UEFI handover protocol use their own implementations of LoadImage/StartImage as well, and some of those tend to do little more than copy the image into memory and jump to the EFI handover protocol entry point, without even accounting for the image size in memory or clearing the bss.

AFAIK this patch does not break loaders that load PE image as a flat binary, since it only operates on ELF sections that are mapped 1-to-1. But that's just the note for a future.

Quoted 9 lines

To be honest, even though I understand the reason these had to be implemented, I'm a bit reluctant to cater for the needs of such loaders, given that these are all downstream distro forks of GRUB (with shim) with varying levels of adherence to the PE/COFF spec.

I'm happy to revisit this later if others feel this is important, but for the moment, I'd prefer it if we could focus on making the x86 image work better with compliant loaders, which is what this series is primarily about.

That's very reasonable. I'll put this patch aside for now then.

#48 lore raw

Re: [PATCH v4 17/26] x86/boot: Reduce size of the DOS stub

In reply to Ard Biesheuvel
Quoted 25 lines · Ard Biesheuvel
Quoted 12 lines · Evgeniy Baskov
Quoted 10 lines · Ard Biesheuvel
Quoted 8 lines · Evgeniy Baskov

This 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.

Quoted 6 lines
Quoted 3 lines

I'd prefer to rip this out altogether.

https://git.kernel.org/pub/scm/linux/kernel/git/ardb/linux.git/commit/?id=9510f6f04f579b9a3f54ad762c75ab2d905e37d8

Sounds great! Can I replace this patch with yours in v5?

Of course.

Quoted 3 lines
Quoted 2 lines

(and refer to the other thread in linux-efi@)

Quoted 7 lines
Quoted 3 lines

Which thread exactly? The one about the removal of real-mode code?

Yes, this one

https://lore.kernel.org/linux-efi/[email protected]/

Thanks!

maintainer
#62 lore raw

Re: [PATCH v4 20/26] x86/build: Make generated PE more spec compliant

In reply to Evgeniy Baskov
Quoted 84 lines · Evgeniy Baskov
Quoted 82 lines · Ard Biesheuvel
Quoted 65 lines · Evgeniy Baskov
Quoted 55 lines · Ard Biesheuvel
Quoted 18 lines · Evgeniy Baskov

Currently 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.

Quoted 7 lines

[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

I would prefer it if we didn't rewrite the build tool this way.

Having the sections in header.S in the order they appear in the binary is rather useful, and I don't think we should manipulate the section flags based on whether CONFIG_DXE_MEM_ATTRIBUTES is set. I also don't think we need more than .text / .,data (as discussed in the other thread on linux-efi@)

Furthermore, I had a look at the audk PE loader [0], and I think it is being overly pedantic.

The PE/COFF spec does not require that all sections are virtually contiguous, and it does not require that the file content is completely covered by either the header or by a section.

So what I would prefer to do is the following:

Sections:

Idx Name          Size     VMA              Type
  0 .reloc        00000200 0000000000002000 DATA
  1 .compat       00000200 0000000000003000 DATA
  2 .text         00bee000 0000000000004000 TEXT
  3 .data         00002200 0000000000bf2000 DATA

using 4k section alignment and 512 byte file alignment, and a header size of 0x200 as before (This requires my patch that allows the setup header to remain unmapped when running the stub [1])

Quoted 7 lines

The reloc and compat payloads are placed at the end of the setup data as before, but increased in size to 512 bytes each, and then mapped non-1:1 into the RVA space.

This works happily with both the existing PE loader as well as the audk one, but with the pedantic flags disabled.

Quoted 8 lines

This makes sense. I'll change this patch to use this layout and to keep sections in headers.S before sending v5. (and I guess I'll make the compressed kernel a part of .text). I have a few questions though:

This layout assumes having the local copy of the bootparams as in your RFC patches, right?

Indeed. Otherwise, the setup header may not have been copied to memory by the loader.

Quoted 3 lines

Can I keep the .rodata -- 5th section fits in the section table without much work?

Quoted 8 lines
Quoted 4 lines

You could, but at least the current PE/COFF loader in EDK2 will map it read/write, as it only distinguishes between executable sections and non-executable sections.

At least it will slightly improve security for some implementations (e.g. audk, while being overly strict support RO sections)

Yeah, but more common loaders will put the compressed data in a writable region. I'd prefer to have a simple and common baseline where we always just use R-X for all text and rodata, and RW- for everything else.