x86/efi: don't allocate memmap through memblock after mm_init()
Subsystems (4)
PATCH v2 1/2 x86/efi: don't allocate memmap through memblock after mm_init()
With commit 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data"), efi_bgrt_init() calls into the memblock allocator through efi_mem_reserve() => efi_arch_mem_reserve() *after* mm_init() has been called.
Indeed, KASAN reports a bad read access later on in efi_free_boot_services():
BUG: KASAN: use-after-free in efi_free_boot_services+0xae/0x24c
at addr ffff88022de12740
Read of size 4 by task swapper/0/0
page:ffffea0008b78480 count:0 mapcount:-127
mapping: (null) index:0x1 flags: 0x5fff8000000000()
[...]
Call Trace:
dump_stack+0x68/0x9f
kasan_report_error+0x4c8/0x500
kasan_report+0x58/0x60
__asan_load4+0x61/0x80
efi_free_boot_services+0xae/0x24c
start_kernel+0x527/0x562
x86_64_start_reservations+0x24/0x26
x86_64_start_kernel+0x157/0x17a
start_cpu+0x5/0x14The instruction at the given address is the first read from the memmap's memory, i.e. the read of md->type in efi_free_boot_services().
Note that the writes earlier in efi_arch_mem_reserve() don't splat because they're done through early_memremap()ed addresses.
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper, efi_memmap_alloc() for this. Use it from efi_arch_mem_reserve() and from efi_free_boot_services() as well.
--- arch/x86/platform/efi/quirks.c | 4 ++-- drivers/firmware/efi/memmap.c | 38 ++++++++++++++++++++++++++++++++++++++ include/linux/efi.h | 1 + 3 files changed, 41 insertions(+), 2 deletions(-)
arch/x86/platform/efi/quirks.c +2 -2
@@ -214,7 +214,7 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size) new_size = efi.memmap.desc_size * num_entries; - new_phys =memblock_alloc (new_size,0 ); + new_phys =efi_memmap_alloc (num_entries);if (!new_phys) {pr_err ("Could not allocate boot services memmap\n" );return ;
@@ -355,7 +355,7 @@ void __init efi_free_boot_services(void) } new_size = efi.memmap.desc_size * num_entries; - new_phys =memblock_alloc (new_size,0 ); + new_phys =efi_memmap_alloc (num_entries);if (!new_phys) {pr_err ("Failed to allocate new EFI memmap\n" );return ;
drivers/firmware/efi/memmap.c +38 -0
@@ -9,6 +9,44 @@#include <linux/efi.h> #include <linux/io.h> #include <asm/early_ioremap.h> +#include <linux/memblock.h> +#include <linux/slab.h> + +static phys_addr_t __init __efi_memmap_alloc_early (unsigned long size) +{ +return memblock_alloc (size,0 ); +} + +static phys_addr_t __init __efi_memmap_alloc_late (unsigned long size) +{ +unsigned int order =get_order (size); +struct page *p =alloc_pages (GFP_KERNEL , order); + +if (!p) +return 0 ; + +return PFN_PHYS (page_to_pfn (p)); +} + +/** +* efi_memmap_alloc - Allocate memory for the EFI memory map +* @num_entries: Number of entries in the allocated map. +* +* Depending on whether mm_init() has already been invoked or not, +* either memblock or "normal" page allocation is used. +* +* Returns the physical address of the allocated memory map on +* success, zero on failure. +*/ +phys_addr_t __init efi_memmap_alloc (unsigned int num_entries) +{ +unsigned long size = num_entries * efi.memmap.desc_size; + +if (slab_is_available ()) +return __efi_memmap_alloc_late (size); + +return __efi_memmap_alloc_early (size); +}/** * __efi_memmap_init - Common code for mapping the EFI memory map
include/linux/efi.h +1 -0
@@ -950,6 +950,7 @@ static inline efi_status_t efi_query_variable_store(u32 attributes,#endif extern void __iomem *efi_lookup_mapped_addr (u64 phys_addr); +extern phys_addr_t __init efi_memmap_alloc (unsigned int num_entries);extern int __init efi_memmap_init_early (struct efi_memory_map_data *data);extern int __init efi_memmap_init_late (phys_addr_t addr,unsigned long size);extern void __init efi_memmap_unmap (void );
Signature · 1 line
2.11.0
PATCH v2 2/2 efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
Before invoking the arch specific handler, efi_mem_reserve() reserves the given memory region through memblock.
efi_mem_reserve() can get called after mm_init() though -- through efi_bgrt_init(), for example. After mm_init(), memblock is dead and should not be used anymore.
Let efi_mem_reserve() check whether memblock is dead and not do the reservation if so. Emit a warning from the generic efi_arch mem_reserve() in this case: if the architecture doesn't provide any other means of registering the region as reserved, the operation would be a nop.
---
Changes to v1:
Change the if condition from slab_is_available() to !slab_is_available as pointed out by Mika Penttilä at
http://lkml.kernel.org/r/[email protected]
drivers/firmware/efi/efi.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)
drivers/firmware/efi/efi.c +5 -2
@@ -403,7 +403,10 @@ u64 __init efi_mem_desc_end(efi_memory_desc_t *md)return end; } -void __init __weak efi_arch_mem_reserve (phys_addr_t addr,u64 size) {} +void __init __weak efi_arch_mem_reserve (phys_addr_t addr,u64 size) +{ +WARN (slab_is_available (),"efi_mem_reserve() has no effect" ); +}/** * efi_mem_reserve - Reserve an EFI memory region
@@ -419,7 +422,7 @@ void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}*/ void __init efi_mem_reserve (phys_addr_t addr,u64 size) { -if (!memblock_is_region_reserved (addr, size)) +if (!slab_is_available () && !memblock_is_region_reserved (addr, size))memblock_reserve (addr, size);/*
Signature · 1 line
2.11.0
Quoted 35 lines · Nicolai Stange
With commit
4bc9f92e64c8("x86/efi-bgrt: Useefi_mem_reserve()to avoid copying image data"),efi_bgrt_init()calls into the memblock allocator throughefi_mem_reserve()=>efi_arch_mem_reserve()*after*mm_init()has been called.Indeed, KASAN reports a bad read access later on in
efi_free_boot_services():BUG: KASAN: use-after-free in efi_free_boot_services+0xae/0x24c at addr ffff88022de12740 Read of size 4 by task swapper/0/0 page:ffffea0008b78480 count:0 mapcount:-127 mapping: (null) index:0x1 flags: 0x5fff8000000000() [...] Call Trace: dump_stack+0x68/0x9f kasan_report_error+0x4c8/0x500 kasan_report+0x58/0x60 __asan_load4+0x61/0x80 efi_free_boot_services+0xae/0x24c start_kernel+0x527/0x562 x86_64_start_reservations+0x24/0x26 x86_64_start_kernel+0x157/0x17a start_cpu+0x5/0x14The instruction at the given address is the first read from the memmap's memory, i.e. the read of
md->typeinefi_free_boot_services().Note that the writes earlier in
efi_arch_mem_reserve()don't splat because they're done through early_memremap()ed addresses.So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.
Quoted 7 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>--- arch/x86/platform/efi/quirks.c | 4 ++-- drivers/firmware/efi/memmap.c | 38 ++++++++++++++++++++++++++++++++++++++ include/linux/efi.h | 1 + 3 files changed, 41 insertions(+), 2 deletions(-)
Nice catch. Could you also modify efi_fake_memmap() to use your new efi_memmap_alloc() function for consistency (note that all memblock_alloc()s should probably be PAGE_SIZE aligned like the fakemem code)?
Quoted 10 lines · Matt Fleming
Quoted 6 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistency
Sure.
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling efi_memmap_unmap() though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.
Quoted 2 lines
(note that all memblock_alloc()s should probably be
PAGE_SIZEaligned like the fakemem code)?
Ok, but I'd really like to understand why: I can't find anything in neither the code nor in the UEFI spec requiring this. And up to now, efi_arch_mem_reserve() as well as efi_free_boot_services() used to do those unaligned allocations...
In light of this, is there really a necessity for using whole page allocations after mm_init() or would kmalloc() suffice here? Provided that the memremap bits get adjusted accordingly, of course.
So, I'm thinking of turning the ->late boolean into a tristate like the following:
Memory allocated by | Memory mapped through --------------------|---------------------- memblock | early_memremap memblock | memremap kmalloc | -
Neglecting slub overhead, the use of kmalloc() over alloc_pages() would save 4096 - 12*40 == 3616 Bytes on my system with its 12 entries under /sys/firmware/efi/runtime-map/. Not really critical, but if it comes for free, why not?
Thanks,
Nicolai
Quoted 31 lines · Nicolai Stange
With commit
4bc9f92e64c8("x86/efi-bgrt: Useefi_mem_reserve()to avoid copying image data"),efi_bgrt_init()calls into the memblock allocator throughefi_mem_reserve()=>efi_arch_mem_reserve()*after*mm_init()has been called.Indeed, KASAN reports a bad read access later on in
efi_free_boot_services():BUG: KASAN: use-after-free in efi_free_boot_services+0xae/0x24c at addr ffff88022de12740 Read of size 4 by task swapper/0/0 page:ffffea0008b78480 count:0 mapcount:-127 mapping: (null) index:0x1 flags: 0x5fff8000000000() [...] Call Trace: dump_stack+0x68/0x9f kasan_report_error+0x4c8/0x500 kasan_report+0x58/0x60 __asan_load4+0x61/0x80 efi_free_boot_services+0xae/0x24c start_kernel+0x527/0x562 x86_64_start_reservations+0x24/0x26 x86_64_start_kernel+0x157/0x17a start_cpu+0x5/0x14The instruction at the given address is the first read from the memmap's memory, i.e. the read of
md->typeinefi_free_boot_services().Note that the writes earlier in
efi_arch_mem_reserve()don't splat because they're done through early_memremap()ed addresses.
Quoted 6 lines
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>
This addresses the v4.9 boot regression I reported:
Quoted 13 lines · Nicolai Stange
Quoted 10 lines · Matt Fleming
Quoted 6 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistency
Quoted 7 lines
Sure.
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling
efi_memmap_unmap()though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.
Will that patch be intrusive?
If yes then we'll need to keep this a separate urgent patch to fix the v4.9 regression that Dan Williams reported. I can apply the fix to efi/urgent and get it to Linus straight away if you guys agree.
Thanks,
Ingo
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
In reply to Nicolai StangeQuoted 6 lines · Nicolai Stange
Before invoking the arch specific handler,
efi_mem_reserve()reserves the given memory region through memblock.
efi_mem_reserve()can get called aftermm_init()though -- throughefi_bgrt_init(), for example. Aftermm_init(), memblock is dead and should not be used anymore.
It did not fail during previous test so we did not catch this bug, if memblock can not be used after mm_init(), IMHO it should fail instead of silently succeed.
Matt, can we move the efi_mem_reserve to earlier code for example in efi_memblock_x86_reserve_range just after reserving the memmap?
Quoted 49 lines
Let
efi_mem_reserve()check whether memblock is dead and not do the reservation if so. Emit a warning from the genericefi_archmem_reserve()in this case: if the architecture doesn't provide any other means of registering the region as reserved, the operation would be a nop.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>---
Changes to v1:
Change the if condition fromslab_is_available()to !slab_is_available as pointed out by Mika Penttilä at
http://lkml.kernel.org/r/c7bf34ba-56f0-8346-36d1-7069f2115dcf-MRsr7dthA9VWk0Htik3J/[email protected]drivers/firmware/efi/efi.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-)drivers/firmware/efi/efi.c +5
-2@@ -403,7 +403,10 @@ u64 __init efi_mem_desc_end(efi_memory_desc_t *md)return end; } -void __init __weak efi_arch_mem_reserve (phys_addr_t addr,u64 size) {} +void __init __weak efi_arch_mem_reserve (phys_addr_t addr,u64 size) +{ +WARN (slab_is_available (),"efi_mem_reserve() has no effect" ); +}/** * efi_mem_reserve - Reserve an EFI memory region @@ -419,7 +422,7 @@ void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}*/ void __init efi_mem_reserve (phys_addr_t addr,u64 size) { -if (!memblock_is_region_reserved (addr, size)) +if (!slab_is_available () && !memblock_is_region_reserved (addr, size))memblock_reserve (addr, size);/* Signature · 6 lines
2.11.0 -- To unsubscribe from this list: send the line "unsubscribe linux-efi" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Thanks
Dave
Quoted 24 lines · Ingo Molnar
Quoted 13 lines · Nicolai Stange
Quoted 10 lines · Matt Fleming
Quoted 6 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistencyQuoted 7 lines
Sure.
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling
efi_memmap_unmap()though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.
Quoted 5 lines
Will that patch be intrusive?
If yes then we'll need to keep this a separate urgent patch to fix the v4.9 regression that Dan Williams reported. I can apply the fix to efi/urgent and get it to Linus straight away if you guys agree.
Ditto question to Matt as I asked in reply to patch 2/2, can we move the efi_mem_reserve to early code so that memblock is still usable and consider to improve it in other way later?
Quoted 8 lines
Thanks,
Ingo
--
To unsubscribe from this list: send the line "unsubscribe linux-efi" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 18 lines · Ingo Molnar
Quoted 15 lines · Nicolai Stange
Quoted 10 lines · Matt Fleming
Quoted 6 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal" page allocator. Introduce a helper,
efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistencySure.
Quoted 8 lines
Quoted 5 lines
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling
efi_memmap_unmap()though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.Will that patch be intrusive?
Given that memblock_alloc() calls memblock_reserve() on its allocations, we could simply consult the memblock_reserved table to infer whether the allocation being freed was created with memblock_alloc() or with alloc_pages(). So I don't think such a patch should be that intrusive. But the normal case is that the EFI memory map remains mapped during the lifetime of the system, and unmapping the EFI memory map does not necessarily imply that it should be freed. This is especially true on ARM systems, where the memory map is allocated and populated by the stub, and never modified by the kernel proper, and so any freeing logic in generic code should take this into account as well (i.e., the memory map allocation is not memblock_reserve()'d, nor is it allocated using alloc_pages())
Quoted 4 lines
If yes then we'll need to keep this a separate urgent patch to fix the v4.9 regression that Dan Williams reported. I can apply the fix to efi/urgent and get it to Linus straight away if you guys agree.
Considering the severity of the issue it solves, and the obvious correctness of the fix, my preference would be to spin a v3 of this patch taking Matt's feedback into account, and merging that as a fix for v4.10 with a cc stable. The 2/2 can wait a bit longer imo
Quoted 21 lines · Ard Biesheuvel
Quoted 20 lines · Ingo Molnar
Quoted 17 lines · Nicolai Stange
Quoted 6 lines · Matt Fleming
Quoted 5 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal"
page allocator. Introduce a helper,efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Quoted 6 lines
Quoted 3 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() toavoid copying image data")
Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistencySure.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling
efi_memmap_unmap()though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.Will that patch be intrusive?
Yes, definitely something for 4.11+.
Quoted 4 lines
Given that
memblock_alloc()callsmemblock_reserve()on its allocations, we could simply consult thememblock_reservedtable to infer whether the allocation being freed was created withmemblock_alloc()or withalloc_pages().
Not sure whether this would work with CONFIG_ARCH_DISCARD_MEMBLOCK=y. This is also the reason why 2/2 is needed.
Quoted 18 lines
So I don't think such a patch
should be that intrusive. But the normal case is that the EFI memory map remains mapped during the lifetime of the system, and unmapping the EFI memory map does not necessarily imply that it should be freed. This is especially true on ARM systems, where the memory map is allocated and populated by the stub, and never modified by the kernel proper, and so any freeing logic in generic code should take this into account as well (i.e., the memory map allocation is not memblock_reserve()'d, nor is it allocated usingalloc_pages())Quoted 5 lines
If yes then we'll need to keep this a separate urgent patch to fix the v4.9 regression that Dan Williams reported. I can apply the fix to efi/urgent and get
it to Linus straight away if you guys agree.
Quoted 4 lines
Considering the severity of the issue it solves, and the obvious correctness of the fix, my preference would be to spin a v3 of this patch taking Matt's feedback into account, and merging that as a fix for v4.10 with a cc stable. The 2/2 can wait a bit longer imo
Matt's Feedback included that
"all memblock_alloc()s should probably be PAGE_SIZE aligned like the
fakemem code"
Unfortunately, I can't see why this would be needed. Furthermore, this isn't currently done outside of fakemem and thus, aliging the memmap allocations on PAGE_SIZE would be another, quite unrelated change?
So, are you Ok with only taking the other review comment, namely
"modify efi_fake_memmap() to use your new efi_memmap_alloc() function
for consistency"
into account for a v3?
Thanks,
Nicolai
Quoted 34 lines · Nicolai Stange
Quoted 21 lines · Ard Biesheuvel
Quoted 20 lines · Ingo Molnar
Quoted 17 lines · Nicolai Stange
Quoted 6 lines · Matt Fleming
Quoted 5 lines · Nicolai Stange
So, after memblock is gone, allocations should be done through the "normal"
page allocator. Introduce a helper,efi_memmap_alloc()for this. Use it fromefi_arch_mem_reserve()and fromefi_free_boot_services()as well.Quoted 6 lines
Quoted 3 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() toavoid copying image data")
Signed-off-by Nicolai Stange <[email protected]>Could you also modify
efi_fake_memmap()to use your newefi_memmap_alloc()function for consistencySure.
Quoted 7 lines
Quoted 7 lines
Quoted 5 lines
I'm planning to submit another set of patches addressing the (bounded) memmap leaking in anything calling
efi_memmap_unmap()though. In the course of doing so, the memmap allocation sites will get touched anyway:
I'll have to store some information about how the memmap's memory has been obtained.Will that patch be intrusive?
Yes, definitely something for 4.11+.
Quoted 8 lines
Quoted 4 lines
Given that
memblock_alloc()callsmemblock_reserve()on its allocations, we could simply consult thememblock_reservedtable to infer whether the allocation being freed was created withmemblock_alloc()or withalloc_pages().Not sure whether this would work with
CONFIG_ARCH_DISCARD_MEMBLOCK=y. This is also the reason why 2/2 is needed.
OK, I hadn't considered that. It is rather unfortunate that on x86, each call to efi_arch_mem_reserve() could potentially result in a new allocation to be created for the entire memory map (consisting of hundreds of 40-byte entries), leaking the old one. So I agree that this code needs some work, and I also agree that it is v4.11 material at the earliest.
Quoted 23 lines
Quoted 18 lines
So I don't think such a patch
should be that intrusive. But the normal case is that the EFI memory map remains mapped during the lifetime of the system, and unmapping the EFI memory map does not necessarily imply that it should be freed. This is especially true on ARM systems, where the memory map is allocated and populated by the stub, and never modified by the kernel proper, and so any freeing logic in generic code should take this into account as well (i.e., the memory map allocation is not memblock_reserve()'d, nor is it allocated usingalloc_pages())Quoted 5 lines
If yes then we'll need to keep this a separate urgent patch to fix the v4.9 regression that Dan Williams reported. I can apply the fix to efi/urgent and get
it to Linus straight away if you guys agree.Quoted 4 lines
Considering the severity of the issue it solves, and the obvious correctness of the fix, my preference would be to spin a v3 of this patch taking Matt's feedback into account, and merging that as a fix for v4.10 with a cc stable. The 2/2 can wait a bit longer imo
Quoted 9 lines
Matt's Feedback included that
"all memblock_alloc()s should probably be
PAGE_SIZEaligned like the
fakemem code"Unfortunately, I can't see why this would be needed. Furthermore, this isn't currently done outside of fakemem and thus, aliging the memmap allocations on
PAGE_SIZEwould be another, quite unrelated change?
We use a pool allocation for the memory map on ARM, which is never page aligned (and page aligned in EFI doesn't mean as much when the OS page size is 16k or 64k) so I think you are correct here.
Quoted 7 lines
So, are you Ok with only taking the other review comment, namely
"modify
efi_fake_memmap()to use your newefi_memmap_alloc()function
for consistency"into account for a v3?
Yes, that should be sufficient for a fix that can be backported. Anything else can wait for now
Quoted 11 lines · Ard Biesheuvel
Quoted 7 lines · Nicolai Stange
So, are you Ok with only taking the other review comment, namely
"modify
efi_fake_memmap()to use your newefi_memmap_alloc()function
for consistency"into account for a v3?
Yes, that should be sufficient for a fix that can be backported. Anything else can wait for now
Ard, thanks for your help!
v3 is here:
http://lkml.kernel.org/r/20170105125130.2815-1-nicstange-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org
Nicolai
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
In reply to Dave YoungQuoted 10 lines · Dave Young
Quoted 6 lines · Nicolai Stange
Before invoking the arch specific handler,
efi_mem_reserve()reserves the given memory region through memblock.
efi_mem_reserve()can get called aftermm_init()though -- throughefi_bgrt_init(), for example. Aftermm_init(), memblock is dead and should not be used anymore.It did not fail during previous test so we did not catch this bug, if memblock can not be used after
mm_init(), IMHO it should fail instead of silently succeed.
This must literally be the fifth time or so that I've been caught out by this over the years because there's no hard error if you call the memblock code after slab and co. are up.
MM folks, is there some way to catch these errors without requiring the sprinkling of slab_is_available() everywhere?
Quoted 2 lines
Matt, can we move the
efi_mem_reserveto earlier code for example inefi_memblock_x86_reserve_rangejust after reserving the memmap?
No, it *needs* to be callable from efi_bgrt_init(), because you only want to reserve those regions if you have the BGRT driver available.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
Quoted 12 lines · Matt Fleming
Quoted 10 lines · Dave Young
Quoted 6 lines · Nicolai Stange
Before invoking the arch specific handler,
efi_mem_reserve()reserves the given memory region through memblock.
efi_mem_reserve()can get called aftermm_init()though -- throughefi_bgrt_init(), for example. Aftermm_init(), memblock is dead and should not be used anymore.It did not fail during previous test so we did not catch this bug, if memblock can not be used after
mm_init(), IMHO it should fail instead of silently succeed.
Quoted 7 lines
This must literally be the fifth time or so that I've been caught out by this over the years because there's no hard error if you call the memblock code after slab and co. are up.
MM folks, is there some way to catch these errors without requiring the sprinkling of
slab_is_available()everywhere?
Well, you could put in a __init global variable about availability into mm/memblock.c and then check it in memblock APIs like memblock_reserve() to BUG_ON? I know BUG_ON is frowned upon but this is not likely to be a situation that can be sensibly recovered.
Signature · 8 lines
Mel Gorman SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
Quoted 5 lines · Mel Gorman
Well, you could put in a
__initglobal variable about availability intomm/memblock.cand then check it in memblock APIs likememblock_reserve()toBUG_ON? I knowBUG_ONis frowned upon but this is not likely to be a situation that can be sensibly recovered.
Indeed. I've only ever seen this situation lead to silent memory corruption and bitter tears.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
In reply to Matt FlemingQuoted 16 lines · Matt Fleming
Quoted 10 lines · Dave Young
Quoted 6 lines · Nicolai Stange
Before invoking the arch specific handler,
efi_mem_reserve()reserves the given memory region through memblock.
efi_mem_reserve()can get called aftermm_init()though -- throughefi_bgrt_init(), for example. Aftermm_init(), memblock is dead and should not be used anymore.It did not fail during previous test so we did not catch this bug, if memblock can not be used after
mm_init(), IMHO it should fail instead of silently succeed.This must literally be the fifth time or so that I've been caught out by this over the years because there's no hard error if you call the memblock code after slab and co. are up.
Quoted 8 lines
MM folks, is there some way to catch these errors without requiring the sprinkling of
slab_is_available()everywhere?Quoted 2 lines
Matt, can we move the
efi_mem_reserveto earlier code for example inefi_memblock_x86_reserve_rangejust after reserving the memmap?No, it *needs* to be callable from
efi_bgrt_init(), because you only want to reserve those regions if you have the BGRT driver available.
It is true that it depends on acpi init, I was wondering if bgrt parsing can be moved to early acpi code. But anyway I'm not sure it is doable and worth.
Thanks
Dave
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
Quoted 4 lines · Dave Young
It is true that it depends on acpi init, I was wondering if bgrt parsing can be moved to early acpi code. But anyway I'm not sure it is doable and worth.
That's a good question. I think I gave up last time I tried to move the BGRT code to early boot because of the dependencies involved with having the ACPI table parsing code initialised.
But if you want to take a crack at it, I'd be happy to review the patches.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
Quoted 6 lines · Matt Fleming
Quoted 4 lines · Dave Young
It is true that it depends on acpi init, I was wondering if bgrt parsing can be moved to early acpi code. But anyway I'm not sure it is doable and worth.
Quoted 6 lines
That's a good question. I think I gave up last time I tried to move the BGRT code to early boot because of the dependencies involved with having the ACPI table parsing code initialised.
But if you want to take a crack at it, I'd be happy to review the patches.
Ok, I will have a try.
Thanks
Dave
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()
In reply to Mel GormanQuoted 5 lines · Mel Gorman
Well, you could put in a
__initglobal variable about availability intomm/memblock.cand then check it in memblock APIs likememblock_reserve()toBUG_ON? I knowBUG_ONis frowned upon but this is not likely to be a situation that can be sensibly recovered.
What about something like this?
BUG_ON() shouldn't actually be necessary because I couldn't think of a situation where A) memblock would be unavailable and B) returning an error would prevent us from making progress.
---->8----
Quoted 1 line
From
1c1c06664d23c5d256016918c54e01802af4e891Mon Sep 17 00:00:00 2001
From: Matt Fleming <[email protected]>
Date: Mon, 27 Feb 2017 21:14:29 +0000
Subject: [PATCH] mm/memblock: Warn if used after slab is up and prevent memory
corruption
Historically there have been many memory corruption bugs caused by using the memblock API after its internal data structures have been destroyed. The latest bug was fixed in commit,
20b1e22d01a4 ("x86/efi: Don't allocate memmap through memblock after mm_init()")
Instead of modifying the memblock data structures that no longer exist and silently corrupting memory, WARN and return with an error.
--- mm/memblock.c | 6 ++++++ 1 file changed, 6 insertions(+)
mm/memblock.c +6 -0
@@ -530,6 +530,9 @@ int __init_memblock memblock_add_range(struct memblock_type *type,if (!size)return 0 ; +if (WARN_ONCE (slab_is_available (),"memblock no longer available\n" )) +return -EINVAL ; +/* special case for empty array */ if (type->regions[0 ].size ==0 ) {WARN_ON (type->cnt !=1 || type->total_size);
@@ -648,6 +651,9 @@ static int __init_memblock memblock_isolate_range(struct memblock_type *type,if (!size)return 0 ; +if (WARN_ONCE (slab_is_available (),"memblock no longer available\n" )) +return -EINVAL ; +/* we'll create at most two more regions */ while (type->cnt +2 > type->max)if (memblock_double_array (type, base, size) <0 )
Signature · 7 lines
2.10.0 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>