* [RESEND PATCH v5 1/4] x86: kdump: move reserve_crashkernel_low() into kexec_core.c
2019-04-16 11:35 [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Chen Zhou
@ 2019-04-16 11:35 ` Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 2/4] arm64: kdump: support reserving crashkernel above 4G Chen Zhou
` (3 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Chen Zhou @ 2019-04-16 11:35 UTC (permalink / raw)
To: tglx, mingo, bp, ebiederm, rppt, catalin.marinas, will.deacon,
akpm, ard.biesheuvel
Cc: horms, takahiro.akashi, linux-arm-kernel, linux-kernel, kexec,
linux-mm, wangkefeng.wang, Chen Zhou
In preparation for supporting more than one crash kernel regions
in arm64 as x86_64 does, move reserve_crashkernel_low() into
kexec/kexec_core.c.
Signed-off-by: Chen Zhou <chenzhou10@huawei.com>
---
arch/x86/include/asm/kexec.h | 3 ++
arch/x86/kernel/setup.c | 66 +++++---------------------------------------
include/linux/kexec.h | 5 ++++
kernel/kexec_core.c | 56 +++++++++++++++++++++++++++++++++++++
4 files changed, 71 insertions(+), 59 deletions(-)
diff --git a/arch/x86/include/asm/kexec.h b/arch/x86/include/asm/kexec.h
index 003f2da..485a514 100644
--- a/arch/x86/include/asm/kexec.h
+++ b/arch/x86/include/asm/kexec.h
@@ -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>
diff --git a/arch/x86/kernel/setup.c b/arch/x86/kernel/setup.c
index 3773905..4182035 100644
--- a/arch/x86/kernel/setup.c
+++ b/arch/x86/kernel/setup.c
@@ -447,9 +447,6 @@ static void __init memblock_x86_reserve_range_setup_data(void)
#ifdef CONFIG_KEXEC_CORE
-/* 16M alignment for crash kernel regions */
-#define CRASH_ALIGN (16 << 20)
-
/*
* Keep the crash kernel below this limit. On 32 bits earlier kernels
* would limit the kernel to the low 512 MiB due to mapping restrictions.
@@ -463,59 +460,6 @@ static void __init memblock_x86_reserve_range_setup_data(void)
# define CRASH_ADDR_HIGH_MAX MAXMEM
#endif
-static int __init reserve_crashkernel_low(void)
-{
-#ifdef CONFIG_X86_64
- unsigned long long base, low_base = 0, low_size = 0;
- unsigned long total_low_mem;
- int ret;
-
- total_low_mem = memblock_mem_size(1UL << (32 - PAGE_SHIFT));
-
- /* crashkernel=Y,low */
- ret = parse_crashkernel_low(boot_command_line, total_low_mem, &low_size, &base);
- if (ret) {
- /*
- * two parts from lib/swiotlb.c:
- * -swiotlb size: user-specified with swiotlb= or default.
- *
- * -swiotlb overflow buffer: now hardcoded to 32k. We round it
- * to 8M for other buffers that may need to stay low too. Also
- * make sure we allocate enough extra low memory so that we
- * don't run out of DMA buffers for 32-bit devices.
- */
- low_size = max(swiotlb_size_or_default() + (8UL << 20), 256UL << 20);
- } else {
- /* passed with crashkernel=0,low ? */
- if (!low_size)
- return 0;
- }
-
- low_base = memblock_find_in_range(0, 1ULL << 32, low_size, CRASH_ALIGN);
- if (!low_base) {
- pr_err("Cannot reserve %ldMB crashkernel low memory, please try smaller size.\n",
- (unsigned long)(low_size >> 20));
- return -ENOMEM;
- }
-
- ret = memblock_reserve(low_base, low_size);
- if (ret) {
- pr_err("%s: Error reserving crashkernel low memblock.\n", __func__);
- return ret;
- }
-
- pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (System low RAM: %ldMB)\n",
- (unsigned long)(low_size >> 20),
- (unsigned long)(low_base >> 20),
- (unsigned long)(total_low_mem >> 20));
-
- crashk_low_res.start = low_base;
- crashk_low_res.end = low_base + low_size - 1;
- insert_resource(&iomem_resource, &crashk_low_res);
-#endif
- return 0;
-}
-
static void __init reserve_crashkernel(void)
{
unsigned long long crash_size, crash_base, total_mem;
@@ -573,9 +517,13 @@ static void __init reserve_crashkernel(void)
return;
}
- if (crash_base >= (1ULL << 32) && reserve_crashkernel_low()) {
- memblock_free(crash_base, crash_size);
- return;
+ if (crash_base >= (1ULL << 32)) {
+ if (reserve_crashkernel_low()) {
+ memblock_free(crash_base, crash_size);
+ return;
+ }
+
+ insert_resource(&iomem_resource, &crashk_low_res);
}
pr_info("Reserving %ldMB of memory at %ldMB for crashkernel (System RAM: %ldMB)\n",
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index b9b1bc5..096ad63 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -63,6 +63,10 @@
#define KEXEC_CORE_NOTE_NAME CRASH_CORE_NOTE_NAME
+#ifndef CRASH_ALIGN
+#define CRASH_ALIGN SZ_128M
+#endif
+
/*
* This structure is used to hold the arguments that are used when loading
* kernel binaries.
@@ -281,6 +285,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);
diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c
index d714044..3492abd 100644
--- a/kernel/kexec_core.c
+++ b/kernel/kexec_core.c
@@ -39,6 +39,8 @@
#include <linux/compiler.h>
#include <linux/hugetlb.h>
#include <linux/frame.h>
+#include <linux/memblock.h>
+#include <linux/swiotlb.h>
#include <asm/page.h>
#include <asm/sections.h>
@@ -96,6 +98,60 @@ int kexec_crash_loaded(void)
}
EXPORT_SYMBOL_GPL(kexec_crash_loaded);
+int __init reserve_crashkernel_low(void)
+{
+ unsigned long long base, low_base = 0, low_size = 0;
+ unsigned long total_low_mem;
+ int ret;
+
+ total_low_mem = memblock_mem_size(1UL << (32 - PAGE_SHIFT));
+
+ /* crashkernel=Y,low */
+ ret = parse_crashkernel_low(boot_command_line, total_low_mem,
+ &low_size, &base);
+ if (ret) {
+ /*
+ * two parts from lib/swiotlb.c:
+ * -swiotlb size: user-specified with swiotlb= or default.
+ *
+ * -swiotlb overflow buffer: now hardcoded to 32k. We round it
+ * to 8M for other buffers that may need to stay low too. Also
+ * make sure we allocate enough extra low memory so that we
+ * don't run out of DMA buffers for 32-bit devices.
+ */
+ low_size = max(swiotlb_size_or_default() + (8UL << 20),
+ 256UL << 20);
+ } else {
+ /* passed with crashkernel=0,low ? */
+ if (!low_size)
+ return 0;
+ }
+
+ low_base = memblock_find_in_range(0, 1ULL << 32, low_size, CRASH_ALIGN);
+ if (!low_base) {
+ pr_err("Cannot reserve %ldMB crashkernel low memory, please try smaller size.\n",
+ (unsigned long)(low_size >> 20));
+ return -ENOMEM;
+ }
+
+ ret = memblock_reserve(low_base, low_size);
+ if (ret) {
+ pr_err("%s: Error reserving crashkernel low memblock.\n",
+ __func__);
+ return ret;
+ }
+
+ pr_info("Reserving %ldMB of low memory at %ldMB for crashkernel (System low RAM: %ldMB)\n",
+ (unsigned long)(low_size >> 20),
+ (unsigned long)(low_base >> 20),
+ (unsigned long)(total_low_mem >> 20));
+
+ crashk_low_res.start = low_base;
+ crashk_low_res.end = low_base + low_size - 1;
+
+ return 0;
+}
+
/*
* When kexec transitions to the new kernel there is a one-to-one
* mapping between physical and virtual addresses. On processors
--
2.7.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* [RESEND PATCH v5 2/4] arm64: kdump: support reserving crashkernel above 4G
2019-04-16 11:35 [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 1/4] x86: kdump: move reserve_crashkernel_low() into kexec_core.c Chen Zhou
@ 2019-04-16 11:35 ` Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 3/4] memblock: extend memblock_cap_memory_range to multiple ranges Chen Zhou
` (2 subsequent siblings)
4 siblings, 0 replies; 6+ messages in thread
From: Chen Zhou @ 2019-04-16 11:35 UTC (permalink / raw)
To: tglx, mingo, bp, ebiederm, rppt, catalin.marinas, will.deacon,
akpm, ard.biesheuvel
Cc: horms, takahiro.akashi, linux-arm-kernel, linux-kernel, kexec,
linux-mm, wangkefeng.wang, Chen Zhou
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.
Signed-off-by: Chen Zhou <chenzhou10@huawei.com>
---
arch/arm64/include/asm/kexec.h | 3 +++
arch/arm64/kernel/setup.c | 3 +++
arch/arm64/mm/init.c | 25 ++++++++++++++++++++-----
3 files changed, 26 insertions(+), 5 deletions(-)
diff --git a/arch/arm64/include/asm/kexec.h b/arch/arm64/include/asm/kexec.h
index 67e4cb7..32949bf 100644
--- a/arch/arm64/include/asm/kexec.h
+++ b/arch/arm64/include/asm/kexec.h
@@ -28,6 +28,9 @@
#define KEXEC_ARCH KEXEC_ARCH_AARCH64
+/* 2M alignment for crash kernel regions */
+#define CRASH_ALIGN SZ_2M
+
#ifndef __ASSEMBLY__
/**
diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c
index 413d566..82cd9a0 100644
--- a/arch/arm64/kernel/setup.c
+++ b/arch/arm64/kernel/setup.c
@@ -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);
diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c
index 972bf43..f5dde73 100644
--- a/arch/arm64/mm/init.c
+++ b/arch/arm64/mm/init.c
@@ -74,20 +74,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 +115,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);
--
2.7.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* [RESEND PATCH v5 3/4] memblock: extend memblock_cap_memory_range to multiple ranges
2019-04-16 11:35 [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 1/4] x86: kdump: move reserve_crashkernel_low() into kexec_core.c Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 2/4] arm64: kdump: support reserving crashkernel above 4G Chen Zhou
@ 2019-04-16 11:35 ` Chen Zhou
2019-04-16 11:35 ` [RESEND PATCH v5 4/4] kdump: update Documentation about crashkernel on arm64 Chen Zhou
2019-04-16 13:15 ` [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Borislav Petkov
4 siblings, 0 replies; 6+ messages in thread
From: Chen Zhou @ 2019-04-16 11:35 UTC (permalink / raw)
To: tglx, mingo, bp, ebiederm, rppt, catalin.marinas, will.deacon,
akpm, ard.biesheuvel
Cc: horms, takahiro.akashi, linux-arm-kernel, linux-kernel, kexec,
linux-mm, wangkefeng.wang, Mike Rapoport, Chen Zhou
From: Mike Rapoport <rppt@linux.ibm.com>
The memblock_cap_memory_range() removes all the memory except the
range passed to it. Extend this function to receive an array of
memblock_regions that should be kept. This allows switching to
simple iteration over memblock arrays with 'for_each_mem_range_rev'
to remove the unneeded memory.
Enable use of this function in arm64 for reservation of multiple
regions for the crash kernel.
Signed-off-by: Mike Rapoport <rppt@linux.vnet.ibm.com>
Signed-off-by: Chen Zhou <chenzhou10@huawei.com>
---
arch/arm64/mm/init.c | 34 ++++++++++++++++++++++++----------
include/linux/memblock.h | 2 +-
mm/memblock.c | 44 ++++++++++++++++++++------------------------
3 files changed, 45 insertions(+), 35 deletions(-)
diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c
index f5dde73..7f999bf 100644
--- a/arch/arm64/mm/init.c
+++ b/arch/arm64/mm/init.c
@@ -64,6 +64,10 @@ EXPORT_SYMBOL(memstart_addr);
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
+
/*
* reserve_crashkernel() - reserves memory for crash kernel
*
@@ -295,9 +299,9 @@ early_param("mem", early_mem);
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;
+ struct memblock_type *usablemem = data;
+ const __be32 *reg, *endp;
+ int len, nr = 0;
if (depth != 1 || strcmp(uname, "chosen") != 0)
return 0;
@@ -306,22 +310,32 @@ 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)) {
+ unsigned long base = dt_mem_next_cell(dt_root_addr_cells, ®);
+ unsigned long size = dt_mem_next_cell(dt_root_size_cells, ®);
+ if (memblock_add_range(usablemem, base, size, NUMA_NO_NODE,
+ MEMBLOCK_NONE))
+ return 0;
+ if (++nr >= CRASH_MAX_USABLE_RANGES)
+ break;
+ }
return 1;
}
static void __init fdt_enforce_memory_region(void)
{
- struct memblock_region reg = {
- .size = 0,
+ struct memblock_region usable_regions[CRASH_MAX_USABLE_RANGES];
+ struct memblock_type usablemem = {
+ .max = CRASH_MAX_USABLE_RANGES,
+ .regions = usable_regions,
};
- of_scan_flat_dt(early_init_dt_scan_usablemem, ®);
+ of_scan_flat_dt(early_init_dt_scan_usablemem, &usablemem);
- if (reg.size)
- memblock_cap_memory_range(reg.base, reg.size);
+ if (usablemem.cnt)
+ memblock_cap_memory_ranges(usablemem.regions, usablemem.cnt);
}
void __init arm64_memblock_init(void)
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 47e3c06..e490a73 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -445,7 +445,7 @@ phys_addr_t memblock_mem_size(unsigned long limit_pfn);
phys_addr_t memblock_start_of_DRAM(void);
phys_addr_t memblock_end_of_DRAM(void);
void memblock_enforce_memory_limit(phys_addr_t memory_limit);
-void memblock_cap_memory_range(phys_addr_t base, phys_addr_t size);
+void memblock_cap_memory_ranges(struct memblock_region *regions, int count);
void memblock_mem_limit_remove_map(phys_addr_t limit);
bool memblock_is_memory(phys_addr_t addr);
bool memblock_is_map_memory(phys_addr_t addr);
diff --git a/mm/memblock.c b/mm/memblock.c
index f315eca..08581b1 100644
--- a/mm/memblock.c
+++ b/mm/memblock.c
@@ -1669,36 +1669,31 @@ void __init memblock_enforce_memory_limit(phys_addr_t limit)
PHYS_ADDR_MAX);
}
-void __init memblock_cap_memory_range(phys_addr_t base, phys_addr_t size)
-{
- int start_rgn, end_rgn;
- int i, ret;
-
- if (!size)
- return;
-
- ret = memblock_isolate_range(&memblock.memory, base, size,
- &start_rgn, &end_rgn);
- if (ret)
- return;
-
- /* remove all the MAP regions */
- for (i = memblock.memory.cnt - 1; i >= end_rgn; i--)
- if (!memblock_is_nomap(&memblock.memory.regions[i]))
- memblock_remove_region(&memblock.memory, i);
+void __init memblock_cap_memory_ranges(struct memblock_region *regions,
+ int count)
+{
+ struct memblock_type regions_to_keep = {
+ .max = count,
+ .cnt = count,
+ .regions = regions,
+ };
+ phys_addr_t start, end;
+ u64 i;
- for (i = start_rgn - 1; i >= 0; i--)
- if (!memblock_is_nomap(&memblock.memory.regions[i]))
- memblock_remove_region(&memblock.memory, i);
+ /* truncate memory while skipping NOMAP regions */
+ for_each_mem_range_rev(i, &memblock.memory, ®ions_to_keep,
+ NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end, NULL)
+ memblock_remove(start, end - start);
/* truncate the reserved regions */
- memblock_remove_range(&memblock.reserved, 0, base);
- memblock_remove_range(&memblock.reserved,
- base + size, PHYS_ADDR_MAX);
+ for_each_mem_range_rev(i, &memblock.reserved, ®ions_to_keep,
+ NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end, NULL)
+ memblock_remove_range(&memblock.reserved, start, end - start);
}
void __init memblock_mem_limit_remove_map(phys_addr_t limit)
{
+ struct memblock_region region = { 0 };
phys_addr_t max_addr;
if (!limit)
@@ -1710,7 +1705,8 @@ void __init memblock_mem_limit_remove_map(phys_addr_t limit)
if (max_addr == PHYS_ADDR_MAX)
return;
- memblock_cap_memory_range(0, max_addr);
+ region.size = max_addr;
+ memblock_cap_memory_ranges(®ion, 1);
}
static int __init_memblock memblock_search(struct memblock_type *type, phys_addr_t addr)
--
2.7.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* [RESEND PATCH v5 4/4] kdump: update Documentation about crashkernel on arm64
2019-04-16 11:35 [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Chen Zhou
` (2 preceding siblings ...)
2019-04-16 11:35 ` [RESEND PATCH v5 3/4] memblock: extend memblock_cap_memory_range to multiple ranges Chen Zhou
@ 2019-04-16 11:35 ` Chen Zhou
2019-04-16 13:15 ` [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Borislav Petkov
4 siblings, 0 replies; 6+ messages in thread
From: Chen Zhou @ 2019-04-16 11:35 UTC (permalink / raw)
To: tglx, mingo, bp, ebiederm, rppt, catalin.marinas, will.deacon,
akpm, ard.biesheuvel
Cc: horms, takahiro.akashi, linux-arm-kernel, linux-kernel, kexec,
linux-mm, wangkefeng.wang, Chen Zhou
Now we support crashkernel=X,[high,low] on arm64, update the
Documentation.
Signed-off-by: Chen Zhou <chenzhou10@huawei.com>
---
Documentation/admin-guide/kernel-parameters.txt | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
index 308af3b..a055983 100644
--- a/Documentation/admin-guide/kernel-parameters.txt
+++ b/Documentation/admin-guide/kernel-parameters.txt
@@ -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
--
2.7.4
^ permalink raw reply related [flat|nested] 6+ messages in thread* Re: [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump
2019-04-16 11:35 [RESEND PATCH v5 0/4] support reserving crashkernel above 4G on arm64 kdump Chen Zhou
` (3 preceding siblings ...)
2019-04-16 11:35 ` [RESEND PATCH v5 4/4] kdump: update Documentation about crashkernel on arm64 Chen Zhou
@ 2019-04-16 13:15 ` Borislav Petkov
4 siblings, 0 replies; 6+ messages in thread
From: Borislav Petkov @ 2019-04-16 13:15 UTC (permalink / raw)
To: Chen Zhou
Cc: tglx, mingo, ebiederm, rppt, catalin.marinas, will.deacon, akpm,
ard.biesheuvel, horms, takahiro.akashi, linux-arm-kernel,
linux-kernel, kexec, linux-mm, wangkefeng.wang
On Tue, Apr 16, 2019 at 07:35:15PM +0800, Chen Zhou wrote:
> 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]>.
Can you please not flood everyone with this patchset every day, and
today twice?
This is not the frequency with how you send patchsets upstream. See
https://www.kernel.org/doc/html/latest/process/submitting-patches.html#don-t-get-discouraged-or-impatient
--
Regards/Gruss,
Boris.
Good mailing practices for 400: avoid top-posting and trim the reply.
^ permalink raw reply [flat|nested] 6+ messages in thread