Skip to contentSkip to conversation

efi: Fix alignenment issues in unaccepted memory code

PATCH Superseded Kiryl Shutsemau (Meta) 4 participants 14 messages Feb 13 – Feb 16

Subsystems (2)

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover efi: Fix alignenment issues in unaccepted memory code

This series addresses two issues related to unaligned physical addresses and sizes when handling EFI unaccepted memory. These issues were identified as potential sources of kernel panics in Intel TDX environments due to incomplete memory reservation or missing "guard page" extensions.

The first patch fixes the reservation of the unaccepted memory table itself in efi_config_parse_tables(). It ensures the entire page range covering the table is reserved even if the table doesn't start on a page boundary.

The second patch ensures that memory acceptance requests in accept_memory() and range_contains_unaccepted_memory() are page-aligned before performing the unit_size alignment check. This prevents skipping the necessary "guard page" extension for unaligned ranges, which is required to avoid crashes with load_unaligned_zeropad().

Kiryl Shutsemau (Meta) (2):
efi: Fix reservation of unaccepted memory table
efi: Align unaccepted memory range to page boundary

 drivers/firmware/efi/efi.c               |  8 ++++----
 drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)
Signature · 1 line
2.51.2
#1 lore raw

PATCH 1/2 efi: Fix reservation of unaccepted memory table

The reserve_unaccepted() function incorrectly calculates the size of the memblock reservation for the unaccepted memory table. It aligns the size of the table, but fails to account for cases where the table's starting physical address (efi.unaccepted) is not page-aligned.

If the table starts at an offset within a page and its end crosses into a subsequent page that the aligned size does not cover, the end of the table will not be reserved. This can lead to the table being overwritten or inaccessible, causing a kernel panic in accept_memory().

This issue was observed when starting Intel TDX VMs with specific memory sizes (e.g., > 64GB).

Fix this by calculating the end address first (including the unaligned start) and then aligning it up, ensuring the entire range is covered by the reservation.

Fixes 8dbe33956d96 ("efi/unaccepted: Make sure unaccepted table is mapped")
---
 drivers/firmware/efi/efi.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/firmware/efi/efi.c +4 -4
