x86/kdump: Fix 'kmem -s' reported an invalid freepointer when SME was active
Subsystems (4)
v4 cover x86/kdump: Fix 'kmem -s' reported an invalid freepointer when SME was active
In purgatory(), the main things are as below:
[1] verify sha256 hashes for various segments. Lets keep these codes, and do not touch the logic.
[2] copy the first 640k content to a backup region.
Lets safely remove it and clean all code related to backup region.
This patch series will remove the backup region, because the current handling of copying the first 640k runs into problems when SME is active(https://bugzilla.kernel.org/show_bug.cgi?id=204793).
The low 1MiB region will always be reserved when the crashkernel kernel command line option is specified. And this way makes it unnecessary to do anything with the low 1MiB region, because the memory allocated later won't fall into the low 1MiB area.
This series includes three patches:
[1] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
The low 1MiB region will always be reserved when the crashkernel kernel command line option is specified, which ensures that the memory allocated later won't fall into the low 1MiB area.
[2] x86/kdump: remove the unused crash_copy_backup_region() The crash_copy_backup_region() has never been used, so clean up the redundant code.
[3] x86/kdump: clean up all the code related to the backup region Remove the backup region and clean up.
Changes since v1:
[1] Add extra checking condition: when the crashkernel option is specified, reserve the low 640k area.
Changes since v2:
[1] Reserve the low 1MiB region when the crashkernel option is only specified.(Suggested by Eric)
[2] Remove the unused crash_copy_backup_region()
[3] Remove the backup region and clean up
[4] Split them into three patches
Changes since v3:
[1] Improve the first patch's log
[2] Improve the third patch based on Eric's suggestions
Lianbo Jiang (3):
x86/kdump: always reserve the low 1MiB when the crashkernel option is
specified
x86/kdump: remove the unused crash_copy_backup_region() x86/kdump: clean up all the code related to the backup region
arch/x86/include/asm/crash.h | 1 - arch/x86/include/asm/kexec.h | 10 ---- arch/x86/include/asm/purgatory.h | 10 ---- arch/x86/kernel/crash.c | 87 ++++-------------------------- arch/x86/kernel/machine_kexec_64.c | 47 ---------------- arch/x86/purgatory/purgatory.c | 19 ------- arch/x86/realmode/init.c | 11 ++++ 7 files changed, 22 insertions(+), 163 deletions(-)
Signature · 1 line
2.17.1
PATCH v4 1/3 x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Kdump kernel will reuse the first 640k region because of some reasons, for example: the trampline and conventional PC system BIOS region may require to allocate memory in this area. Obviously, kdump kernel will also overwrite the first 640k region, therefore, kernel has to copy the contents of the first 640k area to a backup area, which is done in purgatory(), because vmcore may need the old memory. When vmcore is dumped, kdump kernel will read the old memory from the backup area of the first 640k area.
Basically, the main reason should be clear, kernel does not correctly handle the first 640k region when SME is active, which causes that kernel does not properly copy these old memory to the backup area in purgatory(). Therefore, kdump kernel reads out the incorrect contents from the backup area when dumping vmcore. Finally, the phenomenon is as follow:
[root linux]$ crash vmlinux /var/crash/127.0.0.1-2019-09-19-08\:31\:27/vmcore
WARNING: kernel relocated [240MB]: patching 97110 gdb minimal_symbol values
KERNEL: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmlinux
DUMPFILE: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmcore [PARTIAL DUMP]
CPUS: 128
DATE: Thu Sep 19 08:31:18 2019
UPTIME: 00:01:21
LOAD AVERAGE: 0.16, 0.07, 0.02
TASKS: 1343
NODENAME: amd-ethanol
RELEASE: 5.3.0-rc7+
VERSION: #4 SMP Thu Sep 19 08:14:00 EDT 2019
MACHINE: x86_64 (2195 Mhz)
MEMORY: 127.9 GB
PANIC: "Kernel panic - not syncing: sysrq triggered crash"
PID: 9789
COMMAND: "bash"
TASK: "ffff89711894ae80 [THREAD_INFO: ffff89711894ae80]"
CPU: 83
STATE: TASK_RUNNING (PANIC)crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4 crash>
BTW: I also tried to fix the above problem in purgatory(), but there are too many restricts in purgatory() context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.
Currently, there are two places where the first 640k area is needed, the first one is in the find_trampoline_placement(), another one is in the reserve_real_mode(), and their content doesn't matter.
To avoid the above error, when the crashkernel kernel command line option is specified, lets reserve the remaining low 1MiB memory( after reserving real mode memroy) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in purgatory(). This indicates that it does not need to be included in crash dumps or used for anything execept the processor trampolines that must live in the low 1MiB.
In addition, also need to clean all the code related to the backup region later.
--- arch/x86/realmode/init.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
arch/x86/realmode/init.c +11 -0
@@ -34,6 +34,17 @@ void __init reserve_real_mode(void)memblock_reserve (mem, size);set_real_mode_mem (mem); + +#ifdef CONFIG_KEXEC_CORE +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +if (strstr (boot_command_line,"crashkernel=" )) { +memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n" ); + } +#endif /* CONFIG_KEXEC_CORE */ }static void __init setup_real_mode (void )
Signature · 1 line
2.17.1
Borislav Petkov
maintainerRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 1 line · Lianbo Jiang
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Put that as a Link: below.
Quoted 1 line
Kdump kernel will reuse the first 640k region because of some reasons,
s/ of some reasons//
Quoted 1 line
for example: the trampline and conventional PC system BIOS region may
spellcheck: s/trampline/trampoline/
I see two more typos in here and if you had a spellchecker enabled in your editor where you write the commit message, you'll see them too. Please use one.
Quoted 2 lines
require to allocate memory in this area. Obviously, kdump kernel will also overwrite the first 640k region,
Well, it is not obvious to me. Please be more specific: why would the kdump kernel do that?
Quoted 8 lines
therefore, kernel has to copy
the contents of the first 640k area to a backup area, which is done inpurgatory(), because vmcore may need the old memory. When vmcore is dumped, kdump kernel will read the old memory from the backup area of the first 640k area.Basically, the main reason should be clear, kernel does not correctly handle the first 640k region when SME is active,
If you mention the actual reason here, that sentence would be clearer:
"When SME is enabled in the first kernel, the kdump kernel must access the first kernel's memory with the encryption bit set."
Something like that.
Quoted 3 lines
which causes that
kernel does not properly copy these old memory to the backup area inpurgatory(). Therefore, kdump kernel reads out the incorrect contents
s/incorrect/encrypted/
Quoted 1 line
from the backup area when dumping vmcore. Finally, the phenomenon is
phenomenon?
Quoted 24 lines
as follow:
[root linux]$ crash vmlinux /var/crash/127.0.0.1-2019-09-19-08\:31\:27/vmcore
WARNING: kernel relocated [240MB]: patching 97110 gdbminimal_symbolvaluesKERNEL: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmlinux DUMPFILE: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmcore [PARTIAL DUMP] CPUS: 128 DATE: Thu Sep 19 08:31:18 2019 UPTIME: 00:01:21 LOAD AVERAGE: 0.16, 0.07, 0.02 TASKS: 1343 NODENAME: amd-ethanol RELEASE: 5.3.0-rc7+ VERSION: #4 SMP Thu Sep 19 08:14:00 EDT 2019 MACHINE: x86_64 (2195 Mhz) MEMORY: 127.9 GB PANIC: "Kernel panic - not syncing: sysrq triggered crash" PID: 9789 COMMAND: "bash" TASK: "ffff89711894ae80 [THREAD_INFO: ffff89711894ae80]" CPU: 83 STATE: TASK_RUNNING (PANIC)
Quoted 4 lines
crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4 crash>
I fail to see what that's trying to tell me? You have invalid pointers?
Quoted 4 lines
BTW: I also tried to fix the above problem in
purgatory(), but there are too many restricts inpurgatory()context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.
This paragraph belongs under the "---" line below.
Quoted 12 lines
Currently, there are two places where the first 640k area is needed, the first one is in the
find_trampoline_placement(), another one is in thereserve_real_mode(), and their content doesn't matter.To avoid the above error, when the crashkernel kernel command line option is specified, lets reserve the remaining low 1MiB memory( after reserving real mode memroy) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in
purgatory(). This indicates that it does not need to be included in crash dumps or used for anything execept the processor trampolines that must live in the low 1MiB.
Quoted 2 lines
In addition, also need to clean all the code related to the backup region later.
Ditto.
Quoted 14 lines
Signed-off-by Lianbo Jiang <[email protected]>--- arch/x86/realmode/init.c | 11 +++++++++++ 1 file changed, 11 insertions(+)arch/x86/realmode/init.c +1
-0@@ -34,6 +34,17 @@ void __init reserve_real_mode(void)memblock_reserve (mem, size);set_real_mode_mem (mem); +
arch/x86/realmode/init.c void __init reserve_real_mode(void) · line 47
Quoted 10 lines
arch/x86/realmode/init.c +10
-0+#ifdef CONFIG_KEXEC_CORE +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +if (strstr (boot_command_line,"crashkernel=" )) { +memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n" ); + } +#endif /* CONFIG_KEXEC_CORE */
This ifdeffery needs to be a function in kernel/kexec_core.c which is called by reserve_real_mode(), instead.
Thx.
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 3 lines · Borislav Petkov
Quoted 1 line · Lianbo Jiang
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Thanks for your comment.
Quoted 2 lines
Put that as a Link: below.
Looks better. OK.
Quoted 4 lines
Quoted 1 line
Kdump kernel will reuse the first 640k region because of some reasons,
s/ of some reasons//
Quoted 8 lines
Quoted 1 line
for example: the trampline and conventional PC system BIOS region may
spellcheck: s/trampline/trampoline/
I see two more typos in here and if you had a spellchecker enabled in your editor where you write the commit message, you'll see them too. Please use one.
Good point. I just tried to enable the spellchecker in the vim and now it has worked well. Thanks. :-)
Quoted 6 lines
Quoted 2 lines
require to allocate memory in this area. Obviously, kdump kernel will also overwrite the first 640k region,
Well, it is not obvious to me. Please be more specific: why would the kdump kernel do that?
Kdump kernel will reuse the first 640k region because the real mode trampoline has to work in this area. When the vmcore is dumped, the old memory in this area may be accessed, therefore, kernel has to copy the contents of the first 640k area to a backup region so that kdump kernel can read the old memory from the backup area of the first 640k area, which is done in the purgatory().
Quoted 9 lines
Quoted 8 lines
therefore, kernel has to copy
the contents of the first 640k area to a backup area, which is done inpurgatory(), because vmcore may need the old memory. When vmcore is dumped, kdump kernel will read the old memory from the backup area of the first 640k area.Basically, the main reason should be clear, kernel does not correctly handle the first 640k region when SME is active,
Quoted 7 lines
If you mention the actual reason here, that sentence would be clearer:
"When SME is enabled in the first kernel, the kdump kernel must access the first kernel's memory with the encryption bit set."
Something like that.
Looks good.
Quoted 6 lines
Quoted 3 lines
which causes that
kernel does not properly copy these old memory to the backup area inpurgatory(). Therefore, kdump kernel reads out the incorrect contentss/incorrect/encrypted/
Exactly.
Quoted 4 lines
Quoted 1 line
from the backup area when dumping vmcore. Finally, the phenomenon is
phenomenon?
Finally, it caused the following errors.
Quoted 24 lines
Quoted 24 lines
as follow:
[root linux]$ crash vmlinux /var/crash/127.0.0.1-2019-09-19-08\:31\:27/vmcore
WARNING: kernel relocated [240MB]: patching 97110 gdbminimal_symbolvaluesKERNEL: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmlinux DUMPFILE: /var/crash/127.0.0.1-2019-09-19-08:31:27/vmcore [PARTIAL DUMP] CPUS: 128 DATE: Thu Sep 19 08:31:18 2019 UPTIME: 00:01:21 LOAD AVERAGE: 0.16, 0.07, 0.02 TASKS: 1343 NODENAME: amd-ethanol RELEASE: 5.3.0-rc7+ VERSION: #4 SMP Thu Sep 19 08:14:00 EDT 2019 MACHINE: x86_64 (2195 Mhz) MEMORY: 127.9 GB PANIC: "Kernel panic - not syncing: sysrq triggered crash" PID: 9789 COMMAND: "bash" TASK: "ffff89711894ae80 [THREAD_INFO: ffff89711894ae80]" CPU: 83 STATE: TASK_RUNNING (PANIC)
Quoted 7 lines
Quoted 4 lines
crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4 crash>I fail to see what that's trying to tell me? You have invalid pointers?
Yes, when parsing the vmcore via crash tool, it occurs the above errors, the crash tool gets invalid pointers.
Quoted 7 lines
Quoted 4 lines
BTW: I also tried to fix the above problem in
purgatory(), but there are too many restricts inpurgatory()context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.This paragraph belongs under the "---" line below.
OK. Thanks.
Quoted 28 lines
Quoted 12 lines
Currently, there are two places where the first 640k area is needed, the first one is in the
find_trampoline_placement(), another one is in thereserve_real_mode(), and their content doesn't matter.To avoid the above error, when the crashkernel kernel command line option is specified, lets reserve the remaining low 1MiB memory( after reserving real mode memroy) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in
purgatory(). This indicates that it does not need to be included in crash dumps or used for anything execept the processor trampolines that must live in the low 1MiB.Quoted 2 lines
In addition, also need to clean all the code related to the backup region later.
Ditto.
Quoted 11 lines
Signed-off-by Lianbo Jiang <[email protected]>--- arch/x86/realmode/init.c | 11 +++++++++++ 1 file changed, 11 insertions(+)arch/x86/realmode/init.c +0
-0@@ -34,6 +34,17 @@ void __init reserve_real_mode(void)
Quoted 17 lines
arch/x86/realmode/init.c void __init reserve_real_mode(void) · line 47
Quoted 13 lines
arch/x86/realmode/init.c +11
-0memblock_reserve (mem, size);set_real_mode_mem (mem); + +#ifdef CONFIG_KEXEC_CORE +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +if (strstr (boot_command_line,"crashkernel=" )) { +memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n" ); + } +#endif /* CONFIG_KEXEC_CORE */ This ifdeffery needs to be a function in
kernel/kexec_core.cwhich is called byreserve_real_mode(), instead.
Good understanding. I will try to improve it later.
Thanks.
Lianbo
Quoted 2 lines
Thx.
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 6 lines · lijiang
Kdump kernel will reuse the first 640k region because the real mode trampoline has to work in this area. When the vmcore is dumped, the old memory in this area may be accessed, therefore, kernel has to copy the contents of the first 640k area to a backup region so that kdump kernel can read the old memory from the backup area of the first 640k area, which is done in the
purgatory().
That sounds better. :)
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquetteRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
In reply to Borislav PetkovQuoted 2 lines · Borislav Petkov
This ifdeffery needs to be a function in
kernel/kexec_core.cwhich is called byreserve_real_mode(), instead.
Would you mind if i improve this patch as follow? Thanks.
From 5804abec62279585f374d78ace1250505c44c6b7 Mon Sep 17 00:00:00 2001
From: Lianbo Jiang <[email protected]>
Date: Wed, 23 Oct 2019 11:27:04 +0800
Subject: [PATCH] x86/kdump: always reserve the low 1MiB when the crashkernel
option is specified
Kdump kernel will reuse the first 640k region because the real mode trampoline has to work in this area. When the vmcore is dumped, the old memory in this area may be accessed, therefore, kernel has to copy the contents of the first 640k area to a backup region so that kdump kernel can read the old memory from the backup area of the first 640k area, which is done in the purgatory().
But, the current handling of copying the first 640k area runs into problems when SME is enabled, kernel does not properly copy these old memory to the backup area in the purgatory(), thereby, kdump kernel reads out the encrypted contents, because the kdump kernel must access the first kernel's memory with the encryption bit set when SME is enabled in the first kernel. Please refer to this link:
Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Finally, it causes the following errors, and the crash tool gets invalid pointers when parsing the vmcore.
crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4 crash>
To avoid the above errors, when the crashkernel option is specified, lets reserve the remaining low 1MiB memory(after reserving real mode memory) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in purgatory(). This indicates that it does not need to be included in crash dumps or used for anything except the processor trampolines that must live in the low 1MiB.
---
BTW:I also tried to fix the above problem in purgatory(), but there are too many restricts in purgatory() context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.
Currently, there are two places where the first 640k area is needed, the first one is in the find_trampoline_placement(), another one is in the reserve_real_mode(), and their content doesn't matter.
In addition, also need to clean all the code related to the backup region later.
arch/x86/realmode/init.c | 2 ++ include/linux/kexec.h | 2 ++ kernel/kexec_core.c | 13 +++++++++++++ 3 files changed, 17 insertions(+)
arch/x86/realmode/init.c +2 -0
@@ -3,6 +3,7 @@#include <linux/slab.h> #include <linux/memblock.h> #include <linux/mem_encrypt.h> +#include <linux/kexec.h> #include <asm/set_memory.h> #include <asm/pgtable.h>
@@ -34,6 +35,7 @@ void __init reserve_real_mode(void)memblock_reserve (mem, size);set_real_mode_mem (mem); +kexec_reserve_low_1MiB (); }static void __init setup_real_mode (void )
include/linux/kexec.h +2 -0
@@ -306,6 +306,7 @@ extern void __crash_kexec(struct pt_regs *);extern void crash_kexec (struct pt_regs *);int kexec_should_crash (struct task_struct *);int kexec_crash_loaded (void ); +void kexec_reserve_low_1MiB (void );void crash_save_cpu (struct pt_regs *regs,int cpu);extern int kimage_crash_copy_vmcoreinfo (struct kimage *image);
@@ -397,6 +398,7 @@ static inline void __crash_kexec(struct pt_regs *regs) { }static inline void crash_kexec (struct pt_regs *regs) { }static inline int kexec_should_crash (struct task_struct *p) {return 0 ; }static inline int kexec_crash_loaded (void ) {return 0 ; } +static inline void kexec_reserve_low_1MiB (void ) { }#define kexec_in_progress false#endif /* CONFIG_KEXEC_CORE */
kernel/kexec_core.c +13 -0
@@ -37,6 +37,7 @@#include <linux/compiler.h> #include <linux/hugetlb.h> #include <linux/frame.h> +#include <linux/memblock.h> #include <asm/page.h> #include <asm/sections.h>
@@ -70,6 +71,18 @@ struct resource crashk_low_res = { .desc = IORES_DESC_CRASH_KERNEL }; +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +void kexec_reserve_low_1MiB (void ) +{ +if (strstr (boot_command_line,"crashkernel=" )) { +memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n" ); + } +} +int kexec_should_crash (struct task_struct *p) {/*
Signature · 1 line
2.17.1
Borislav Petkov
maintainerRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 1 line · lijiang
Would you mind if i improve this patch as follow? Thanks.
Yap, looks good to me.
Thx.
Signature · 9 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexecRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 5 lines · Borislav Petkov
Quoted 1 line · lijiang
Would you mind if i improve this patch as follow? Thanks.
Yap, looks good to me.
Thanks for your comment.
OK. I will post this one and the third patch in this series later.
Thanks.
Lianbo
Quoted 2 lines
Thx.
RE: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
In reply to lijiangI don't find the corresponding patch in the v5 patchset, so I comment here.
Quoted 130 lines
-----Original Message-----
From: [email protected] [mailto:[email protected]] On Behalf Of lijiang
Sent: Wednesday, October 23, 2019 2:35 PM
To: Borislav Petkov <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specifiedQuoted 2 lines · Borislav Petkov
This ifdeffery needs to be a function in
kernel/kexec_core.cwhich is called byreserve_real_mode(), instead.Would you mind if i improve this patch as follow? Thanks.
From
5804abec62279585f374d78ace1250505c44c6b7Mon Sep 17 00:00:00 2001
From: Lianbo Jiang <[email protected]>
Date: Wed, 23 Oct 2019 11:27:04 +0800
Subject: [PATCH] x86/kdump: always reserve the low 1MiB when the crashkernel
option is specifiedKdump kernel will reuse the first 640k region because the real mode trampoline has to work in this area. When the vmcore is dumped, the old memory in this area may be accessed, therefore, kernel has to copy the contents of the first 640k area to a backup region so that kdump kernel can read the old memory from the backup area of the first 640k area, which is done in the
purgatory().But, the current handling of copying the first 640k area runs into problems when SME is enabled, kernel does not properly copy these old memory to the backup area in the
purgatory(), thereby, kdump kernel reads out the encrypted contents, because the kdump kernel must access the first kernel's memory with the encryption bit set when SME is enabled in the first kernel. Please refer to this link:Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Finally, it causes the following errors, and the crash tool gets invalid pointers when parsing the vmcore.
crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
crash>To avoid the above errors, when the crashkernel option is specified, lets reserve the remaining low 1MiB memory(after reserving real mode memory) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in
purgatory(). This indicates that it does not need to be included in crash dumps or used for anything except the processor trampolines that must live in the low 1MiB.Signed-off-by Lianbo Jiang <[email protected]>---
BTW:I also tried to fix the above problem inpurgatory(), but there are too many restricts inpurgatory()context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.Currently, there are two places where the first 640k area is needed, the first one is in the
find_trampoline_placement(), another one is in thereserve_real_mode(), and their content doesn't matter.In addition, also need to clean all the code related to the backup region later.
arch/x86/realmode/init.c | 2 ++ include/linux/kexec.h | 2 ++ kernel/kexec_core.c | 13 +++++++++++++ 3 files changed, 17 insertions(+)arch/x86/realmode/init.c +2
-0@@ -3,6 +3,7 @@#include <linux/slab.h> #include <linux/memblock.h> #include <linux/mem_encrypt.h> +#include <linux/kexec.h> #include <asm/set_memory.h> #include <asm/pgtable.h> @@ -34,6 +35,7 @@ void __init reserve_real_mode(void)memblock_reserve (mem, size);set_real_mode_mem (mem); +kexec_reserve_low_1MiB (); }static void __init setup_real_mode (void )include/linux/kexec.h +2
-0@@ -306,6 +306,7 @@ extern void __crash_kexec(struct pt_regs *);extern void crash_kexec (struct pt_regs *);int kexec_should_crash (struct task_struct *);int kexec_crash_loaded (void ); +void kexec_reserve_low_1MiB (void );void crash_save_cpu (struct pt_regs *regs,int cpu);extern int kimage_crash_copy_vmcoreinfo (struct kimage *image);@@ -397,6 +398,7 @@ static inline void __crash_kexec(struct pt_regs *regs) { }static inline void crash_kexec (struct pt_regs *regs) { }static inline int kexec_should_crash (struct task_struct *p) {return 0 ; }static inline int kexec_crash_loaded (void ) {return 0 ; } +static inline void kexec_reserve_low_1MiB (void ) { }#define kexec_in_progress false#endif /* CONFIG_KEXEC_CORE */ kernel/kexec_core.c +1
-0@@ -37,6 +37,7 @@#include <linux/compiler.h> #include <linux/hugetlb.h> #include <linux/frame.h> +#include <linux/memblock.h> #include <asm/page.h> #include <asm/sections.h>
kernel/kexec_core.c struct resource crashk_low_res = { · line 80
Quoted 10 lines
kernel/kexec_core.c +7
-0@@ -70,6 +71,18 @@ struct resource crashk_low_res = { .desc = IORES_DESC_CRASH_KERNEL }; +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +void kexec_reserve_low_1MiB (void ) +{ +if (strstr (boot_command_line,"crashkernel=" )) {
strstr() matches for example, ANYEXTRACHARACTERScrashkernel=ANYEXTRACHARACTERS.
Is it enough to use cmdline_find_option_bool()?
Quoted 11 lines
kernel/kexec_core.c +5
-0+memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n"); + } +} +int kexec_should_crash (struct task_struct *p) {/*
--
2.17.1
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
Quoted 1 line · On Thu, Oct 24, 2019 at 08:13:25AM +0000, [email protected] wrote:
I don't find the corresponding patch in the v5 patchset, so I comment here.
You don't?
https://lore.kernel.org/lkml/[email protected]/
Signature · 9 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette
_______________________________________________
kexec mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/kexecRe: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specified
In reply to [email protected]Quoted 2 lines · 在 2019年10月24日 16:13, [email protected] 写道:
I don't find the corresponding patch in the v5 patchset, so I comment here.
Thanks for your comment.
Quoted 143 lines
Quoted 130 lines
-----Original Message-----
From: [email protected] [mailto:[email protected]] On Behalf Of lijiang
Sent: Wednesday, October 23, 2019 2:35 PM
To: Borislav Petkov <[email protected]>
Cc: [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]; [email protected]
Subject: Re: [PATCH 1/3 v4] x86/kdump: always reserve the low 1MiB when the crashkernel option is specifiedQuoted 2 lines · Borislav Petkov
This ifdeffery needs to be a function in
kernel/kexec_core.cwhich is called byreserve_real_mode(), instead.Would you mind if i improve this patch as follow? Thanks.
From
5804abec62279585f374d78ace1250505c44c6b7Mon Sep 17 00:00:00 2001
From: Lianbo Jiang <[email protected]>
Date: Wed, 23 Oct 2019 11:27:04 +0800
Subject: [PATCH] x86/kdump: always reserve the low 1MiB when the crashkernel
option is specifiedKdump kernel will reuse the first 640k region because the real mode trampoline has to work in this area. When the vmcore is dumped, the old memory in this area may be accessed, therefore, kernel has to copy the contents of the first 640k area to a backup region so that kdump kernel can read the old memory from the backup area of the first 640k area, which is done in the
purgatory().But, the current handling of copying the first 640k area runs into problems when SME is enabled, kernel does not properly copy these old memory to the backup area in the
purgatory(), thereby, kdump kernel reads out the encrypted contents, because the kdump kernel must access the first kernel's memory with the encryption bit set when SME is enabled in the first kernel. Please refer to this link:Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=204793
Finally, it causes the following errors, and the crash tool gets invalid pointers when parsing the vmcore.
crash> kmem -s|grep -i invalid
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
kmem: dma-kmalloc-512: slab:ffffd77680001c00 invalid freepointer:a6086ac099f0c5a4
crash>To avoid the above errors, when the crashkernel option is specified, lets reserve the remaining low 1MiB memory(after reserving real mode memory) so that the allocated memory does not fall into the low 1MiB area, which makes us not to copy the first 640k content to a backup region in
purgatory(). This indicates that it does not need to be included in crash dumps or used for anything except the processor trampolines that must live in the low 1MiB.Signed-off-by Lianbo Jiang <[email protected]>---
BTW:I also tried to fix the above problem inpurgatory(), but there are too many restricts inpurgatory()context, for example: i can't allocate new memory to create the identity mapping page table for SME situation.Currently, there are two places where the first 640k area is needed, the first one is in the
find_trampoline_placement(), another one is in thereserve_real_mode(), and their content doesn't matter.In addition, also need to clean all the code related to the backup region later.
arch/x86/realmode/init.c | 2 ++ include/linux/kexec.h | 2 ++ kernel/kexec_core.c | 13 +++++++++++++ 3 files changed, 17 insertions(+)arch/x86/realmode/init.c +2
-0@@ -3,6 +3,7 @@#include <linux/slab.h> #include <linux/memblock.h> #include <linux/mem_encrypt.h> +#include <linux/kexec.h> #include <asm/set_memory.h> #include <asm/pgtable.h> @@ -34,6 +35,7 @@ void __init reserve_real_mode(void)memblock_reserve (mem, size);set_real_mode_mem (mem); +kexec_reserve_low_1MiB (); }static void __init setup_real_mode (void )include/linux/kexec.h +2
-0@@ -306,6 +306,7 @@ extern void __crash_kexec(struct pt_regs *);extern void crash_kexec (struct pt_regs *);int kexec_should_crash (struct task_struct *);int kexec_crash_loaded (void ); +void kexec_reserve_low_1MiB (void );void crash_save_cpu (struct pt_regs *regs,int cpu);extern int kimage_crash_copy_vmcoreinfo (struct kimage *image);@@ -397,6 +398,7 @@ static inline void __crash_kexec(struct pt_regs *regs) { }static inline void crash_kexec (struct pt_regs *regs) { }static inline int kexec_should_crash (struct task_struct *p) {return 0 ; }static inline int kexec_crash_loaded (void ) {return 0 ; } +static inline void kexec_reserve_low_1MiB (void ) { }#define kexec_in_progress false#endif /* CONFIG_KEXEC_CORE */ kernel/kexec_core.c +1
-0@@ -37,6 +37,7 @@#include <linux/compiler.h> #include <linux/hugetlb.h> #include <linux/frame.h> +#include <linux/memblock.h> #include <asm/page.h> #include <asm/sections.h> kernel/kexec_core.c struct resource crashk_low_res = { · line 80
Quoted 10 lines
kernel/kexec_core.c +7
-0@@ -70,6 +71,18 @@ struct resource crashk_low_res = { .desc = IORES_DESC_CRASH_KERNEL }; +/* +* When the crashkernel option is specified, only use the low +* 1MiB for the real mode trampoline. +*/ +void kexec_reserve_low_1MiB (void ) +{ +if (strstr (boot_command_line,"crashkernel=" )) {
strstr()matches for example, ANYEXTRACHARACTERScrashkernel=ANYEXTRACHARACTERS.
Quoted 2 lines
Is it enough to use
cmdline_find_option_bool()?
The cmdline_find_option_bool() will find a boolean option, but the crashkernel option is not a boolean option, maybe it looks odd. So, should we use the cmdline_find_option() better?
+#include <asm/cmdline.h>
void __init kexec_reserve_low_1MiB(void)
{
- if (strstr(boot_command_line, "crashkernel=")) {
+ char buffer[4];
+
+ if (cmdline_find_option(boot_command_line, "crashkernel=",
+ buffer, sizeof(buffer))) {
memblock_reserve(0, 1<<20);
pr_info("Reserving the low 1MiB of memory for crashkernel\n");
}And here, no need to parse the arguments of crashkernel(sometimes, which has a complicated syntax), so the size of buffer should be enough. What's your opinion?
Thanks
Lianbo
Quoted 12 lines
Quoted 11 lines
kernel/kexec_core.c +5
-0+memblock_reserve (0 ,1 <<20 ); +pr_info ("Reserving the low 1MiB of memory for crashkernel\n"); + } +} +int kexec_should_crash (struct task_struct *p) {/*
--
2.17.1
kbuild test robot
build botRe: [PATCH] x86/kdump: always reserve the low 1MiB when the crashkernel
In reply to lijiangThank you for the patch! Perhaps something to improve:
Hi lijiang,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on linus/master]
[cannot apply to v5.4-rc4 next-20191024]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]
url: https://github.com/0day-ci/linux/commits/lijiang/x86-kdump-always-reserve-the-low-1MiB-when-the-crashkernel/20191025-030439 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git f116b96685a046a89c25d4a6ba2da489145c8888 config: i386-defconfig (attached as .config) compiler: gcc-7 (Debian 7.4.0-14) 7.4.0 reproduce: # save the attached .config to linux build tree make ARCH=i386
If you fix the issue, kindly add following tag
All warnings (new ones prefixed by >>):
>> WARNING: vmlinux.o(.text+0xe39b7): Section mismatch in reference from the function kexec_reserve_low_1MiB() to the variable .init.data:boot_command_line
The function kexec_reserve_low_1MiB() references
the variable __initdata boot_command_line.
This is often because kexec_reserve_low_1MiB lacks a __initdata annotation or the annotation of boot_command_line is wrong.
--
>> WARNING: vmlinux.o(.text+0xe39d0): Section mismatch in reference from the function kexec_reserve_low_1MiB() to the function .meminit.text:memblock_reserve()
The function kexec_reserve_low_1MiB() references
the function __meminit memblock_reserve().
This is often because kexec_reserve_low_1MiB lacks a __meminit annotation or the annotation of memblock_reserve is wrong.
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
Re: [PATCH] x86/kdump: always reserve the low 1MiB when the crashkernel
Quoted 29 lines · kbuild test robot
Hi lijiang,
Thank you for the patch! Perhaps something to improve:
[auto build test WARNING on linus/master]
[cannot apply to v5.4-rc4 next-20191024]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982]url: https://github.com/0day-ci/linux/commits/lijiang/x86-kdump-always-reserve-the-low-1MiB-when-the-crashkernel/20191025-030439 base: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git f116b96685a046a89c25d4a6ba2da489145c8888 config: i386-defconfig (attached as .config) compiler: gcc-7 (Debian 7.4.0-14) 7.4.0 reproduce: # save the attached .config to linux build tree make ARCH=i386If you fix the issue, kindly add following tag
Reported-by kbuild test robot <[email protected]>All warnings (new ones prefixed by >>):
Quoted 1 line
Quoted 1 line
WARNING:
vmlinux.o(.text+0xe39b7): Section mismatch in reference from the functionkexec_reserve_low_1MiB()to the variable .init.data:boot_command_lineThe function
kexec_reserve_low_1MiB()references
the variable__initdataboot_command_line.
This is often becausekexec_reserve_low_1MiBlacks a__initdataannotation or the annotation ofboot_command_lineis wrong.
--
Quoted 6 lines
Quoted 1 line
Quoted 1 line
WARNING:
vmlinux.o(.text+0xe39d0): Section mismatch in reference from the functionkexec_reserve_low_1MiB()to the function .meminit.text:memblock_reserve()The function
kexec_reserve_low_1MiB()references
the function__meminitmemblock_reserve().
This is often becausekexec_reserve_low_1MiBlacks a__meminitannotation or the annotation ofmemblock_reserveis wrong.
These warnings have been fixed in patch v5. Please refer to the latest patch v5.
Thanks.
Lianbo
Quoted 4 lines
---
0-DAY kernel test infrastructure Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all Intel Corporation
PATCH v4 2/3 x86/kdump: remove the unused crash_copy_backup_region()
In reply to Lianbo JiangThe crash_copy_backup_region() has never been used, so clean up the redundant code.
--- arch/x86/include/asm/crash.h | 1 - 1 file changed, 1 deletion(-)
arch/x86/include/asm/crash.h +0 -1
@@ -3,7 +3,6 @@#define _ASM_X86_CRASH_Hint crash_load_segments (struct kimage *image); -int crash_copy_backup_region (struct kimage *image);int crash_setup_memmap_entries (struct kimage *image,struct boot_params *params);void crash_smp_send_stop (void );
Signature · 7 lines
2.17.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
PATCH v4 3/3 x86/kdump: clean up all the code related to the backup region
In reply to Lianbo JiangWhen the crashkernel kernel command line option is specified, the low 1MiB memory will always be reserved, which makes that the memory allocated later won't fall into the low 1MiB area, thereby, it's not necessary to create a backup region and also no need to copy the first 640k content to a backup region.
Currently, the code related to the backup region can be safely removed, so lets clean up.
--- arch/x86/include/asm/kexec.h | 10 ---- arch/x86/include/asm/purgatory.h | 10 ---- arch/x86/kernel/crash.c | 87 ++++-------------------------- arch/x86/kernel/machine_kexec_64.c | 47 ---------------- arch/x86/purgatory/purgatory.c | 19 ------- 5 files changed, 11 insertions(+), 162 deletions(-)
arch/x86/include/asm/kexec.h +0 -10
@@ -66,10 +66,6 @@ struct kimage;# define KEXEC_ARCH KEXEC_ARCH_X86_64#endif -/* Memory to backup during crash kdump */ -#define KEXEC_BACKUP_SRC_START (0UL) -#define KEXEC_BACKUP_SRC_END (640 * 1024UL - 1)/* 640K */ -/* * This function is responsible for capturing register states if coming * via panic otherwise just fix up the ss and sp if coming via kernel
@@ -154,12 +150,6 @@ struct kimage_arch {pud_t *pud;pmd_t *pmd;pte_t *pte; -/* Details of backup region */ -unsigned long backup_src_start; -unsigned long backup_src_sz; - -/* Physical address of backup segment */ -unsigned long backup_load_addr;/* Core ELF header buffer */ void *elf_headers;
arch/x86/include/asm/purgatory.h +0 -10
@@ -6,16 +6,6 @@#include <linux/purgatory.h> extern void purgatory (void ); -/* -* These forward declarations serve two purposes: -* -* 1) Make sparse happy when checking arch/purgatory -* 2) Document that these are required to be global so the symbol -* lookup in kexec works -*/ -extern unsigned long purgatory_backup_dest; -extern unsigned long purgatory_backup_src; -extern unsigned long purgatory_backup_sz;#endif /* __ASSEMBLY__ */ #endif /* _ASM_PURGATORY_H */
arch/x86/kernel/crash.c +11 -76
141 lines not on this page · raw message
arch/x86/kernel/machine_kexec_64.c +0 -47
59 lines not on this page · raw message
arch/x86/purgatory/purgatory.c +0 -19
@@ -14,28 +14,10 @@#include "../boot/string.h" -unsigned long purgatory_backup_dest __section(.kexec-purgatory); -unsigned long purgatory_backup_src __section(.kexec-purgatory); -unsigned long purgatory_backup_sz __section(.kexec-purgatory); - u8 purgatory_sha256_digest[SHA256_DIGEST_SIZE] __section(.kexec-purgatory); struct kexec_sha_region purgatory_sha_regions[KEXEC_SEGMENT_MAX] __section(.kexec-purgatory); -/* -* On x86, second kernel requries first 640K of memory to boot. Copy -* first 640K to a backup region in reserved memory range so that second -* kernel can use first 640K. -*/ -static int copy_backup_region (void ) -{ -if (purgatory_backup_dest) { -memcpy ((void *)purgatory_backup_dest, - (void *)purgatory_backup_src, purgatory_backup_sz); - } -return 0 ; -} -static int verify_sha256_digest (void ) {struct kexec_sha_region *ptr, *end;
@@ -66,7 +48,6 @@ void purgatory(void)for (;;) ; } -copy_backup_region (); }/*
Signature · 7 lines
2.17.1 _______________________________________________ kexec mailing list [email protected] http://lists.infradead.org/mailman/listinfo/kexec
Borislav Petkov
maintainerRe: [PATCH 3/3 v4] x86/kdump: clean up all the code related to the backup region
Quoted 9 lines · Lianbo Jiang
When the crashkernel kernel command line option is specified, the low 1MiB memory will always be reserved, which makes that the memory allocated later won't fall into the low 1MiB area, thereby, it's not necessary to create a backup region and also no need to copy the first 640k content to a backup region.
Currently, the code related to the backup region can be safely removed, so lets clean up.
Quoted 8 lines
Signed-off-by Lianbo Jiang <[email protected]>--- arch/x86/include/asm/kexec.h | 10 ---- arch/x86/include/asm/purgatory.h | 10 ---- arch/x86/kernel/crash.c | 87 ++++-------------------------- arch/x86/kernel/machine_kexec_64.c | 47 ---------------- arch/x86/purgatory/purgatory.c | 19 ------- 5 files changed, 11 insertions(+), 162 deletions(-)
That's a diffstat one cannot object to nowadays. :)
Signature · 4 lines
Regards/Gruss,
Boris.
https://people.kernel.org/tglx/notes-about-netiquette