support reserving crashkernel above 4G on arm64 kdump
Subsystems (8)
v2 cover support reserving crashkernel above 4G on arm64 kdump
When crashkernel is reserved above 4G in memory, kernel should reserve some amount of low memory for swiotlb and some DMA buffers. So there may be two crash kernel regions, one is below 4G, the other is above 4G.
Crash dump kernel reads more than one crash kernel regions via a dtb property under node /chosen,
linux,usable-memory-range = <BASE1 SIZE1 [BASE2 SIZE2]>.
Besides, we need to modify kexec-tools:
arm64: support more than one crash kernel regions(see [1])
Changes since [v1]:
- Move common reserve_crashkernel_low() code into kernel/kexec_core.c.
- Remove memblock_cap_memory_ranges() i added in v1 and implement that in fdt_enforce_memory_region().
There are at most two crash kernel regions, for two crash kernel regions case, we cap the memory range [min(regs[*].start), max(regs[*].end)] and then remove the memory range in the middle.
[1]: http://lists.infradead.org/pipermail/kexec/2019-April/022792.html
[v1]: https://lkml.org/lkml/2019/4/8/628
Chen Zhou (3):
arm64: kdump: support reserving crashkernel above 4G
arm64: kdump: support more than one crash kernel regions
kdump: update Documentation about crashkernel on arm64
Documentation/admin-guide/kernel-parameters.txt | 4 +- arch/arm64/include/asm/kexec.h | 3 + arch/arm64/kernel/setup.c | 3 + arch/arm64/mm/init.c | 92 +++++++++++++++++++++---- arch/x86/include/asm/kexec.h | 3 + arch/x86/kernel/setup.c | 66 ++---------------- include/linux/kexec.h | 1 + include/linux/memblock.h | 6 ++ kernel/kexec_core.c | 53 ++++++++++++++ mm/memblock.c | 7 +- 10 files changed, 159 insertions(+), 79 deletions(-)
Signature · 1 line
2.7.4
PATCH v2 1/3 arm64: kdump: support reserving crashkernel above 4G
When crashkernel is reserved above 4G in memory, kernel should reserve some amount of low memory for swiotlb and some DMA buffers.
Kernel would try to allocate at least 256M below 4G automatically as x86_64 if crashkernel is above 4G. Meanwhile, support crashkernel=X,[high,low] in arm64.
--- arch/arm64/include/asm/kexec.h | 3 ++ arch/arm64/kernel/setup.c | 3 ++ arch/arm64/mm/init.c | 26 +++++++++++++---- arch/x86/include/asm/kexec.h | 3 ++ arch/x86/kernel/setup.c | 66 +++++------------------------------------- include/linux/kexec.h | 1 + kernel/kexec_core.c | 53 +++++++++++++++++++++++++++++++++ 7 files changed, 91 insertions(+), 64 deletions(-)
arch/arm64/include/asm/kexec.h +3 -0
@@ -28,6 +28,9 @@#define KEXEC_ARCH KEXEC_ARCH_AARCH64 +/* 2M alignment for crash kernel regions */ +#define CRASH_ALIGN SZ_2M +#ifndef __ASSEMBLY__/**
arch/arm64/kernel/setup.c +3 -0
@@ -243,6 +243,9 @@ static void __init request_standard_resources(void)request_resource (res, &kernel_data);#ifdef CONFIG_KEXEC_CORE /* Userspace will find "Crash kernel" region in /proc/iomem. */ +if (crashk_low_res.end && crashk_low_res.start >= res->start && + crashk_low_res.end <= res->end) +request_resource (res, &crashk_low_res);if (crashk_res.end && crashk_res.start >= res->start && crashk_res.end <= res->end)request_resource (res, &crashk_res);
arch/arm64/mm/init.c +21 -5
@@ -64,6 +64,7 @@ EXPORT_SYMBOL(memstart_addr);phys_addr_t arm64_dma_phys_limit__ro_after_init ;#ifdef CONFIG_KEXEC_CORE +/* * reserve_crashkernel() - reserves memory for crash kernel *
@@ -74,20 +75,30 @@ phys_addr_t arm64_dma_phys_limit __ro_after_init;static void __init reserve_crashkernel (void ) {unsigned long long crash_base, crash_size; +bool high = false;int ret; ret =parse_crashkernel (boot_command_line,memblock_phys_mem_size (), &crash_size, &crash_base);/* no crashkernel= or invalid value specified */ -if (ret || !crash_size) -return ; +if (ret || !crash_size) { +/* crashkernel=X,high */ + ret =parse_crashkernel_high (boot_command_line, +memblock_phys_mem_size (), + &crash_size, &crash_base); +if (ret || !crash_size) +return ; + high = true; + } crash_size =PAGE_ALIGN (crash_size);if (crash_base ==0 ) {/* Current arm64 boot protocol requires 2MB alignment */ - crash_base =memblock_find_in_range (0 ,ARCH_LOW_ADDRESS_LIMIT , - crash_size,SZ_2M ); + crash_base =memblock_find_in_range (0 , + high ?memblock_end_of_DRAM () + :ARCH_LOW_ADDRESS_LIMIT , + crash_size,CRASH_ALIGN );if (crash_base ==0 ) {pr_warn ("cannot allocate crashkernel (size:0x%llx)\n" , crash_size);
@@ -105,13 +116,18 @@ static void __init reserve_crashkernel(void)return ; } -if (!IS_ALIGNED (crash_base,SZ_2M )) { +if (!IS_ALIGNED (crash_base,CRASH_ALIGN )) {pr_warn ("cannot reserve crashkernel: base address is not 2MB aligned\n" );return ; } }memblock_reserve (crash_base, crash_size); +if (crash_base >=SZ_4G &&reserve_crashkernel_low ()) { +memblock_free (crash_base, crash_size); +return ; + } +pr_info ("crashkernel reserved: 0x%016llx - 0x%016llx (%lld MB)\n" , crash_base, crash_base + crash_size, crash_size >>20 );
arch/x86/include/asm/kexec.h +3 -0
@@ -18,6 +18,9 @@# define KEXEC_CONTROL_CODE_MAX_SIZE 2048 +/* 16M alignment for crash kernel regions */ +#define CRASH_ALIGN (16 << 20) +#ifndef __ASSEMBLY__#include <linux/string.h>
arch/x86/kernel/setup.c +7 -59
84 lines not on this page · raw message
include/linux/kexec.h +1 -0
@@ -281,6 +281,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 ); +int __init reserve_crashkernel_low (void );void crash_save_cpu (struct pt_regs *regs,int cpu);extern int kimage_crash_copy_vmcoreinfo (struct kimage *image);
kernel/kexec_core.c +53 -0
65 lines not on this page · raw message
Signature · 1 line
2.7.4
PATCH v2 2/3 arm64: kdump: support more than one crash kernel regions
In reply to Chen ZhouAfter commit (arm64: kdump: support reserving crashkernel above 4G), there may be two crash kernel regions, one is below 4G, the other is above 4G.
Crash dump kernel reads more than one crash kernel regions via a dtb property under node /chosen,
linux,usable-memory-range = <BASE1 SIZE1 [BASE2 SIZE2]>
--- arch/arm64/mm/init.c | 66 ++++++++++++++++++++++++++++++++++++++++-------- include/linux/memblock.h | 6 +++++ mm/memblock.c | 7 ++--- 3 files changed, 66 insertions(+), 13 deletions(-)
arch/arm64/mm/init.c +56 -10
@@ -65,6 +65,11 @@ phys_addr_t arm64_dma_phys_limit __ro_after_init;#ifdef CONFIG_KEXEC_CORE +/* at most two crash kernel regions, low_region and high_region */ +#define CRASH_MAX_USABLE_RANGES 2 +#define LOW_REGION_IDX 0 +#define HIGH_REGION_IDX 1 +/* * reserve_crashkernel() - reserves memory for crash kernel *
@@ -297,8 +302,8 @@ static int __init early_init_dt_scan_usablemem(unsigned long node, const char *uname, int depth, void *data) { struct memblock_region *usablemem = data; -const __be32 *reg; -int len; +const __be32 *reg, *endp; +int len, nr =0 ;if (depth !=1 ||strcmp (uname,"chosen" ) !=0 )return 0 ;
@@ -307,22 +312,63 @@ static int __init early_init_dt_scan_usablemem(unsigned long node,if (!reg || (len < (dt_root_addr_cells + dt_root_size_cells)))return 1 ; - usablemem->base =dt_mem_next_cell (dt_root_addr_cells, ®); - usablemem->size =dt_mem_next_cell (dt_root_size_cells, ®); + endp = reg + (len /sizeof (__be32)); +while ((endp - reg) >= (dt_root_addr_cells + dt_root_size_cells)) { + usablemem[nr].base =dt_mem_next_cell (dt_root_addr_cells, ®); + usablemem[nr].size =dt_mem_next_cell (dt_root_size_cells, ®); + +if (++nr >=CRASH_MAX_USABLE_RANGES ) +break ; + }return 1 ; }static void __init fdt_enforce_memory_region (void ) { -struct memblock_region reg = { - .size =0 , - }; +int i, cnt =0 ; +struct memblock_region regs[CRASH_MAX_USABLE_RANGES ]; + +memset (regs,0 ,sizeof (regs)); +of_scan_flat_dt (early_init_dt_scan_usablemem, regs); + +for (i =0 ; i <CRASH_MAX_USABLE_RANGES ; i++) +if (regs[i].size) + cnt++; +else +break ; + +if (cnt -1 ==LOW_REGION_IDX ) +memblock_cap_memory_range (regs[LOW_REGION_IDX ].base, + regs[LOW_REGION_IDX ].size); +else if (cnt -1 ==HIGH_REGION_IDX ) { +/* +* Two crash kernel regions, cap the memory range +* [regs[LOW_REGION_IDX].base, regs[HIGH_REGION_IDX].end] +* and then remove the memory range in the middle. +*/ +int start_rgn, end_rgn, i, ret; +phys_addr_t mid_base, mid_size; + + mid_base = regs[LOW_REGION_IDX ].base + regs[LOW_REGION_IDX ].size; + mid_size = regs[HIGH_REGION_IDX ].base - mid_base; + ret =memblock_isolate_range (&memblock.memory, mid_base, + mid_size, &start_rgn, &end_rgn); -of_scan_flat_dt (early_init_dt_scan_usablemem, ®); +if (ret) +return ; -if (reg.size) -memblock_cap_memory_range (reg.base, reg.size); +memblock_cap_memory_range (regs[LOW_REGION_IDX ].base, + regs[HIGH_REGION_IDX ].base - + regs[LOW_REGION_IDX ].base + + regs[HIGH_REGION_IDX ].size); +for (i = end_rgn -1 ; i >= start_rgn; i--) { +if (!memblock_is_nomap (&memblock.memory.regions[i])) +memblock_remove_region (&memblock.memory, i); + } +memblock_remove_range (&memblock.reserved, mid_base, + mid_base + mid_size); + } }void __init arm64_memblock_init (void )
include/linux/memblock.h +6 -0
@@ -110,9 +110,15 @@ void memblock_discard(void);phys_addr_t memblock_find_in_range (phys_addr_t start,phys_addr_t end,phys_addr_t size,phys_addr_t align); +void memblock_remove_region (struct memblock_type *type,unsigned long r);void memblock_allow_resize (void );int memblock_add_node (phys_addr_t base,phys_addr_t size,int nid);int memblock_add (phys_addr_t base,phys_addr_t size); +int memblock_isolate_range (struct memblock_type *type, +phys_addr_t base,phys_addr_t size, +int *start_rgn,int *end_rgn); +int memblock_remove_range (struct memblock_type *type, +phys_addr_t base,phys_addr_t size);int memblock_remove (phys_addr_t base,phys_addr_t size);int memblock_free (phys_addr_t base,phys_addr_t size);int memblock_reserve (phys_addr_t base,phys_addr_t size);
mm/memblock.c +4 -3
@@ -357,7 +357,8 @@ phys_addr_t __init_memblock memblock_find_in_range(phys_addr_t start,return ret; } -static void __init_memblock memblock_remove_region(struct memblock_type *type, unsigned long r) +void __init_memblock memblock_remove_region(struct memblock_type *type, +unsigned long r) { type->total_size -= type->regions[r].size; memmove(&type->regions[r], &type->regions[r + 1],
@@ -724,7 +725,7 @@ int __init_memblock memblock_add(phys_addr_t base, phys_addr_t size)* Return: * 0 on success, -errno on failure. */ -static int __init_memblock memblock_isolate_range(struct memblock_type *type, +int __init_memblock memblock_isolate_range(struct memblock_type *type,phys_addr_t base,phys_addr_t size,int *start_rgn,int *end_rgn) {
@@ -784,7 +785,7 @@ static int __init_memblock memblock_isolate_range(struct memblock_type *type,return 0 ; } -static int __init_memblock memblock_remove_range(struct memblock_type *type, +int __init_memblock memblock_remove_range(struct memblock_type *type,phys_addr_t base,phys_addr_t size) {int start_rgn, end_rgn;
Signature · 1 line
2.7.4
PATCH v2 3/3 kdump: update Documentation about crashkernel on arm64
In reply to Chen ZhouNow we support crashkernel=X,[high,low] on arm64, update the Documentation.
--- Documentation/admin-guide/kernel-parameters.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +2 -2
@@ -715,14 +715,14 @@ Documentation/kdump/kdump.txt for an example. crashkernel=size[KMG],high - [KNL, x86_64] range could be above 4G. Allow kernel + [KNL, x86_64, arm64] range could be above 4G. Allow kernel to allocate physical memory region from top, so could be above 4G if system have more than 4G ram installed. Otherwise memory region will be allocated below 4G, if available. It will be ignored if crashkernel=X is specified. crashkernel=size[KMG],low - [KNL, x86_64] range under 4G. When crashkernel=X,high + [KNL, x86_64, arm64] range under 4G. When crashkernel=X,high is passed, kernel could allocate physical memory region above 4G, that cause second kernel crash on system that require some amount of low memory, e.g. swiotlb
Signature · 1 line
2.7.4