| Message ID | 20160712050514.22307-2-takahiro.akashi@linaro.org |
|---|---|
| State | Superseded |
| Headers | show |
Hi, On Wed, Jul 13, 2016 at 10:12:12AM +0100, Suzuki K Poulose wrote: > On 12/07/16 06:05, AKASHI Takahiro wrote: > >On the startup of primary kernel, the memory region used by crash dump > >kernel must be specified by "crashkernel=" kernel parameter. > >reserve_crashkernel() will allocate and reserve the region for later use. > > > >User space tools, like kexec-tools, will be able to find that region as > > - "Crash kernel" in /proc/iomem, or > > - "linux,crashkernel-base" and "linux,crashkernel-size" under > > /sys/firmware/devicetree/base/chosen > > > >Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org> > >Signed-off-by: Mark Salter <msalter@redhat.com> > >Signed-off-by: Pratyush Anand <panand@redhat.com> > >Reviewed-by: James Morse <james.morse@arm.com> > > Minor nits below. > > >--- > > arch/arm64/kernel/setup.c | 7 ++- > > arch/arm64/mm/init.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++ > > 2 files changed, 121 insertions(+), 1 deletion(-) > > > >diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c > >index c1509e6..cb5eee0 100644 > >--- a/arch/arm64/kernel/setup.c > >+++ b/arch/arm64/kernel/setup.c > >@@ -31,7 +31,6 @@ > > #include <linux/screen_info.h> > > #include <linux/init.h> > > #include <linux/kexec.h> > >-#include <linux/crash_dump.h> > > #include <linux/root_dev.h> > > #include <linux/cpu.h> > > #include <linux/interrupt.h> > >@@ -222,6 +221,12 @@ static void __init request_standard_resources(void) > > kernel_data.end <= res->end) > > request_resource(res, &kernel_data); > > } > >+ > >+#ifdef CONFIG_KEXEC_CORE > >+ /* User space tools will find "Crash kernel" region in /proc/iomem. */ > >+ if (crashk_res.end) > >+ insert_resource(&iomem_resource, &crashk_res); > >+#endif > > nit: Could we not do this from reserve_crashkernel() ? Reserve_crashkernel() should be called before arm64_memblock_init(). If the code above is put in reserve_crashkernel(), the inserted resource will be gone later by calling request_resource() in request_standard_resource() because the crashkernel memory is part of System RAM. > > > > #include <asm/boot.h> > > #include <asm/fixmap.h> > >@@ -76,6 +78,117 @@ static int __init early_initrd(char *p) > > early_param("initrd", early_initrd); > > #endif > > > >+#ifdef CONFIG_KEXEC_CORE > >+static unsigned long long crash_size, crash_base; > >+static struct property crash_base_prop = { > >+ .name = "linux,crashkernel-base", > >+ .length = sizeof(u64), > >+ .value = &crash_base > >+}; > >+static struct property crash_size_prop = { > >+ .name = "linux,crashkernel-size", > >+ .length = sizeof(u64), > >+ .value = &crash_size, > >+}; > >+ > > >+ > >+/* > >+ * reserve_crashkernel() - reserves memory for crash kernel > >+ * > >+ * This function reserves memory area given in "crashkernel=" kernel command > >+ * line parameter. The memory reserved is used by dump capture kernel when > >+ * primary kernel is crashing. > >+ */ > >+static void __init reserve_crashkernel(void) > >+{ > >+ 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 (crash_base == 0) { > > ... > > >+ memblock_reserve(crash_base, crash_size); > >+ > >+ } else { > > ... > > >+ > >+ memblock_reserve(crash_base, crash_size); > > >+ } > > Nit: you could move the memblock_reserve() here to a single place. Sure. Thanks, -Takahiro AKASHI > >+ > >+ pr_info("Reserving %lldMB of memory at %lldMB for crashkernel\n", > >+ crash_size >> 20, crash_base >> 20); > >+ > >+ crashk_res.start = crash_base; > >+ crashk_res.end = crash_base + crash_size - 1; > > As mentioned above, may be we could move the insert_resource() here, which > would keep the generic setup.c code cleaner and is a bit more reader friendly. > > >+} > >+#else > > Suzuki > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
On Tue, Jul 19, 2016 at 05:39:07PM +0800, Dennis Chen wrote: > Hello AKASHI, > > On Tue, Jul 12, 2016 at 02:05:07PM +0900, AKASHI Takahiro wrote: > > On the startup of primary kernel, the memory region used by crash dump > > kernel must be specified by "crashkernel=" kernel parameter. > > reserve_crashkernel() will allocate and reserve the region for later use. > > > > User space tools, like kexec-tools, will be able to find that region as > > - "Crash kernel" in /proc/iomem, or > > - "linux,crashkernel-base" and "linux,crashkernel-size" under > > /sys/firmware/devicetree/base/chosen > > > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org> > > Signed-off-by: Mark Salter <msalter@redhat.com> > > Signed-off-by: Pratyush Anand <panand@redhat.com> > > Reviewed-by: James Morse <james.morse@arm.com> > > --- > > arch/arm64/kernel/setup.c | 7 ++- > > arch/arm64/mm/init.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++ > > 2 files changed, 121 insertions(+), 1 deletion(-) > > > > diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c > > index c1509e6..cb5eee0 100644 > > --- a/arch/arm64/kernel/setup.c > > +++ b/arch/arm64/kernel/setup.c > > @@ -31,7 +31,6 @@ > > #include <linux/screen_info.h> > > #include <linux/init.h> > > #include <linux/kexec.h> > > -#include <linux/crash_dump.h> > > #include <linux/root_dev.h> > > #include <linux/cpu.h> > > #include <linux/interrupt.h> > > @@ -222,6 +221,12 @@ static void __init request_standard_resources(void) > > kernel_data.end <= res->end) > > request_resource(res, &kernel_data); > > } > > + > > +#ifdef CONFIG_KEXEC_CORE > > + /* User space tools will find "Crash kernel" region in /proc/iomem. */ > > + if (crashk_res.end) > > + insert_resource(&iomem_resource, &crashk_res); > > +#endif > > } > > > > u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID }; > > diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c > > index 2ade7a6..51b1302 100644 > > --- a/arch/arm64/mm/init.c > > +++ b/arch/arm64/mm/init.c > > @@ -29,11 +29,13 @@ > > #include <linux/gfp.h> > > #include <linux/memblock.h> > > #include <linux/sort.h> > > +#include <linux/of.h> > > #include <linux/of_fdt.h> > > #include <linux/dma-mapping.h> > > #include <linux/dma-contiguous.h> > > #include <linux/efi.h> > > #include <linux/swiotlb.h> > > +#include <linux/kexec.h> > > > > #include <asm/boot.h> > > #include <asm/fixmap.h> > > @@ -76,6 +78,117 @@ static int __init early_initrd(char *p) > > early_param("initrd", early_initrd); > > #endif > > > > +#ifdef CONFIG_KEXEC_CORE > > +static unsigned long long crash_size, crash_base; > > +static struct property crash_base_prop = { > > + .name = "linux,crashkernel-base", > > + .length = sizeof(u64), > > + .value = &crash_base > > +}; > > +static struct property crash_size_prop = { > > + .name = "linux,crashkernel-size", > > + .length = sizeof(u64), > > + .value = &crash_size, > > +}; > > + > > +static int __init export_crashkernel(void) > > +{ > > + struct device_node *node; > > + int ret; > > + > > + if (!crashk_res.end) > > + return 0; > > + > > + crash_base = cpu_to_be64(crashk_res.start); > > + crash_size = cpu_to_be64(crashk_res.end - crashk_res.start + 1); > > + > > + /* Add /chosen/linux,crashkernel-* properties */ > > + node = of_find_node_by_path("/chosen"); > > + if (!node) > > + return -ENOENT; > > + > > + /* > > + * There might be existing crash kernel properties, but we can't > > + * be sure what's in them, so remove them. > > + */ > > + of_remove_property(node, of_find_property(node, > > + "linux,crashkernel-base", NULL)); > > + of_remove_property(node, of_find_property(node, > > + "linux,crashkernel-size", NULL)); > > + > > + ret = of_add_property(node, &crash_base_prop); > > + if (ret) > > + goto ret_err; > > + > > + ret = of_add_property(node, &crash_size_prop); > > + if (ret) > > + goto ret_err; > > + > > + return 0; > > + > > +ret_err: > > + pr_warn("Exporting crashkernel region to device tree failed\n"); > > + return ret; > > +} > > +late_initcall(export_crashkernel); > > + > > +/* > > + * reserve_crashkernel() - reserves memory for crash kernel > > + * > > + * This function reserves memory area given in "crashkernel=" kernel command > > + * line parameter. The memory reserved is used by dump capture kernel when > > + * primary kernel is crashing. > > + */ > > +static void __init reserve_crashkernel(void) > > +{ > > + 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 (crash_base == 0) { > > + /* Current arm64 boot protocol requires 2MB alignment */ > > + crash_base = memblock_find_in_range(0, > > + MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); > > + if (crash_base == 0) { > > + pr_warn("Unable to allocate crashkernel (size:%llx)\n", > > + crash_size); > > + return; > > + } > > + memblock_reserve(crash_base, crash_size); > > > I am not pretty sure the context here, but > can we use below code piece instead of the above lines? > if (crash_base == 0) > memblock_alloc(crash_size, SZ_2M); Either would be fine here. Thanks, -Takahiro AKASHI > Thanks, > Dennis > > > + > > + } else { > > + /* User specifies base address explicitly. */ > > + if (!memblock_is_region_memory(crash_base, crash_size) || > > + memblock_is_region_reserved(crash_base, crash_size)) { > > + pr_warn("crashkernel has wrong address or size\n"); > > + return; > > + } > > + > > + if (!IS_ALIGNED(crash_base, SZ_2M)) { > > + pr_warn("crashkernel base address is not 2MB aligned\n"); > > + return; > > + } > > + > > + memblock_reserve(crash_base, crash_size); > > + } > > + > > + pr_info("Reserving %lldMB of memory at %lldMB for crashkernel\n", > > + crash_size >> 20, crash_base >> 20); > > + > > + crashk_res.start = crash_base; > > + crashk_res.end = crash_base + crash_size - 1; > > +} > > +#else > > +static void __init reserve_crashkernel(void) > > +{ > > + ; > > +} > > +#endif /* CONFIG_KEXEC_CORE */ > > + > > /* > > * Return the maximum physical address for ZONE_DMA (DMA_BIT_MASK(32)). It > > * currently assumes that for memory starting above 4G, 32-bit devices will > > @@ -289,6 +402,8 @@ void __init arm64_memblock_init(void) > > } > > #endif > > > > + reserve_crashkernel(); > > + > > early_init_fdt_scan_reserved_mem(); > > > > /* 4GB maximum for 32-bit only capable devices */ > > -- > > 2.9.0 > > > > > > _______________________________________________ > > linux-arm-kernel mailing list > > linux-arm-kernel@lists.infradead.org > > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > > > IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you. > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
On Tue, 2016-07-19 at 18:41 +0800, Dennis Chen wrote: > On Tue, Jul 19, 2016 at 07:28:16PM +0900, AKASHI Takahiro wrote: > > > > On Tue, Jul 19, 2016 at 05:39:07PM +0800, Dennis Chen wrote: > > > > > > Hello AKASHI, > > > > > > On Tue, Jul 12, 2016 at 02:05:07PM +0900, AKASHI Takahiro wrote: > > > > > > > > On the startup of primary kernel, the memory region used by crash dump > > > > kernel must be specified by "crashkernel=" kernel parameter. > > > > reserve_crashkernel() will allocate and reserve the region for later use. > > > > > > > > User space tools, like kexec-tools, will be able to find that region as > > > > - "Crash kernel" in /proc/iomem, or > > > > - "linux,crashkernel-base" and "linux,crashkernel-size" under > > > > /sys/firmware/devicetree/base/chosen > > > > > > > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org> > > > > Signed-off-by: Mark Salter <msalter@redhat.com> > > > > Signed-off-by: Pratyush Anand <panand@redhat.com> > > > > Reviewed-by: James Morse <james.morse@arm.com> > > > > --- > > > > arch/arm64/kernel/setup.c | 7 ++- > > > > arch/arm64/mm/init.c | 115 ++++++++++++++++++++++++++++++++++++++++++++++ > > > > 2 files changed, 121 insertions(+), 1 deletion(-) > > > > > > > > diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c > > > > index c1509e6..cb5eee0 100644 > > > > --- a/arch/arm64/kernel/setup.c > > > > +++ b/arch/arm64/kernel/setup.c > > > > @@ -31,7 +31,6 @@ > > > > #include <linux/screen_info.h> > > > > #include <linux/init.h> > > > > #include <linux/kexec.h> > > > > -#include <linux/crash_dump.h> > > > > #include <linux/root_dev.h> > > > > #include <linux/cpu.h> > > > > #include <linux/interrupt.h> > > > > @@ -222,6 +221,12 @@ static void __init request_standard_resources(void) > > > > kernel_data.end <= res->end) > > > > request_resource(res, &kernel_data); > > > > } > > > > + > > > > +#ifdef CONFIG_KEXEC_CORE > > > > + /* User space tools will find "Crash kernel" region in /proc/iomem. */ > > > > + if (crashk_res.end) > > > > + insert_resource(&iomem_resource, &crashk_res); > > > > +#endif > > > > } > > > > > > > > u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID }; > > > > diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c > > > > index 2ade7a6..51b1302 100644 > > > > --- a/arch/arm64/mm/init.c > > > > +++ b/arch/arm64/mm/init.c > > > > @@ -29,11 +29,13 @@ > > > > #include <linux/gfp.h> > > > > #include <linux/memblock.h> > > > > #include <linux/sort.h> > > > > +#include <linux/of.h> > > > > #include <linux/of_fdt.h> > > > > #include <linux/dma-mapping.h> > > > > #include <linux/dma-contiguous.h> > > > > #include <linux/efi.h> > > > > #include <linux/swiotlb.h> > > > > +#include <linux/kexec.h> > > > > > > > > #include <asm/boot.h> > > > > #include <asm/fixmap.h> > > > > @@ -76,6 +78,117 @@ static int __init early_initrd(char *p) > > > > early_param("initrd", early_initrd); > > > > #endif > > > > > > > > +#ifdef CONFIG_KEXEC_CORE > > > > +static unsigned long long crash_size, crash_base; > > > > +static struct property crash_base_prop = { > > > > + .name = "linux,crashkernel-base", > > > > + .length = sizeof(u64), > > > > + .value = &crash_base > > > > +}; > > > > +static struct property crash_size_prop = { > > > > + .name = "linux,crashkernel-size", > > > > + .length = sizeof(u64), > > > > + .value = &crash_size, > > > > +}; > > > > + > > > > +static int __init export_crashkernel(void) > > > > +{ > > > > + struct device_node *node; > > > > + int ret; > > > > + > > > > + if (!crashk_res.end) > > > > + return 0; > > > > + > > > > + crash_base = cpu_to_be64(crashk_res.start); > > > > + crash_size = cpu_to_be64(crashk_res.end - crashk_res.start + 1); > > > > + > > > > + /* Add /chosen/linux,crashkernel-* properties */ > > > > + node = of_find_node_by_path("/chosen"); > > > > + if (!node) > > > > + return -ENOENT; > > > > + > > > > + /* > > > > + * There might be existing crash kernel properties, but we can't > > > > + * be sure what's in them, so remove them. > > > > + */ > > > > + of_remove_property(node, of_find_property(node, > > > > + "linux,crashkernel-base", NULL)); > > > > + of_remove_property(node, of_find_property(node, > > > > + "linux,crashkernel-size", NULL)); > > > > + > > > > + ret = of_add_property(node, &crash_base_prop); > > > > + if (ret) > > > > + goto ret_err; > > > > + > > > > + ret = of_add_property(node, &crash_size_prop); > > > > + if (ret) > > > > + goto ret_err; > > > > + > > > > + return 0; > > > > + > > > > +ret_err: > > > > + pr_warn("Exporting crashkernel region to device tree failed\n"); > > > > + return ret; > > > > +} > > > > +late_initcall(export_crashkernel); > > > > + > > > > +/* > > > > + * reserve_crashkernel() - reserves memory for crash kernel > > > > + * > > > > + * This function reserves memory area given in "crashkernel=" kernel command > > > > + * line parameter. The memory reserved is used by dump capture kernel when > > > > + * primary kernel is crashing. > > > > + */ > > > > +static void __init reserve_crashkernel(void) > > > > +{ > > > > + 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 (crash_base == 0) { > > > > + /* Current arm64 boot protocol requires 2MB alignment */ > > > > + crash_base = memblock_find_in_range(0, > > > > + MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); > > > > + if (crash_base == 0) { > > > > + pr_warn("Unable to allocate crashkernel (size:%llx)\n", > > > > + crash_size); > > > > + return; > > > > + } > > > > + memblock_reserve(crash_base, crash_size); > > > > > > > I am not pretty sure the context here, but > > > can we use below code piece instead of the above lines? > > > if (crash_base == 0) > > > memblock_alloc(crash_size, SZ_2M); > > Either would be fine here. > > > Hello AKASHI, maybe you can succeed to find the base with memblock_find_in_range(), > but that doesn't mean you will also succeed to reserve them with memblock_reserve followed. We avoid memblock_alloc() here because it panics on failure. This could happen if user asks for an unusually large crashkernel size. Better to print a message and keep booting. Checking the return value of memblock_reserve() seems like a good thing to do though. > > Thanks, > Dennis > > > > > > Thanks, > > -Takahiro AKASHI > > > > > > > > Thanks, > > > Dennis > > > > > > > > > > > + > > > > + } else { > > > > + /* User specifies base address explicitly. */ > > > > + if (!memblock_is_region_memory(crash_base, crash_size) || > > > > + memblock_is_region_reserved(crash_base, crash_size)) { > > > > + pr_warn("crashkernel has wrong address or size\n"); > > > > + return; > > > > + } > > > > + > > > > + if (!IS_ALIGNED(crash_base, SZ_2M)) { > > > > + pr_warn("crashkernel base address is not 2MB aligned\n"); > > > > + return; > > > > + } > > > > + > > > > + memblock_reserve(crash_base, crash_size); > > > > + } > > > > + > > > > + pr_info("Reserving %lldMB of memory at %lldMB for crashkernel\n", > > > > + crash_size >> 20, crash_base >> 20); > > > > + > > > > + crashk_res.start = crash_base; > > > > + crashk_res.end = crash_base + crash_size - 1; > > > > +} > > > > +#else > > > > +static void __init reserve_crashkernel(void) > > > > +{ > > > > + ; > > > > +} > > > > +#endif /* CONFIG_KEXEC_CORE */ > > > > + > > > > /* > > > > * Return the maximum physical address for ZONE_DMA (DMA_BIT_MASK(32)). It > > > > * currently assumes that for memory starting above 4G, 32-bit devices will > > > > @@ -289,6 +402,8 @@ void __init arm64_memblock_init(void) > > > > } > > > > #endif > > > > > > > > + reserve_crashkernel(); > > > > + > > > > early_init_fdt_scan_reserved_mem(); > > > > > > > > /* 4GB maximum for 32-bit only capable devices */ > > > > -- > > > > 2.9.0 > > > > > > > > > > > > _______________________________________________ > > > > linux-arm-kernel mailing list > > > > linux-arm-kernel@lists.infradead.org > > > > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > > > >
On Tue, Jul 19, 2016 at 08:48:57AM -0400, Mark Salter wrote: > On Tue, 2016-07-19 at 18:41 +0800, Dennis Chen wrote: > > On Tue, Jul 19, 2016 at 07:28:16PM +0900, AKASHI Takahiro wrote: > > > On Tue, Jul 19, 2016 at 05:39:07PM +0800, Dennis Chen wrote: > > > > On Tue, Jul 12, 2016 at 02:05:07PM +0900, AKASHI Takahiro wrote: > > > > > +/* > > > > > + * reserve_crashkernel() - reserves memory for crash kernel > > > > > + * > > > > > + * This function reserves memory area given in "crashkernel=" kernel command > > > > > + * line parameter. The memory reserved is used by dump capture kernel when > > > > > + * primary kernel is crashing. > > > > > + */ > > > > > +static void __init reserve_crashkernel(void) > > > > > +{ > > > > > + 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 (crash_base == 0) { > > > > > + /* Current arm64 boot protocol requires 2MB alignment */ > > > > > + crash_base = memblock_find_in_range(0, > > > > > + MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); > > > > > + if (crash_base == 0) { > > > > > + pr_warn("Unable to allocate crashkernel (size:%llx)\n", > > > > > + crash_size); > > > > > + return; > > > > > + } > > > > > + memblock_reserve(crash_base, crash_size); > > > > > > > > > I am not pretty sure the context here, but > > > > can we use below code piece instead of the above lines? > > > > if (crash_base == 0) > > > > memblock_alloc(crash_size, SZ_2M); > > > Either would be fine here. > > > > > Hello AKASHI, maybe you can succeed to find the base with memblock_find_in_range(), > > but that doesn't mean you will also succeed to reserve them with memblock_reserve followed. > > We avoid memblock_alloc() here because it panics on failure. This could happen > if user asks for an unusually large crashkernel size. Better to print a message > and keep booting. Checking the return value of memblock_reserve() seems like a > good thing to do though. Another option would be to add a memblock_try_alloc() function to the memblock API, which in case of failure returns 0 rather than triggering a panic(). We'd still have to check the return value, but all the memblock manipulation would be in one place. It looks like adding that is fairly simple: phys_addr_t __init memblock_try_alloc(phys_addr_t size, phys_addr_t align) { return __memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE); } Thanks, Mark.
On Tue, Jul 19, 2016 at 08:48:57AM -0400, Mark Salter wrote: > On Tue, 2016-07-19 at 18:41 +0800, Dennis Chen wrote: > > On Tue, Jul 19, 2016 at 07:28:16PM +0900, AKASHI Takahiro wrote: > > > > > > On Tue, Jul 19, 2016 at 05:39:07PM +0800, Dennis Chen wrote: > > > > > > > > Hello AKASHI, > > > > > > > > On Tue, Jul 12, 2016 at 02:05:07PM +0900, AKASHI Takahiro wrote: > > > > > > > > > > On the startup of primary kernel, the memory region used by crash dump > > > > > kernel must be specified by "crashkernel=" kernel parameter. > > > > > reserve_crashkernel() will allocate and reserve the region for later use. > > > > > > > > > > User space tools, like kexec-tools, will be able to find that region as > > > > > ????????????- "Crash kernel" in /proc/iomem, or > > > > > ????????????- "linux,crashkernel-base" and "linux,crashkernel-size" under > > > > > ????????????????/sys/firmware/devicetree/base/chosen > > > > > > > > > > Signed-off-by: AKASHI Takahiro <takahiro.akashi@linaro.org> > > > > > Signed-off-by: Mark Salter <msalter@redhat.com> > > > > > Signed-off-by: Pratyush Anand <panand@redhat.com> > > > > > Reviewed-by: James Morse <james.morse@arm.com> > > > > > --- > > > > > ??arch/arm64/kernel/setup.c |??????7 ++- > > > > > ??arch/arm64/mm/init.c????????????| 115 ++++++++++++++++++++++++++++++++++++++++++++++ > > > > > ??2 files changed, 121 insertions(+), 1 deletion(-) > > > > > > > > > > diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c > > > > > index c1509e6..cb5eee0 100644 > > > > > --- a/arch/arm64/kernel/setup.c > > > > > +++ b/arch/arm64/kernel/setup.c > > > > > @@ -31,7 +31,6 @@ > > > > > ??#include <linux/screen_info.h> > > > > > ??#include <linux/init.h> > > > > > ??#include <linux/kexec.h> > > > > > -#include <linux/crash_dump.h> > > > > > ??#include <linux/root_dev.h> > > > > > ??#include <linux/cpu.h> > > > > > ??#include <linux/interrupt.h> > > > > > @@ -222,6 +221,12 @@ static void __init request_standard_resources(void) > > > > > ????????????????????????????????????kernel_data.end <= res->end) > > > > > ????????????????????????????????????????????request_resource(res, &kernel_data); > > > > > ????????????} > > > > > + > > > > > +#ifdef CONFIG_KEXEC_CORE > > > > > +??????????/* User space tools will find "Crash kernel" region in /proc/iomem. */ > > > > > +??????????if (crashk_res.end) > > > > > +??????????????????????????insert_resource(&iomem_resource, &crashk_res); > > > > > +#endif > > > > > ??} > > > > > > > > > > ??u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID }; > > > > > diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c > > > > > index 2ade7a6..51b1302 100644 > > > > > --- a/arch/arm64/mm/init.c > > > > > +++ b/arch/arm64/mm/init.c > > > > > @@ -29,11 +29,13 @@ > > > > > ??#include <linux/gfp.h> > > > > > ??#include <linux/memblock.h> > > > > > ??#include <linux/sort.h> > > > > > +#include <linux/of.h> > > > > > ??#include <linux/of_fdt.h> > > > > > ??#include <linux/dma-mapping.h> > > > > > ??#include <linux/dma-contiguous.h> > > > > > ??#include <linux/efi.h> > > > > > ??#include <linux/swiotlb.h> > > > > > +#include <linux/kexec.h> > > > > > > > > > > ??#include <asm/boot.h> > > > > > ??#include <asm/fixmap.h> > > > > > @@ -76,6 +78,117 @@ static int __init early_initrd(char *p) > > > > > ??early_param("initrd", early_initrd); > > > > > ??#endif > > > > > > > > > > +#ifdef CONFIG_KEXEC_CORE > > > > > +static unsigned long long crash_size, crash_base; > > > > > +static struct property crash_base_prop = { > > > > > +??????????.name = "linux,crashkernel-base", > > > > > +??????????.length = sizeof(u64), > > > > > +??????????.value = &crash_base > > > > > +}; > > > > > +static struct property crash_size_prop = { > > > > > +??????????.name = "linux,crashkernel-size", > > > > > +??????????.length = sizeof(u64), > > > > > +??????????.value = &crash_size, > > > > > +}; > > > > > + > > > > > +static int __init export_crashkernel(void) > > > > > +{ > > > > > +??????????struct device_node *node; > > > > > +??????????int ret; > > > > > + > > > > > +??????????if (!crashk_res.end) > > > > > +??????????????????????????return 0; > > > > > + > > > > > +??????????crash_base = cpu_to_be64(crashk_res.start); > > > > > +??????????crash_size = cpu_to_be64(crashk_res.end - crashk_res.start + 1); > > > > > + > > > > > +??????????/* Add /chosen/linux,crashkernel-* properties */ > > > > > +??????????node = of_find_node_by_path("/chosen"); > > > > > +??????????if (!node) > > > > > +??????????????????????????return -ENOENT; > > > > > + > > > > > +??????????/* > > > > > +????????????* There might be existing crash kernel properties, but we can't > > > > > +????????????* be sure what's in them, so remove them. > > > > > +????????????*/ > > > > > +??????????of_remove_property(node, of_find_property(node, > > > > > +??????????????????????????????????????????????????????????"linux,crashkernel-base", NULL)); > > > > > +??????????of_remove_property(node, of_find_property(node, > > > > > +??????????????????????????????????????????????????????????"linux,crashkernel-size", NULL)); > > > > > + > > > > > +??????????ret = of_add_property(node, &crash_base_prop); > > > > > +??????????if (ret) > > > > > +??????????????????????????goto ret_err; > > > > > + > > > > > +??????????ret = of_add_property(node, &crash_size_prop); > > > > > +??????????if (ret) > > > > > +??????????????????????????goto ret_err; > > > > > + > > > > > +??????????return 0; > > > > > + > > > > > +ret_err: > > > > > +??????????pr_warn("Exporting crashkernel region to device tree failed\n"); > > > > > +??????????return ret; > > > > > +} > > > > > +late_initcall(export_crashkernel); > > > > > + > > > > > +/* > > > > > + * reserve_crashkernel() - reserves memory for crash kernel > > > > > + * > > > > > + * This function reserves memory area given in "crashkernel=" kernel command > > > > > + * line parameter. The memory reserved is used by dump capture kernel when > > > > > + * primary kernel is crashing. > > > > > + */ > > > > > +static void __init reserve_crashkernel(void) > > > > > +{ > > > > > +??????????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 (crash_base == 0) { > > > > > +??????????????????????????/* Current arm64 boot protocol requires 2MB alignment */ > > > > > +??????????????????????????crash_base = memblock_find_in_range(0, > > > > > +??????????????????????????????????????????????????????????MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); > > > > > +??????????????????????????if (crash_base == 0) { > > > > > +??????????????????????????????????????????pr_warn("Unable to allocate crashkernel (size:%llx)\n", > > > > > +??????????????????????????????????????????????????????????crash_size); > > > > > +??????????????????????????????????????????return; > > > > > +??????????????????????????} > > > > > +??????????????????????????memblock_reserve(crash_base, crash_size); > > > > > > > > > I am not pretty sure the context here, but > > > > can we use below code piece instead of the above lines? > > > > ????????????????if (crash_base == 0) > > > > ????????????????????????????????memblock_alloc(crash_size, SZ_2M); > > > Either would be fine here. > > > > > Hello AKASHI, maybe you can succeed to find the base with memblock_find_in_range(),?? > > but that doesn't mean you will also succeed to reserve them with memblock_reserve followed. > > We avoid memblock_alloc() here because it panics on failure. This could happen Thank you for pointing this out. I forgot it. > if user asks for an unusually large crashkernel size. Better to print a message > and keep booting. Checking the return value of memblock_reserve() seems like a > good thing to do though. Yeah, but it is unlikely that the function fails in this context (just after find_in_range at early boot time) and nobody in arm64/mm/*.c checks a return value of memblock_reserve() as well. So I want to keep the code unchanged. Thanks, -Takahiro AKASHI > > > > > Thanks, > > Dennis > > > > > > > > > Thanks, > > > -Takahiro AKASHI > > > > > > > > > > > Thanks, > > > > Dennis > > > > > > > > > > > > > > + > > > > > +??????????} else { > > > > > +??????????????????????????/* User specifies base address explicitly. */ > > > > > +??????????????????????????if (!memblock_is_region_memory(crash_base, crash_size) || > > > > > +??????????????????????????????????????????memblock_is_region_reserved(crash_base, crash_size)) { > > > > > +??????????????????????????????????????????pr_warn("crashkernel has wrong address or size\n"); > > > > > +??????????????????????????????????????????return; > > > > > +??????????????????????????} > > > > > + > > > > > +??????????????????????????if (!IS_ALIGNED(crash_base, SZ_2M)) { > > > > > +??????????????????????????????????????????pr_warn("crashkernel base address is not 2MB aligned\n"); > > > > > +??????????????????????????????????????????return; > > > > > +??????????????????????????} > > > > > + > > > > > +??????????????????????????memblock_reserve(crash_base, crash_size); > > > > > +??????????} > > > > > + > > > > > +??????????pr_info("Reserving %lldMB of memory at %lldMB for crashkernel\n", > > > > > +??????????????????????????crash_size >> 20, crash_base >> 20); > > > > > + > > > > > +??????????crashk_res.start = crash_base; > > > > > +??????????crashk_res.end = crash_base + crash_size - 1; > > > > > +} > > > > > +#else > > > > > +static void __init reserve_crashkernel(void) > > > > > +{ > > > > > +??????????; > > > > > +} > > > > > +#endif /* CONFIG_KEXEC_CORE */ > > > > > + > > > > > ??/* > > > > > ?? * Return the maximum physical address for ZONE_DMA (DMA_BIT_MASK(32)). It > > > > > ?? * currently assumes that for memory starting above 4G, 32-bit devices will > > > > > @@ -289,6 +402,8 @@ void __init arm64_memblock_init(void) > > > > > ????????????} > > > > > ??#endif > > > > > > > > > > +??????????reserve_crashkernel(); > > > > > + > > > > > ????????????early_init_fdt_scan_reserved_mem(); > > > > > > > > > > ????????????/* 4GB maximum for 32-bit only capable devices */ > > > > > -- > > > > > 2.9.0 > > > > > > > > > > > > > > > _______________________________________________ > > > > > linux-arm-kernel mailing list > > > > > linux-arm-kernel@lists.infradead.org > > > > > http://lists.infradead.org/mailman/listinfo/linux-arm-kernel > > > > > > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
On Tue, Jul 19, 2016 at 02:27:54PM +0100, Mark Rutland wrote: > On Tue, Jul 19, 2016 at 08:48:57AM -0400, Mark Salter wrote: > > On Tue, 2016-07-19 at 18:41 +0800, Dennis Chen wrote: > > > On Tue, Jul 19, 2016 at 07:28:16PM +0900, AKASHI Takahiro wrote: > > > > On Tue, Jul 19, 2016 at 05:39:07PM +0800, Dennis Chen wrote: > > > > > On Tue, Jul 12, 2016 at 02:05:07PM +0900, AKASHI Takahiro wrote: > > > > > > +/* > > > > > > + * reserve_crashkernel() - reserves memory for crash kernel > > > > > > + * > > > > > > + * This function reserves memory area given in "crashkernel=" kernel command > > > > > > + * line parameter. The memory reserved is used by dump capture kernel when > > > > > > + * primary kernel is crashing. > > > > > > + */ > > > > > > +static void __init reserve_crashkernel(void) > > > > > > +{ > > > > > > +??????????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 (crash_base == 0) { > > > > > > +??????????????????????????/* Current arm64 boot protocol requires 2MB alignment */ > > > > > > +??????????????????????????crash_base = memblock_find_in_range(0, > > > > > > +??????????????????????????????????????????????????????????MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); > > > > > > +??????????????????????????if (crash_base == 0) { > > > > > > +??????????????????????????????????????????pr_warn("Unable to allocate crashkernel (size:%llx)\n", > > > > > > +??????????????????????????????????????????????????????????crash_size); > > > > > > +??????????????????????????????????????????return; > > > > > > +??????????????????????????} > > > > > > +??????????????????????????memblock_reserve(crash_base, crash_size); > > > > > > > > > > > I am not pretty sure the context here, but > > > > > can we use below code piece instead of the above lines? > > > > > ????????????????if (crash_base == 0) > > > > > ????????????????????????????????memblock_alloc(crash_size, SZ_2M); > > > > Either would be fine here. > > > > > > > Hello AKASHI, maybe you can succeed to find the base with memblock_find_in_range(),?? > > > but that doesn't mean you will also succeed to reserve them with memblock_reserve followed. > > > > We avoid memblock_alloc() here because it panics on failure. This could happen > > if user asks for an unusually large crashkernel size. Better to print a message > > and keep booting. Checking the return value of memblock_reserve() seems like a > > good thing to do though. > > Another option would be to add a memblock_try_alloc() function to the > memblock API, which in case of failure returns 0 rather than triggering > a panic(). We'd still have to check the return value, but all the > memblock manipulation would be in one place. > > It looks like adding that is fairly simple: > > phys_addr_t __init memblock_try_alloc(phys_addr_t size, phys_addr_t align) > { > return __memblock_alloc_base(size, align, MEMBLOCK_ALLOC_ACCESSIBLE); > } Apart form this issue, I found that the kernel can panic, if the memory for crash dump kernel is allocated above 32-bits, due to a failure of alloc_bootmem_low() in request_standard_resources(). (In addition, dma_contiguous_reserve() will also fail.) So I'd like to change the code to: if (crash_base == 0) { crash_base = memblock_find_in_range(0, IS_ENABLED(CONFIG_ZONE_DMA) ? ARCH_LOW_ADDRESS_LIMIT : MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); ... Does this make sense? Thanks, -Takahiro AKASHI > Thanks, > Mark. _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
diff --git a/arch/arm64/kernel/setup.c b/arch/arm64/kernel/setup.c index c1509e6..cb5eee0 100644 --- a/arch/arm64/kernel/setup.c +++ b/arch/arm64/kernel/setup.c @@ -31,7 +31,6 @@ #include <linux/screen_info.h> #include <linux/init.h> #include <linux/kexec.h> -#include <linux/crash_dump.h> #include <linux/root_dev.h> #include <linux/cpu.h> #include <linux/interrupt.h> @@ -222,6 +221,12 @@ static void __init request_standard_resources(void) kernel_data.end <= res->end) request_resource(res, &kernel_data); } + +#ifdef CONFIG_KEXEC_CORE + /* User space tools will find "Crash kernel" region in /proc/iomem. */ + if (crashk_res.end) + insert_resource(&iomem_resource, &crashk_res); +#endif } u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID }; diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c index 2ade7a6..51b1302 100644 --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -29,11 +29,13 @@ #include <linux/gfp.h> #include <linux/memblock.h> #include <linux/sort.h> +#include <linux/of.h> #include <linux/of_fdt.h> #include <linux/dma-mapping.h> #include <linux/dma-contiguous.h> #include <linux/efi.h> #include <linux/swiotlb.h> +#include <linux/kexec.h> #include <asm/boot.h> #include <asm/fixmap.h> @@ -76,6 +78,117 @@ static int __init early_initrd(char *p) early_param("initrd", early_initrd); #endif +#ifdef CONFIG_KEXEC_CORE +static unsigned long long crash_size, crash_base; +static struct property crash_base_prop = { + .name = "linux,crashkernel-base", + .length = sizeof(u64), + .value = &crash_base +}; +static struct property crash_size_prop = { + .name = "linux,crashkernel-size", + .length = sizeof(u64), + .value = &crash_size, +}; + +static int __init export_crashkernel(void) +{ + struct device_node *node; + int ret; + + if (!crashk_res.end) + return 0; + + crash_base = cpu_to_be64(crashk_res.start); + crash_size = cpu_to_be64(crashk_res.end - crashk_res.start + 1); + + /* Add /chosen/linux,crashkernel-* properties */ + node = of_find_node_by_path("/chosen"); + if (!node) + return -ENOENT; + + /* + * There might be existing crash kernel properties, but we can't + * be sure what's in them, so remove them. + */ + of_remove_property(node, of_find_property(node, + "linux,crashkernel-base", NULL)); + of_remove_property(node, of_find_property(node, + "linux,crashkernel-size", NULL)); + + ret = of_add_property(node, &crash_base_prop); + if (ret) + goto ret_err; + + ret = of_add_property(node, &crash_size_prop); + if (ret) + goto ret_err; + + return 0; + +ret_err: + pr_warn("Exporting crashkernel region to device tree failed\n"); + return ret; +} +late_initcall(export_crashkernel); + +/* + * reserve_crashkernel() - reserves memory for crash kernel + * + * This function reserves memory area given in "crashkernel=" kernel command + * line parameter. The memory reserved is used by dump capture kernel when + * primary kernel is crashing. + */ +static void __init reserve_crashkernel(void) +{ + 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 (crash_base == 0) { + /* Current arm64 boot protocol requires 2MB alignment */ + crash_base = memblock_find_in_range(0, + MEMBLOCK_ALLOC_ACCESSIBLE, crash_size, SZ_2M); + if (crash_base == 0) { + pr_warn("Unable to allocate crashkernel (size:%llx)\n", + crash_size); + return; + } + memblock_reserve(crash_base, crash_size); + + } else { + /* User specifies base address explicitly. */ + if (!memblock_is_region_memory(crash_base, crash_size) || + memblock_is_region_reserved(crash_base, crash_size)) { + pr_warn("crashkernel has wrong address or size\n"); + return; + } + + if (!IS_ALIGNED(crash_base, SZ_2M)) { + pr_warn("crashkernel base address is not 2MB aligned\n"); + return; + } + + memblock_reserve(crash_base, crash_size); + } + + pr_info("Reserving %lldMB of memory at %lldMB for crashkernel\n", + crash_size >> 20, crash_base >> 20); + + crashk_res.start = crash_base; + crashk_res.end = crash_base + crash_size - 1; +} +#else +static void __init reserve_crashkernel(void) +{ + ; +} +#endif /* CONFIG_KEXEC_CORE */ + /* * Return the maximum physical address for ZONE_DMA (DMA_BIT_MASK(32)). It * currently assumes that for memory starting above 4G, 32-bit devices will @@ -289,6 +402,8 @@ void __init arm64_memblock_init(void) } #endif + reserve_crashkernel(); + early_init_fdt_scan_reserved_mem(); /* 4GB maximum for 32-bit only capable devices */