Skip to contentSkip to conversation

x86/efi: don't allocate memmap through memblock after mm_init()

PATCH Superseded Nicolai Stange 7 participants 19 messages Dec 22, 2016 – Feb 27, 2017

Subsystems (4)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

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/0x14

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

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")
---
 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
index 10aca63a50d7..30031d5293c4 100644
@@ -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
index f03ddecd232b..78686443cb37 100644
@@ -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
index a07a476178cd..0c5420208c40 100644
@@ -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
#1 lore raw

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.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

---
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
index 92914801e388..158a8df2f4af 100644
@@ -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
#10 lore raw
In reply to Nicolai Stange
Quoted 35 lines · Nicolai Stange

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/0x14

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

Quoted 7 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")
---
 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)?

#11 lore raw
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_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_SIZE aligned 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

Tested-by on v2 1/2
#18 lore raw
In reply to Nicolai Stange
Quoted 31 lines · Nicolai Stange

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/0x14

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

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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

This addresses the v4.9 boot regression I reported:

http://marc.info/?l=linux-kernel&m=148349836923836&w=2

#12 lore raw
In reply to Nicolai Stange
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_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

#2 lore raw

Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()

In reply to Nicolai Stange
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 after mm_init() though -- through efi_bgrt_init(), for example. After mm_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 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.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

---
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/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
index 92914801e388..158a8df2f4af 100644
@@ -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

#13 lore raw
In reply to Ingo Molnar
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_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.

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

#14 lore raw
In reply to Ingo Molnar
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_memmap_alloc() function for consistency

Sure.

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

#15 lore raw
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Quoted 6 lines
Quoted 3 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to

avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_memmap_alloc() function for consistency

Sure.

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() 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().

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 using alloc_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

#16 lore raw
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 from efi_arch_mem_reserve() and from efi_free_boot_services() as well.

Quoted 6 lines
Quoted 3 lines
Fixes 4bc9f92e64c8 ("x86/efi-bgrt: Use efi_mem_reserve() to

avoid copying image data")

Could you also modify efi_fake_memmap() to use your new efi_memmap_alloc() function for consistency

Sure.

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() 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().

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 using alloc_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_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?

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 new efi_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

#17 lore raw
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 new efi_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

#3 lore raw

Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()

In reply to Dave Young
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 after mm_init() though -- through efi_bgrt_init(), for example. After mm_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_reserve to earlier code for example in efi_memblock_x86_reserve_range just 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>

#4 lore raw

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 after mm_init() though -- through efi_bgrt_init(), for example. After mm_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>
#5 lore raw

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

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>

#7 lore raw

Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()

In reply to Matt Fleming
Quoted 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 after mm_init() though -- through efi_bgrt_init(), for example. After mm_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_reserve to earlier code for example in efi_memblock_x86_reserve_range just 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>

#8 lore raw

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>

#9 lore raw

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>

#6 lore raw

Re: [PATCH v2 2/2] efi: efi_mem_reserve(): don't reserve through memblock after mm_init()

In reply to Mel Gorman
Quoted 5 lines · Mel Gorman

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.

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 1c1c06664d23c5d256016918c54e01802af4e891 Mon 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.

Cc Nicolai Stange <[email protected]>
Cc Dave Young <[email protected]>
Cc Ard Biesheuvel <[email protected]>
Cc Mel Gorman <[email protected]>
Cc Andrew Morton <[email protected]>
Cc Vlastimil Babka <[email protected]>
Cc Michal Hocko <[email protected]>
---
 mm/memblock.c | 6 ++++++
 1 file changed, 6 insertions(+)
mm/memblock.c +6 -0
index 7608bc305936..4dbd86f2fddb 100644
@@ -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>