Skip to contentSkip to conversation

x86/alternative: delay freeing of smp_locks section

PATCH In review Mike Rapoport 3 participants 5 messages Mar 30 – Apr 3 x86

lore
Share & tools
lore
#0 lore raw

PATCH v2 1/1 x86/alternative: delay freeing of smp_locks section

From: "Mike Rapoport (Microsoft)" <[email protected]>

On SMP systems alternative_instructions() frees memory occupied by smp_locks section immediately after patching the lock instructions.

The memory is freed using free_init_pages() that calls free_reserved_area() that essentially does __free_page() for every page in the range.

Up until recently it didn't update memblock state so in cases when CONFIG_ARCH_KEEP_MEMBLOCK is enabled (on x86 it is selected by INTEL_TDX_HOST), the state of memblock and the memory map would be inconsistent.

Additionally, with CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled feeing of smp_locks happens before the memory map is fully initialized and freeing reserved memory may case an access to not-yet-initialized struct page when __free_page() searches for a buddy page.

Following the discussion in [1], implementation of memblock_free_late() and free_reserved_area() was unified to ensure that reserved memory that's freed after memblock transfers the pages to the buddy allocator is actually freed and that the memblock and the memory map are consistent. As a part of these changes, free_reserved_area() now WARN()s when it is called before the initialization of the memory map is complete.

The memory map is fully initialized in page_alloc_init_late() that completes before initcalls are executed, so it is safe to free reserved memory in any initcall except early_initcall().

Move freeing of smp_locks section to an initcall to ensure it will happen after the memory map is fully initialized. Since it does not matter which exactly initcall to use and the code lives in arch/, pick arch_initcall.

[1] https://lore.kernel.org/all/ec2aaef14783869b3be6e3c253b2dcbf67dbc12a.camel@kernel.crashing.org

---
 arch/x86/kernel/alternative.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)
arch/x86/kernel/alternative.c +17 -5
index e87da25d1236..62936a3bde19 100644
@@ -2448,19 +2448,31 @@ void __init alternative_instructions(void)
 					    __smp_locks, __smp_locks_end,
 					    _text, _etext);
 	}
+#endif
 
+	restart_nmi();
+	alternatives_patched = 1;
+
+	alt_reloc_selftest();
+}
+
+#ifdef CONFIG_SMP
+/*
+ * With CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled we can free_init_pages() only
+ * after the deferred initialization of the memory map is complete.
+ */
+static int __init free_smp_locks(void)
+{
 	if (!uniproc_patched || num_possible_cpus() == 1) {
 		free_init_pages("SMP alternatives",
 				(unsigned long)__smp_locks,
 				(unsigned long)__smp_locks_end);
 	}
-#endif
 
-	restart_nmi();
-	alternatives_patched = 1;
-
-	alt_reloc_selftest();
+	return 0;
 }