index 111e87a618e5..56e9d73412fa 100644
@@ -692,13 +692,13 @@ static __init int match_config_table(const efi_guid_t *guid,
 
 static __init void reserve_unaccepted(struct efi_unaccepted_memory *unaccepted)
 {
-	phys_addr_t start, size;
+	phys_addr_t start, end;
 
 	start = PAGE_ALIGN_DOWN(efi.unaccepted);
-	size = PAGE_ALIGN(sizeof(*unaccepted) + unaccepted->size);
+	end = PAGE_ALIGN(efi.unaccepted + sizeof(*unaccepted) + unaccepted->size);
 
-	memblock_add(start, size);
-	memblock_reserve(start, size);
+	memblock_add(start, end - start);
+	memblock_reserve(start, end - start);
 }
 
 int __init efi_config_parse_tables(const efi_config_table_t *config_tables,
Signature · 1 line
2.51.2
#11 lore raw

PATCH 2/2 efi: Align unaccepted memory range to page boundary

In reply to Kiryl Shutsemau (Meta)

The accept_memory() and range_contains_unaccepted_memory() functions employ a "guard page" logic to prevent crashes with load_unaligned_zeropad(). This logic extends the range to be accepted (or checked) by one unit_size if the end of the range is aligned to a unit_size boundary.

However, if the caller passes a range that is not page-aligned, the 'end' of the range might not be numerically aligned to unit_size, even if it covers the last page of a unit. This causes the "if (!(end % unit_size))" check to fail, skipping the necessary extension and leaving the next unit unaccepted, which can lead to a kernel panic when accessed by load_unaligned_zeropad().

Align the start address down and the size up to the nearest page boundary before performing the unit_size alignment check. This ensures that the guard unit is correctly added when the range effectively ends on a unit boundary.

---
 drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/firmware/efi/unaccepted_memory.c +10 -2
index c2c067eff634..9ddf3dedd514 100644
@@ -35,14 +35,18 @@ void accept_memory(phys_addr_t start, unsigned long size)
 	struct efi_unaccepted_memory *unaccepted;
 	unsigned long range_start, range_end;
 	struct accept_range range, *entry;
-	phys_addr_t end = start + size;
 	unsigned long flags;
+	phys_addr_t end;
 	u64 unit_size;
 
 	unaccepted = efi_get_unaccepted_table();
 	if (!unaccepted)
 		return;
 
+	start = PAGE_ALIGN_DOWN(start);
+	size = PAGE_ALIGN(size);
+	end = start + size;
+
 	unit_size = unaccepted->unit_size;
 
 	/*
@@ -160,15 +164,19 @@ void accept_memory(phys_addr_t start, unsigned long size)
 bool range_contains_unaccepted_memory(phys_addr_t start, unsigned long size)
 {
 	struct efi_unaccepted_memory *unaccepted;
-	phys_addr_t end = start + size;
 	unsigned long flags;
 	bool ret = false;
+	phys_addr_t end;
 	u64 unit_size;
 
 	unaccepted = efi_get_unaccepted_table();
 	if (!unaccepted)
 		return false;
 
+	start = PAGE_ALIGN_DOWN(start);
+	size = PAGE_ALIGN(size);
+	end = start + size;
+
 	unit_size = unaccepted->unit_size;
 
 	/*
Signature · 1 line
2.51.2
#2 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

In reply to Kiryl Shutsemau (Meta)

drivers/firmware/efi/efi.c static __init int match_config_table(const efi_guid_t *guid, · line 697

Quoted 6 lines · Kiryl Shutsemau (Meta)

static __init void reserve_unaccepted(struct efi_unaccepted_memory *unaccepted) {

drivers/firmware/efi/efi.c +1 -1
-	phys_addr_t start, size;
+	phys_addr_t start, end;
 
 	start = PAGE_ALIGN_DOWN(efi.unaccepted);

Why are we even aligning the start? Isn't *that* the bug?

The memblock code seems to be able to handle arbitrary alignment just fine.

#3 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 9 lines · Dave Hansen

drivers/firmware/efi/efi.c static __init int match_config_table(const efi_guid_t *guid, · line 697

Quoted 6 lines · Kiryl Shutsemau (Meta)

static __init void reserve_unaccepted(struct efi_unaccepted_memory *unaccepted) {

drivers/firmware/efi/efi.c +1 -1
-	phys_addr_t start, size;
+	phys_addr_t start, end;
 
 	start = PAGE_ALIGN_DOWN(efi.unaccepted);

Why are we even aligning the start? Isn't *that* the bug?

How so? It is up to EFI how the table is allocated. We need to be sure that this memory is mapped and not overwritten.

Quoted 1 line

The memblock code seems to be able to handle arbitrary alignment just fine.

Memblock will track it, but, as the comment says, anything smaller than page size will not be mapped, but we need the table to be accessible by kernel.

Signature · 1 line
  Kiryl Shutsemau / Kirill A. Shutemov
#4 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 4 lines · Kiryl Shutsemau
Quoted 1 line

The memblock code seems to be able to handle arbitrary alignment just fine.

Memblock will track it, but, as the comment says, anything smaller than page size will not be mapped, but we need the table to be accessible by kernel.

That seems really, really fragile.

We should first make sure this is intentional memblock behavior and not a bug before we go add more hacks on top of it.

Why would you even present a byte-level reservation interface if it is free to just silently ignore some of the ranges by rounding them off later?

#5 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 6 lines · Dave Hansen
Quoted 4 lines · Kiryl Shutsemau
Quoted 1 line

The memblock code seems to be able to handle arbitrary alignment just fine.

Memblock will track it, but, as the comment says, anything smaller than page size will not be mapped, but we need the table to be accessible by kernel.

Quoted 7 lines

That seems really, really fragile.

We should first make sure this is intentional memblock behavior and not a bug before we go add more hacks on top of it.

Why would you even present a byte-level reservation interface if it is free to just silently ignore some of the ranges by rounding them off later?

+Mike.

My guess that multiple memblock_add() calls might add up to the full page size.

Signature · 1 line
  Kiryl Shutsemau / Kirill A. Shutemov
#6 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 7 lines · Kiryl Shutsemau
Quoted 6 lines · Dave Hansen
Quoted 4 lines · Kiryl Shutsemau
Quoted 1 line

The memblock code seems to be able to handle arbitrary alignment just fine.

Memblock will track it, but, as the comment says, anything smaller than page size will not be mapped, but we need the table to be accessible by kernel.

Quoted 7 lines
Quoted 7 lines

That seems really, really fragile.

We should first make sure this is intentional memblock behavior and not a bug before we go add more hacks on top of it.

Why would you even present a byte-level reservation interface if it is free to just silently ignore some of the ranges by rounding them off later?

Heh, it's x86's choice of memblock iterator that's rounding the ranges ;)

Maybe I miss some context, but my understanding is that for crash kernels the unaccepted table is E820_TYPE_RESERVED and those are never added to memblock.memory by e820 code, hence the call to memblock_add() in reserve_unaccepted().

When x86 creates page tables, init_range_memory_mapping() walks memblock.memory with for_each_mem_pfn_range() that rounds ranges that are not page-aligned, which is normally fine, because it would mean that we miss some partial pages that are divided between E820_RAM and E820_SOMETHING_ELSE.

And Kiryl's intention to round up unaccepted to page boundary seems correct to me.

Quoted 2 lines

My guess that multiple memblock_add() calls might add up to the full page size.

I'm not following here. Can you explain what do you mean?

Multiple memblock_add() calls to adjacent ranges will coalesce into one larger range. But I don't see how is that related.

Quoted 3 lines
Signature · 2 lines
-- 
  Kiryl Shutsemau / Kirill A. Shutemov
Signature · 2 lines
Sincerely yours,
Mike.
#7 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 7 lines · Mike Rapoport
Quoted 2 lines

My guess that multiple memblock_add() calls might add up to the full page size.

I'm not following here. Can you explain what do you mean?

Multiple memblock_add() calls to adjacent ranges will coalesce into one larger range. But I don't see how is that related.

I tried to find justification for the byte-level tracking by memblock. Not in relation to this case, but in general.

Signature · 1 line
  Kiryl Shutsemau / Kirill A. Shutemov
#8 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 11 lines · Kiryl Shutsemau
Quoted 7 lines · Mike Rapoport
Quoted 2 lines

My guess that multiple memblock_add() calls might add up to the full page size.

I'm not following here. Can you explain what do you mean?

Multiple memblock_add() calls to adjacent ranges will coalesce into one larger range. But I don't see how is that related.

I tried to find justification for the byte-level tracking by memblock. Not in relation to this case, but in general.

Probably somewhere deep in git archaeology :)

I presume to not waste a page for every small allocation.

Quoted 2 lines
Signature · 1 line
  Kiryl Shutsemau / Kirill A. Shutemov
Signature · 2 lines
Sincerely yours,
Mike.
#12 lore raw

Re: [PATCH 2/2] efi: Align unaccepted memory range to page boundary

In reply to Kiryl Shutsemau (Meta)
Quoted 32 lines · Kiryl Shutsemau (Meta)

The accept_memory() and range_contains_unaccepted_memory() functions employ a "guard page" logic to prevent crashes with load_unaligned_zeropad(). This logic extends the range to be accepted (or checked) by one unit_size if the end of the range is aligned to a unit_size boundary.

However, if the caller passes a range that is not page-aligned, the 'end' of the range might not be numerically aligned to unit_size, even if it covers the last page of a unit. This causes the "if (!(end % unit_size))" check to fail, skipping the necessary extension and leaving the next unit unaccepted, which can lead to a kernel panic when accessed by load_unaligned_zeropad().

Align the start address down and the size up to the nearest page boundary before performing the unit_size alignment check. This ensures that the guard unit is correctly added when the range effectively ends on a unit boundary.

---
 drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/firmware/efi/unaccepted_memory.c +0 -1
index c2c067eff634..9ddf3dedd514 100644
@@ -35,14 +35,18 @@ void accept_memory(phys_addr_t start, unsigned long size)
 	struct efi_unaccepted_memory *unaccepted;
 	unsigned long range_start, range_end;
 	struct accept_range range, *entry;
-	phys_addr_t end = start + size;
 	unsigned long flags;

drivers/firmware/efi/unaccepted_memory.c void accept_memory(phys_addr_t start, unsigned long size) · line 48

Quoted 10 lines
drivers/firmware/efi/unaccepted_memory.c +4 -0
+	phys_addr_t end;
 	u64 unit_size;
 
 	unaccepted = efi_get_unaccepted_table();
 	if (!unaccepted)
 		return;
 
+	start = PAGE_ALIGN_DOWN(start);
+	size = PAGE_ALIGN(size);
+	end = start + size;

Should this really be:

	end = PAGE_ALIGN(start + size);
	start = PAGE_ALIGN_DOWN(start);

?

Thanks,
Tom

Quoted 25 lines
drivers/firmware/efi/unaccepted_memory.c +6 -1
+
 	unit_size = unaccepted->unit_size;
 
 	/*
@@ -160,15 +164,19 @@ void accept_memory(phys_addr_t start, unsigned long size)
 bool range_contains_unaccepted_memory(phys_addr_t start, unsigned long size)
 {
 	struct efi_unaccepted_memory *unaccepted;
-	phys_addr_t end = start + size;
 	unsigned long flags;
 	bool ret = false;
+	phys_addr_t end;
 	u64 unit_size;
 
 	unaccepted = efi_get_unaccepted_table();
 	if (!unaccepted)
 		return false;
 
+	start = PAGE_ALIGN_DOWN(start);
+	size = PAGE_ALIGN(size);
+	end = start + size;
+
 	unit_size = unaccepted->unit_size;
 
 	/*
#13 lore raw

Re: [PATCH 2/2] efi: Align unaccepted memory range to page boundary

Quoted 46 lines · Tom Lendacky
Quoted 32 lines · Kiryl Shutsemau (Meta)

The accept_memory() and range_contains_unaccepted_memory() functions employ a "guard page" logic to prevent crashes with load_unaligned_zeropad(). This logic extends the range to be accepted (or checked) by one unit_size if the end of the range is aligned to a unit_size boundary.

However, if the caller passes a range that is not page-aligned, the 'end' of the range might not be numerically aligned to unit_size, even if it covers the last page of a unit. This causes the "if (!(end % unit_size))" check to fail, skipping the necessary extension and leaving the next unit unaccepted, which can lead to a kernel panic when accessed by load_unaligned_zeropad().

Align the start address down and the size up to the nearest page boundary before performing the unit_size alignment check. This ensures that the guard unit is correctly added when the range effectively ends on a unit boundary.

---
 drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)
drivers/firmware/efi/unaccepted_memory.c +0 -1
index c2c067eff634..9ddf3dedd514 100644
@@ -35,14 +35,18 @@ void accept_memory(phys_addr_t start, unsigned long size)
 	struct efi_unaccepted_memory *unaccepted;
 	unsigned long range_start, range_end;
 	struct accept_range range, *entry;
-	phys_addr_t end = start + size;
 	unsigned long flags;

drivers/firmware/efi/unaccepted_memory.c void accept_memory(phys_addr_t start, unsigned long size) · line 48

Quoted 10 lines
drivers/firmware/efi/unaccepted_memory.c +4 -0
+	phys_addr_t end;
 	u64 unit_size;
 
 	unaccepted = efi_get_unaccepted_table();
 	if (!unaccepted)
 		return;
 
+	start = PAGE_ALIGN_DOWN(start);
+	size = PAGE_ALIGN(size);
+	end = start + size;

Should this really be:

Quoted 4 lines
	end = PAGE_ALIGN(start + size);
	start = PAGE_ALIGN_DOWN(start);

?

Doh! Yes, you are right.

Signature · 1 line
  Kiryl Shutsemau / Kirill A. Shutemov
#9 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

In reply to Mike Rapoport
Quoted 1 line · Mike Rapoport

Heh, it's x86's choice of memblock iterator that's rounding the ranges 😉

Ahh, good point. I was just assuming that the memblock iteration _had_ to be over PFNs. Silly me.

Quoted 5 lines

Maybe I miss some context, but my understanding is that for crash kernels the unaccepted table is E820_TYPE_RESERVED and those are never added to memblock.memory by e820 code, hence the call to memblock_add() in reserve_unaccepted().

Quoted 8 lines

When x86 creates page tables, init_range_memory_mapping() walks memblock.memory with for_each_mem_pfn_range() that rounds ranges that are not page-aligned, which is normally fine, because it would mean that we miss some partial pages that are divided between E820_RAM and E820_SOMETHING_ELSE.

And Kiryl's intention to round up unaccepted to page boundary seems correct to me.

It fixes the bug for sure.

I'm more worried about the next feature, or the existing features that also only working because memory is page-aligned somewhere (even though it isn't guaranteed to remain that way).

There are two choices for fixing this: One, we do Kiryl's fix plus checks to ensure that all the memblocks that generate direct mappings (is it _just_ the "memory" type?) are padded out to page-aligned boundaries.

The other alternative is to do for_each_mem_range() and do the padding universally when creating the mappings. Maybe _also_ with warnings or maybe a pr_debug().

I do still think it's a little wonky for memblock_add()'s management of the "memory" type to allow unaligned arguments when that type is also used to create page-aligned mapping structures. Memblocks themselves obviously need to be byte-level, but I'm not sure it's the right thing for the "memory" type API.

#10 lore raw

Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table

Quoted 34 lines · Dave Hansen
Quoted 1 line · Mike Rapoport

Heh, it's x86's choice of memblock iterator that's rounding the ranges 😉

Ahh, good point. I was just assuming that the memblock iteration _had_ to be over PFNs. Silly me.

Quoted 5 lines

Maybe I miss some context, but my understanding is that for crash kernels the unaccepted table is E820_TYPE_RESERVED and those are never added to memblock.memory by e820 code, hence the call to memblock_add() in reserve_unaccepted().

Quoted 8 lines

When x86 creates page tables, init_range_memory_mapping() walks memblock.memory with for_each_mem_pfn_range() that rounds ranges that are not page-aligned, which is normally fine, because it would mean that we miss some partial pages that are divided between E820_RAM and E820_SOMETHING_ELSE.

And Kiryl's intention to round up unaccepted to page boundary seems correct to me.

It fixes the bug for sure.

I'm more worried about the next feature, or the existing features that also only working because memory is page-aligned somewhere (even though it isn't guaranteed to remain that way).

There are two choices for fixing this: One, we do Kiryl's fix plus checks to ensure that all the memblocks that generate direct mappings (is it _just_ the "memory" type?) are padded out to page-aligned boundaries.

The other alternative is to do for_each_mem_range() and do the padding universally when creating the mappings. Maybe _also_ with warnings or maybe a pr_debug().

Quoted 5 lines

I do still think it's a little wonky for memblock_add()'s management of the "memory" type to allow unaligned arguments when that type is also used to create page-aligned mapping structures. Memblocks themselves obviously need to be byte-level, but I'm not sure it's the right thing for the "memory" type API.

Well, we could make memblock_add() implicitly cut down the edges when it's adding to memblock.memory and make everything there page aligned, but I truly have no idea what will break and I'm sure something will :)

Another thing that's more on x86 side, is that translation from e820 to memblock only adds E820_TYPE_RAM to memblock. And since in e820 these are mutually exclusive with other e820 types, this could create non-aligned chunks when firmware reservations are not page aligned. It also creates unnecessary holes in memblock.memory that slow down memblock interation a bit and more interestingly, everything that's not in E820_TYPE_RAM is treated as IO and requires ioremap/memremap for access, even it is in DRAM.

If these reserved regions were added to memblock.memory along with being memblock_reserve()ed we wouldn't hit the bug with unaccepted I believe some others as well.

Signature · 2 lines
Sincerely yours,
Mike.