efi: Fix alignenment issues in unaccepted memory code
Subsystems (2)
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
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.
--- drivers/firmware/efi/efi.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/firmware/efi/efi.c +4 -4
@@ -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
Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table
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
__initvoidreserve_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.
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
__initvoidreserve_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
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?
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
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.
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
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.
Re: [PATCH 1/2] efi: Fix reservation of unaccepted memory table
In reply to Mike RapoportQuoted 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_RESERVEDand those are never added to memblock.memory by e820 code, hence the call tomemblock_add()inreserve_unaccepted().
Quoted 8 lines
When x86 creates page tables,
init_range_memory_mapping()walks memblock.memory withfor_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 betweenE820_RAMandE820_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.
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_RESERVEDand those are never added to memblock.memory by e820 code, hence the call tomemblock_add()inreserve_unaccepted().Quoted 8 lines
When x86 creates page tables,
init_range_memory_mapping()walks memblock.memory withfor_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 betweenE820_RAMandE820_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 apr_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.
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
@@ -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
Re: [PATCH 2/2] efi: Align unaccepted memory range to page boundary
Quoted 32 lines · Kiryl Shutsemau (Meta)
The
accept_memory()andrange_contains_unaccepted_memory()functions employ a "guard page" logic to prevent crashes withload_unaligned_zeropad(). This logic extends the range to be accepted (or checked) by oneunit_sizeif the end of the range is aligned to aunit_sizeboundary.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 byload_unaligned_zeropad().Align the start address down and the size up to the nearest page boundary before performing the
unit_sizealignment check. This ensures that the guard unit is correctly added when the range effectively ends on a unit boundary.Signed-off-by Kiryl Shutsemau (Meta) <[email protected]>--- drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)drivers/firmware/efi/unaccepted_memory.c +0
-1@@ -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;/*
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()andrange_contains_unaccepted_memory()functions employ a "guard page" logic to prevent crashes withload_unaligned_zeropad(). This logic extends the range to be accepted (or checked) by oneunit_sizeif the end of the range is aligned to aunit_sizeboundary.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 byload_unaligned_zeropad().Align the start address down and the size up to the nearest page boundary before performing the
unit_sizealignment check. This ensures that the guard unit is correctly added when the range effectively ends on a unit boundary.Signed-off-by Kiryl Shutsemau (Meta) <[email protected]>--- drivers/firmware/efi/unaccepted_memory.c | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-)drivers/firmware/efi/unaccepted_memory.c +0
-1@@ -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