+arch_initcall(free_smp_locks);
+#endif
 
 /**
  * text_poke_early - Update instructions on a live kernel at boot time

base-commit: e77a5a5cfe43b4c25bd44a3818e487033287517f

Signature · 1 line
2.53.0
#1 lore raw
Quoted 25 lines · Mike Rapoport

From: "Mike Rapoport (Microsoft)" <[email protected]>

On SMP systems alternative_instructions() frees memory occupied by smp_locks section immediately after patching the lock instructions.

The memory is freed using free_init_pages() that calls free_reserved_area() that essentially does __free_page() for every page in the range.

Up until recently it didn't update memblock state so in cases when CONFIG_ARCH_KEEP_MEMBLOCK is enabled (on x86 it is selected by INTEL_TDX_HOST), the state of memblock and the memory map would be inconsistent.

Additionally, with CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled feeing of smp_locks happens before the memory map is fully initialized and freeing reserved memory may case an access to not-yet-initialized struct page when __free_page() searches for a buddy page.

Following the discussion in [1], implementation of memblock_free_late() and free_reserved_area() was unified to ensure that reserved memory that's freed after memblock transfers the pages to the buddy allocator is actually freed and that the memblock and the memory map are consistent. As a part of these changes, free_reserved_area() now WARN()s when it is called before the initialization of the memory map is complete.

Quoted 7 lines

The memory map is fully initialized in page_alloc_init_late() that completes before initcalls are executed, so it is safe to free reserved memory in any initcall except early_initcall().

Move freeing of smp_locks section to an initcall to ensure it will happen after the memory map is fully initialized. Since it does not matter which exactly initcall to use and the code lives in arch/, pick arch_initcall.

Silly question, why not put the .smp_locks in __init_begin[],__init_end[] right next to .altinstr such that it gets freed by free_initmem() ?

#2 lore raw
Quoted 30 lines · Peter Zijlstra
Quoted 29 lines · Mike Rapoport

From: "Mike Rapoport (Microsoft)" <[email protected]>

On SMP systems alternative_instructions() frees memory occupied by smp_locks section immediately after patching the lock instructions.

The memory is freed using free_init_pages() that calls free_reserved_area() that essentially does __free_page() for every page in the range.

Up until recently it didn't update memblock state so in cases when CONFIG_ARCH_KEEP_MEMBLOCK is enabled (on x86 it is selected by INTEL_TDX_HOST), the state of memblock and the memory map would be inconsistent.

Additionally, with CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled feeing of smp_locks happens before the memory map is fully initialized and freeing reserved memory may case an access to not-yet-initialized struct page when __free_page() searches for a buddy page.

Following the discussion in [1], implementation of memblock_free_late() and free_reserved_area() was unified to ensure that reserved memory that's freed after memblock transfers the pages to the buddy allocator is actually freed and that the memblock and the memory map are consistent. As a part of these changes, free_reserved_area() now WARN()s when it is called before the initialization of the memory map is complete.

The memory map is fully initialized in page_alloc_init_late() that completes before initcalls are executed, so it is safe to free reserved memory in any initcall except early_initcall().

Quoted 7 lines
Quoted 3 lines

Move freeing of smp_locks section to an initcall to ensure it will happen after the memory map is fully initialized. Since it does not matter which exactly initcall to use and the code lives in arch/, pick arch_initcall.

Silly question, why not put the .smp_locks in __init_begin[],__init_end[] right next to .altinstr such that it gets freed by free_initmem() ?

Because it's not always freed? :)

Signature · 2 lines
Sincerely yours,
Mike.
#3 lore raw
In reply to Mike Rapoport
Quoted 29 lines · Mike Rapoport

From: "Mike Rapoport (Microsoft)" <[email protected]>

On SMP systems alternative_instructions() frees memory occupied by smp_locks section immediately after patching the lock instructions.

The memory is freed using free_init_pages() that calls free_reserved_area() that essentially does __free_page() for every page in the range.

Up until recently it didn't update memblock state so in cases when CONFIG_ARCH_KEEP_MEMBLOCK is enabled (on x86 it is selected by INTEL_TDX_HOST), the state of memblock and the memory map would be inconsistent.

Additionally, with CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled feeing of smp_locks happens before the memory map is fully initialized and freeing reserved memory may case an access to not-yet-initialized struct page when __free_page() searches for a buddy page.

Following the discussion in [1], implementation of memblock_free_late() and free_reserved_area() was unified to ensure that reserved memory that's freed after memblock transfers the pages to the buddy allocator is actually freed and that the memblock and the memory map are consistent. As a part of these changes, free_reserved_area() now WARN()s when it is called before the initialization of the memory map is complete.

The memory map is fully initialized in page_alloc_init_late() that completes before initcalls are executed, so it is safe to free reserved memory in any initcall except early_initcall().

Quoted 5 lines

Move freeing of smp_locks section to an initcall to ensure it will happen after the memory map is fully initialized. Since it does not matter which exactly initcall to use and the code lives in arch/, pick arch_initcall.

[1] https://lore.kernel.org/all/ec2aaef14783869b3be6e3c253b2dcbf67dbc12a.camel@kernel.crashing.org

Forgot to add:

Fixes b2129a39511b ("memblock: make free_reserved_area() update memblock if ARCH_KEEP_MEMBLOCK=y")
Quoted 9 lines
---
 arch/x86/kernel/alternative.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)
Signature · 2 lines
Sincerely yours,
Mike.
maintainer Acked-by on v2 1/1
#4 lore raw
In reply to Mike Rapoport
Quoted 8 lines · Mike Rapoport

From: "Mike Rapoport (Microsoft)" <[email protected]>

On SMP systems alternative_instructions() frees memory occupied by smp_locks section immediately after patching the lock instructions.

The memory is freed using free_init_pages() that calls free_reserved_area() that essentially does __free_page() for every page in the range.

Quoted 6 lines

Up until recently it didn't update memblock state so in cases when CONFIG_ARCH_KEEP_MEMBLOCK is enabled (on x86 it is selected by INTEL_TDX_HOST), the state of memblock and the memory map would be inconsistent.

Additionally, with CONFIG_DEFERRED_STRUCT_PAGE_INIT enabled feeing of

enabled, freeing of...

Quoted 2 lines

smp_locks happens before the memory map is fully initialized and freeing reserved memory may case an access to not-yet-initialized struct page when

may cause

Quoted 25 lines

__free_page() searches for a buddy page.

Following the discussion in [1], implementation of memblock_free_late() and free_reserved_area() was unified to ensure that reserved memory that's freed after memblock transfers the pages to the buddy allocator is actually freed and that the memblock and the memory map are consistent. As a part of these changes, free_reserved_area() now WARN()s when it is called before the initialization of the memory map is complete.

The memory map is fully initialized in page_alloc_init_late() that completes before initcalls are executed, so it is safe to free reserved memory in any initcall except early_initcall().

Move freeing of smp_locks section to an initcall to ensure it will happen after the memory map is fully initialized. Since it does not matter which exactly initcall to use and the code lives in arch/, pick arch_initcall.

[1] https://lore.kernel.org/all/ec2aaef14783869b3be6e3c253b2dcbf67dbc12a.camel@kernel.crashing.org

Quoted 3 lines
---
 arch/x86/kernel/alternative.c | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

Yah, thanks for explaining in the commit message in detail.

With the Fixes: you posted downthread:

to go through your tree as the issue is tickled by the changes there.

Thx.

Signature · 4 lines
Regards/Gruss,
    Boris.

https://people.kernel.org/tglx/notes-about-netiquette