From a364008bff5e245cf4125540a043ee3ffac3de98 Mon Sep 17 00:00:00 2001 From: Mingzheng Xing Date: Thu, 18 Apr 2024 11:26:52 +0800 Subject: [PATCH 1/7] kdump: Add riscv64 support This patch provides support for enabling the kdump service on riscv. After starting the kdump service, the kdump kernel can be successfully loaded, and after triggering a kernel crash, the kdump kernel can be started normally and the vmcore can be captured. Due to some issues with initrd in kexec-tools, avoid it first to provide basic riscv architecture kdump support. Tested in openeuler riscv qemu, and can also pass Mugen testing. Signed-off-by: Mingzheng Xing (cherry picked from commit 7033d5da29de3ac009d36a9e5e516aaa6d58712d) --- kdump.sysconfig.riscv64 | 37 + kexec-tools-Add-riscv-support.patch | 1992 +++++++++++++++++++++++++++ kexec-tools.spec | 28 +- riscv-makedumpfile-1.7.3.patch | 910 ++++++++++++ 4 files changed, 2960 insertions(+), 7 deletions(-) create mode 100644 kdump.sysconfig.riscv64 create mode 100644 kexec-tools-Add-riscv-support.patch create mode 100644 riscv-makedumpfile-1.7.3.patch diff --git a/kdump.sysconfig.riscv64 b/kdump.sysconfig.riscv64 new file mode 100644 index 0000000..1e65df8 --- /dev/null +++ b/kdump.sysconfig.riscv64 @@ -0,0 +1,37 @@ +# Kernel Version string for the -kdump kernel, such as 2.6.13-1544.FC5kdump +# If no version is specified, then the init script will try to find a +# kdump kernel with the same version number as the running kernel. +KDUMP_KERNELVER="" + +# The kdump commandline is the command line that needs to be passed off to +# the kdump kernel. This will likely match the contents of the grub kernel +# line. For example: +# KDUMP_COMMANDLINE="ro root=LABEL=/" +# Dracut depends on proper root= options, so please make sure that appropriate +# root= options are copied from /proc/cmdline. In general it is best to append +# command line options using "KDUMP_COMMANDLINE_APPEND=". +# If a command line is not specified, the default will be taken from +# /proc/cmdline +KDUMP_COMMANDLINE="" + +# This variable lets us remove arguments from the current kdump commandline +# as taken from either KDUMP_COMMANDLINE above, or from /proc/cmdline +# NOTE: some arguments such as crashkernel will always be removed +KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet" + +# This variable lets us append arguments to the current kdump commandline +# after processed by KDUMP_COMMANDLINE_REMOVE +KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices novmcoredd noinitrd" + +# Any additional kexec arguments required. In most situations, this should +# be left empty +# +# Example: +# KEXEC_ARGS="--elf32-core-headers" +KEXEC_ARGS="" + +#Where to find the boot image +#KDUMP_BOOTDIR="/boot" + +#What is the image type used for kdump +KDUMP_IMG="vmlinuz" diff --git a/kexec-tools-Add-riscv-support.patch b/kexec-tools-Add-riscv-support.patch new file mode 100644 index 0000000..2411292 --- /dev/null +++ b/kexec-tools-Add-riscv-support.patch @@ -0,0 +1,1992 @@ +From 82e95543fb855e5686630ca4d86b0f55f8ac45cb Mon Sep 17 00:00:00 2001 +From: Mingzheng Xing +Date: Wed, 17 Apr 2024 15:42:31 +0800 +Subject: [PATCH] kexec-tools Add riscv support +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +The riscv support of kexec-tools has not entered the upstream mainline. +The support patch comes from the following commits from the upstream +community, which providing preliminary support for the riscv arch. + +Author: Nick Kossifidis +Date: Thu Oct 20 11:15:48 2022 +0800 + + RISC-V: Add support for riscv kexec/kdump on kexec-tools + + This patch adds support for loading the ELF kernel image. It parses + the current/provided device tree to determine the system's memory + layout, and /proc/iomem for the various kernel segments. + + This patch was firstly developed by Nick Kossifidis, and two fixes ( + 1: fail to find free memory area for dtb load when using initrd image, + lists.infradead.org/pipermail/linux-riscv/2022-August/018398.html; + 2: fix memory range size calculation, + kexec/arch/riscv/crashdump-riscv.c:line 85 + ) are contributed by Yixun Lan, Xianting Tian. + + Tested on Qemu's rv64 virt machine and SoC of T-Head RISC-V Xuantie 910 CPU. + + Tested-by: Yixun Lan + Co-developed-by: Xianting Tian + Co-developed-by: Yixun Lan + Signed-off-by: Nick Kossifidis + Signed-off-by: Simon Horman + +Author: Simon Horman +Date: Fri Oct 21 17:02:23 2022 +0200 + + local: RISC-V: distribute purgatory/riscv/Makefile + + Include purgatory/riscv/Makefile in distribution tarball. + + Local patch as it is planned to suggest this as a fix for + the patch that introduced this problem. + + http://lists.infradead.org/pipermail/kexec/2022-October/026057.html + + Signed-off-by: Simon Horman + +Author: Song Shuai +Date: Fri Aug 11 18:19:09 2023 +0800 + + RISC-V: Some fixes for riscv port + + RISC-V: Fix the undeclared ‘EM_RISCV’ build failure + =================================================== + + Use local `elf.h` instead of `linux/elf.h` to fix this build error: + + ``` + kexec/arch/riscv/crashdump-riscv.c:17:13: error: ‘EM_RISCV’ undeclared here (not in a function); did you mean ‘EM_CRIS’? + .machine = EM_RISCV, + ^~~~~~~~ + EM_CRIS + ``` + + RISC-V: Correct the usage of command line option + ================================================ + + RISC-V process OPT_CMDLINE with the "command-line" partten, + but the riscv_opts_usage shows the "cmdline" option. + So correct the usage's output. + + RISC-V: Use linux,usable-memory-range for crash kernel + ====================================================== + + Now we use "memeory::linux,usable-memory" to indicate the available + memory for the crash kernel. + + While booting with UEFI, the crash kernel would use efi.memmap to + re-populate memblock and then first kernel's memory would be corrputed. + Consequently, the /proc/vmcore file failed to create in my local test. + + And according to "chosen" dtschema [1], the available memory for the + crash kernel should be held via "chosen::linux,usable-memory-range" + property which will re-cap memblock even after UEFI's re-population. + + [1]: https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/chosen.yaml + + RISC-V: Get memory ranges from iomem + ==================================== + + When booting with UEFI, Linux marks the Runtime Code/Data memory + as no-map and then exports it to "Reserved" iomem_resource. + + Kexc-tools uses dtb_get_memory_ranges() function to get memory ranges + via parsing dtb, but it can't see the Reserved EFI Runtime memory. + That would corrupt EFI Runtime memory and fail the kexeced kernel to + deal EFI stuff. + + In my test, the kexeced kernel warned "efi: System table signature incorrect!" + and then paniced at efi_call_rts() due to the null efi.runtime. + + So we should use /proc/iomem to get memory ranges. + + Signed-off-by: Song Shuai + +Author: Li Zhengyu +Date: Thu Aug 31 18:35:43 2023 +0800 + + RISC-V: Enable kexec_file_load syscall + + Create prepare_kexec_file_options() function to prepare the options + to kexec_file_load syscall, and it would be used in elf_riscv_load() + or the future image_riscv_load(). + + The patch comes from the RISC-V Linux kernel_file_load support[1], + So its author should be Li Zhengyu. + + [1]: https://lore.kernel.org/all/20220408100914.150110-1-lizhengyu3@huawei.com/ + + Signed-off-by: Song Shuai + +Author: Song Shuai +Date: Wed Sep 13 15:53:39 2023 +0800 + + RISC-V: Separate elf_riscv_find_pbase out + + The is the preparative patch for RISC-V kexec Image file support. + + Separate the elf_riscv_find_pbase() function out to + allow kernel_load syscall load Image binary file. + + Signed-off-by: Song Shuai + +Author: Song Shuai +Date: Wed Sep 13 11:31:47 2023 +0800 + + RISC-V: Support loading Image binary file + + Add image-riscv file_type to probe/load Image file type, + + As for kexec_load, find the pbase aligned text_offset from image header + and prepare segments for this syscall. + + for kexec_file_load, setup the related options and let kernel part to + deal with the Image. + + Signed-off-by: Song Shuai + +Author: Chen Jiahao +Date: Sat Mar 18 19:49:40 2023 +0800 + + RISC-V: Fix locate_hole failed when loading device tree + + When adding the device tree in load_extra_segments, the min_usable + address should start from initrd_base, i.e. the start of target + memory range. While the max_usable should still be the max_addr + of search range. + + Signed-off-by: Chen Jiahao + +Author: Chen Jiahao +Date: Sat Mar 18 23:23:34 2023 +0800 + + kexec: Add support for crashkernel=X,[high,low] on RISC-V + + When allocating crash kernel above 4G memory, more than one iomem + region will be reserved for crash kernel. Support parsing high memory + address for kernel ELF. + + Signed-off-by: Chen Jiahao + +Link: https://lore.kernel.org/linux-riscv/20230726175000.2536220-1-chenjiahao16@huawei.com +Link: https://lore.kernel.org/kexec/20221020031548.47587-1-xianting.tian@linux.alibaba.com +Signed-off-by: Mingzheng Xing +--- + configure.ac | 3 + + include/elf.h | 1 + + kexec/Makefile | 1 + + kexec/arch/riscv/Makefile | 37 ++ + kexec/arch/riscv/crashdump-riscv.c | 140 +++++++ + kexec/arch/riscv/image-header.h | 88 +++++ + kexec/arch/riscv/include/arch/options.h | 43 +++ + kexec/arch/riscv/iomem.h | 10 + + kexec/arch/riscv/kexec-elf-riscv.c | 184 +++++++++ + kexec/arch/riscv/kexec-image-riscv.c | 95 +++++ + kexec/arch/riscv/kexec-riscv.c | 478 ++++++++++++++++++++++++ + kexec/arch/riscv/kexec-riscv.h | 53 +++ + kexec/dt-ops.c | 442 +++++++++++++++++++++- + kexec/dt-ops.h | 7 + + kexec/kexec-iomem.c | 4 +- + kexec/kexec-syscall.h | 7 + + purgatory/Makefile | 1 + + purgatory/arch/riscv/Makefile | 7 + + 18 files changed, 1598 insertions(+), 3 deletions(-) + create mode 100644 kexec/arch/riscv/Makefile + create mode 100644 kexec/arch/riscv/crashdump-riscv.c + create mode 100644 kexec/arch/riscv/image-header.h + create mode 100644 kexec/arch/riscv/include/arch/options.h + create mode 100644 kexec/arch/riscv/iomem.h + create mode 100644 kexec/arch/riscv/kexec-elf-riscv.c + create mode 100644 kexec/arch/riscv/kexec-image-riscv.c + create mode 100644 kexec/arch/riscv/kexec-riscv.c + create mode 100644 kexec/arch/riscv/kexec-riscv.h + create mode 100644 purgatory/arch/riscv/Makefile + +diff --git a/configure.ac b/configure.ac +index 767574e..a3e4e88 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -61,6 +61,9 @@ case $target_cpu in + loongarch*) + ARCH="loongarch" + ;; ++ riscv32|riscv64) ++ ARCH="riscv" ++ ;; + * ) + AC_MSG_ERROR([unsupported architecture $target_cpu]) + ;; +diff --git a/include/elf.h b/include/elf.h +index 1c8d2cc..93a5ee5 100644 +--- a/include/elf.h ++++ b/include/elf.h +@@ -259,6 +259,7 @@ typedef struct + #define EM_ARC_A5 93 /* ARC Cores Tangent-A5 */ + #define EM_XTENSA 94 /* Tensilica Xtensa Architecture */ + #define EM_AARCH64 183 /* ARM AARCH64 */ ++#define EM_RISCV 243 /* RISC-V */ + #define EM_LOONGARCH 258 /* Loongson Loongarch*/ + #define EM_NUM 184 + +diff --git a/kexec/Makefile b/kexec/Makefile +index 8a52e8d..405864a 100644 +--- a/kexec/Makefile ++++ b/kexec/Makefile +@@ -88,6 +88,7 @@ include $(srcdir)/kexec/arch/mips/Makefile + include $(srcdir)/kexec/arch/cris/Makefile + include $(srcdir)/kexec/arch/ppc/Makefile + include $(srcdir)/kexec/arch/ppc64/Makefile ++include $(srcdir)/kexec/arch/riscv/Makefile + include $(srcdir)/kexec/arch/s390/Makefile + include $(srcdir)/kexec/arch/sh/Makefile + include $(srcdir)/kexec/arch/x86_64/Makefile +diff --git a/kexec/arch/riscv/Makefile b/kexec/arch/riscv/Makefile +new file mode 100644 +index 0000000..37ef760 +--- /dev/null ++++ b/kexec/arch/riscv/Makefile +@@ -0,0 +1,37 @@ ++# ++# kexec riscv ++# ++riscv_KEXEC_SRCS = kexec/arch/riscv/kexec-riscv.c ++riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-elf-riscv.c ++riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-image-riscv.c ++riscv_KEXEC_SRCS += kexec/arch/riscv/crashdump-riscv.c ++ ++riscv_MEM_REGIONS = kexec/mem_regions.c ++ ++riscv_DT_OPS += kexec/dt-ops.c ++ ++riscv_ARCH_REUSE_INITRD = ++ ++riscv_CPPFLAGS += -I $(srcdir)/kexec/ ++ ++dist += kexec/arch/riscv/Makefile $(riscv_KEXEC_SRCS) \ ++ kexec/arch/riscv/kexec-riscv.h \ ++ kexec/arch/riscv/image-header.h \ ++ kexec/arch/riscv/include/arch/options.h ++ ++ifdef HAVE_LIBFDT ++ ++LIBS += -lfdt ++ ++else ++ ++include $(srcdir)/kexec/libfdt/Makefile.libfdt ++ ++libfdt_SRCS += $(LIBFDT_SRCS:%=kexec/libfdt/%) ++ ++riscv_CPPFLAGS += -I$(srcdir)/kexec/libfdt ++ ++riscv_KEXEC_SRCS += $(libfdt_SRCS) ++ ++endif ++ +diff --git a/kexec/arch/riscv/crashdump-riscv.c b/kexec/arch/riscv/crashdump-riscv.c +new file mode 100644 +index 0000000..336d7a7 +--- /dev/null ++++ b/kexec/arch/riscv/crashdump-riscv.c +@@ -0,0 +1,140 @@ ++#include ++#include ++#include ++ ++#include "kexec.h" ++#include "crashdump.h" ++#include "kexec-elf.h" ++#include "mem_regions.h" ++ ++static struct crash_elf_info elf_info = { ++#if __riscv_xlen == 64 ++ .class = ELFCLASS64, ++#else ++ .class = ELFCLASS32, ++#endif ++ .data = ELFDATA2LSB, ++ .machine = EM_RISCV, ++}; ++ ++static struct memory_ranges crash_mem_ranges = {0}; ++struct memory_range elfcorehdr_mem = {0}; ++ ++static unsigned long long get_page_offset(struct kexec_info *info) ++{ ++ unsigned long long vaddr_off = 0; ++ unsigned long long page_size = sysconf(_SC_PAGESIZE); ++ unsigned long long init_start = get_kernel_sym("_sinittext"); ++ ++ /* ++ * Begining of init section is aligned to page size ++ */ ++ vaddr_off = init_start - page_size; ++ ++ return vaddr_off; ++} ++ ++int load_elfcorehdr(struct kexec_info *info) ++{ ++ struct memory_range crashkern_range = {0}; ++ struct memory_range *ranges = NULL; ++ unsigned long start = 0; ++ unsigned long end = 0; ++ unsigned long buf_size = 0; ++ unsigned long elfcorehdr_addr = 0; ++ void* buf = NULL; ++ int i = 0; ++ int ret = 0; ++ ++ ret = parse_iomem_single("Kernel code\n", &start, NULL); ++ if (ret) { ++ fprintf(stderr, "Cannot determine kernel physical base addr\n"); ++ return -EINVAL; ++ } ++ elf_info.kern_paddr_start = start; ++ ++ ret = parse_iomem_single("Kernel bss\n", NULL, &end); ++ if (ret) { ++ fprintf(stderr, "Cannot determine kernel physical bss addr\n"); ++ return -EINVAL; ++ } ++ elf_info.kern_paddr_start = start; ++ elf_info.kern_size = end - start; ++ ++ elf_info.kern_vaddr_start = get_kernel_sym("_text"); ++ if (!elf_info.kern_vaddr_start) { ++ elf_info.kern_vaddr_start = UINT64_MAX; ++ } ++ ++ elf_info.page_offset = get_page_offset(info); ++ dbgprintf("page_offset: %016llx\n", elf_info.page_offset); ++ ++ ret = parse_iomem_single("Crash kernel\n", &start, &end); ++ if (ret) { ++ fprintf(stderr, "Cannot determine kernel physical bss addr\n"); ++ return -EINVAL; ++ } ++ crashkern_range.start = start; ++ crashkern_range.end = end; ++ crashkern_range.type = RANGE_RESERVED; ++ ++ ranges = info->memory_range; ++ for (i = 0; i < info->memory_ranges; i++) { ++ ret = mem_regions_alloc_and_add(&crash_mem_ranges, ++ ranges[i].start, ++ ranges[i].end - ranges[i].start + 1, ++ ranges[i].type); ++ if (ret ) { ++ fprintf(stderr, "Could not create crash_mem_ranges\n"); ++ return ret; ++ } ++ } ++ ++ ret = mem_regions_alloc_and_exclude(&crash_mem_ranges, ++ &crashkern_range); ++ if (ret) { ++ fprintf(stderr, "Could not exclude crashkern_range\n"); ++ return ret; ++ } ++ ++#if __riscv_xlen == 64 ++ crash_create_elf64_headers(info, &elf_info, crash_mem_ranges.ranges, ++ crash_mem_ranges.size, &buf, &buf_size, ++ ELF_CORE_HEADER_ALIGN); ++ ++#else ++ crash_create_elf32_headers(info, &elf_info, crash_mem_ranges.ranges, ++ crash_mem_ranges.size, &buf, &buf_size, ++ ELF_CORE_HEADER_ALIGN); ++#endif ++ ++ ++ elfcorehdr_addr = add_buffer_phys_virt(info, buf, buf_size, ++ buf_size, 0, ++ crashkern_range.start, ++ crashkern_range.end, ++ -1, 0); ++ ++ elfcorehdr_mem.start = elfcorehdr_addr; ++ elfcorehdr_mem.end = elfcorehdr_addr + buf_size - 1; ++ ++ dbgprintf("%s: elfcorehdr 0x%llx-0x%llx\n", __func__, ++ elfcorehdr_mem.start, elfcorehdr_mem.end); ++ ++ return 0; ++} ++ ++int is_crashkernel_mem_reserved(void) ++{ ++ uint64_t start = 0; ++ uint64_t end = 0; ++ ++ return parse_iomem_single("Crash kernel\n", &start, &end) == 0 ? ++ (start != end) : 0; ++} ++ ++int get_crash_kernel_load_range(uint64_t *start, uint64_t *end) ++{ ++ return parse_iomem_single("Crash kernel\n", start, end); ++} ++ +diff --git a/kexec/arch/riscv/image-header.h b/kexec/arch/riscv/image-header.h +new file mode 100644 +index 0000000..a677546 +--- /dev/null ++++ b/kexec/arch/riscv/image-header.h +@@ -0,0 +1,88 @@ ++/* ++ * RISCV64 binary image header. ++ * token from arm64/image-header.h ++ */ ++ ++#if !defined(__RISCV_IMAGE_HEADER_H) ++#define __RISCV_IMAGE_HEADER_H ++ ++#include ++#include ++ ++/** ++ * struct riscv_image_header - riscv kernel image header. ++ * ++ **/ ++struct riscv_image_header { ++ uint32_t code0; ++ uint32_t code1; ++ uint64_t text_offset; ++ uint64_t image_size; ++ uint64_t flags; ++ uint32_t version; ++ uint32_t res1; ++ uint64_t res2; ++ uint64_t magic; ++ uint32_t magic2; ++ uint32_t res3; ++}; ++ ++#define RISCV_IMAGE_MAGIC 0x5643534952 ++#define RISCV_IMAGE_MAGIC2 0x05435352 ++ ++#define RISCV_HEADER_VERSION_MAJOR 0 ++#define RISCV_HEADER_VERSION_MINOR 2 ++ ++#define RISCV_HEADER_VERSION (RISCV_HEADER_VERSION_MAJOR << 16 | \ ++ RISCV_HEADER_VERSION_MINOR) ++ ++ ++static const uint64_t riscv_image_flag_be = (1UL << 0); ++ ++/** ++ * riscv_header_check_magic - Helper to check the riscv image header. ++ * ++ * Returns non-zero if header is OK. ++ */ ++ ++static inline int riscv_header_check_magic(const struct riscv_image_header *h) ++{ ++ if (!h) ++ return 0; ++ ++ return (h->version >= RISCV_HEADER_VERSION && h->magic2 == RISCV_IMAGE_MAGIC2); ++} ++ ++/** ++ * riscv_header_check_endiannes - Helper to check the riscv image header. ++ * ++ * Returns non-zero if the image was built as big endian. ++ */ ++ ++static inline int riscv_header_check_endiannes(const struct riscv_image_header *h) ++{ ++ if (!h) ++ return 0; ++ ++ return (le64toh(h->flags) & riscv_image_flag_be) >> 0; ++} ++ ++ ++ ++static inline uint64_t riscv_header_text_offset(const struct riscv_image_header *h) ++{ ++ if (!h) ++ return 0; ++ ++ return le64toh(h->text_offset); ++} ++ ++static inline uint64_t riscv_header_image_size(const struct riscv_image_header *h) ++{ ++ if (!h) ++ return 0; ++ ++ return le64toh(h->image_size); ++} ++ ++#endif +diff --git a/kexec/arch/riscv/include/arch/options.h b/kexec/arch/riscv/include/arch/options.h +new file mode 100644 +index 0000000..7c24184 +--- /dev/null ++++ b/kexec/arch/riscv/include/arch/options.h +@@ -0,0 +1,43 @@ ++#ifndef KEXEC_ARCH_RISCV_OPTIONS_H ++#define KEXEC_ARCH_RISCV_OPTIONS_H ++ ++#define OPT_APPEND ((OPT_MAX)+0) ++#define OPT_DTB ((OPT_MAX)+1) ++#define OPT_INITRD ((OPT_MAX)+2) ++#define OPT_CMDLINE ((OPT_MAX)+3) ++#define OPT_REUSE_CMDLINE ((OPT_MAX)+4) ++#define OPT_ARCH_MAX ((OPT_MAX)+5) ++ ++/* Options relevant to the architecture (excluding loader-specific ones), ++ * in this case none: ++ */ ++#define KEXEC_ARCH_OPTIONS \ ++ KEXEC_OPTIONS \ ++ { "append", 1, 0, OPT_APPEND}, \ ++ { "dtb", 1, 0, OPT_DTB }, \ ++ { "initrd", 1, 0, OPT_INITRD }, \ ++ { "command-line", 1, 0, OPT_CMDLINE}, \ ++ { "reuse-cmdline", 0, NULL, OPT_REUSE_CMDLINE }, \ ++ ++ ++#define KEXEC_ARCH_OPT_STR KEXEC_OPT_STR "" ++ ++/* The following two #defines list ALL of the options added by all of the ++ * architecture's loaders. ++ * o main() uses this complete list to scan for its options, ignoring ++ * arch-specific/loader-specific ones. ++ * o Then, arch_process_options() uses this complete list to scan for its ++ * options, ignoring general/loader-specific ones. ++ * o Then, the file_type[n].load re-scans for options, using ++ * KEXEC_ARCH_OPTIONS plus its loader-specific options subset. ++ * Any unrecognised options cause an error here. ++ * ++ * This is done so that main()'s/arch_process_options()'s getopt_long() calls ++ * don't choose a kernel filename from random arguments to options they don't ++ * recognise -- as they now recognise (if not act upon) all possible options. ++ */ ++#define KEXEC_ALL_OPTIONS KEXEC_ARCH_OPTIONS ++ ++#define KEXEC_ALL_OPT_STR KEXEC_ARCH_OPT_STR ++ ++#endif /* KEXEC_ARCH_RISCV_OPTIONS_H */ +diff --git a/kexec/arch/riscv/iomem.h b/kexec/arch/riscv/iomem.h +new file mode 100644 +index 0000000..7671e26 +--- /dev/null ++++ b/kexec/arch/riscv/iomem.h +@@ -0,0 +1,10 @@ ++#ifndef IOMEM_H ++#define IOMEM_H ++ ++#define SYSTEM_RAM "System RAM\n" ++#define KERNEL_CODE "Kernel code\n" ++#define KERNEL_DATA "Kernel data\n" ++#define CRASH_KERNEL "Crash kernel\n" ++#define IOMEM_RESERVED "Reserved\n" ++ ++#endif +diff --git a/kexec/arch/riscv/kexec-elf-riscv.c b/kexec/arch/riscv/kexec-elf-riscv.c +new file mode 100644 +index 0000000..434873c +--- /dev/null ++++ b/kexec/arch/riscv/kexec-elf-riscv.c +@@ -0,0 +1,184 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2019 FORTH-ICS/CARV ++ * Nick Kossifidis ++ */ ++ ++#include "kexec.h" ++#include "dt-ops.h" /* For dtb_set/clear_initrd() */ ++#include /* For ELF header handling */ ++#include /* For EFBIG/EINVAL */ ++#include /* For getpagesize() */ ++#include "kexec-syscall.h" /* For KEXEC_ON_CRASH */ ++#include "kexec-riscv.h" ++ ++/**************\ ++* ENTRY POINTS * ++\**************/ ++ ++int elf_riscv_probe(const char *buf, off_t len) ++{ ++ struct mem_ehdr ehdr = {0}; ++ int ret = 0; ++ ++ ret = build_elf_exec_info(buf, len, &ehdr, 0); ++ if (ret < 0) ++ goto cleanup; ++ ++ if (ehdr.e_machine != EM_RISCV) { ++ fprintf(stderr, "Not for this architecture.\n"); ++ ret = -EINVAL; ++ goto cleanup; ++ } ++ ++ ret = 0; ++ ++ cleanup: ++ free_elf_info(&ehdr); ++ return ret; ++} ++ ++void elf_riscv_usage(void) ++{ ++} ++ ++ ++int elf_riscv_load(int argc, char **argv, const char *buf, off_t len, ++ struct kexec_info *info) ++{ ++ struct mem_ehdr ehdr = {0}; ++ struct mem_phdr *phdr = NULL; ++ off_t new_base_addr = 0; ++ off_t kernel_size = 0; ++ off_t page_size = getpagesize(); ++ off_t max_addr = 0; ++ off_t old_base_addr = 0; ++ off_t old_start_addr = 0; ++ int i = 0; ++ int ret = 0; ++ ++ if (info->file_mode) { ++ return prepare_kexec_file_options(info); ++ } ++ ++ /* Parse the ELF file */ ++ ret = build_elf_exec_info(buf, len, &ehdr, 0); ++ if (ret < 0) { ++ fprintf(stderr, "ELF exec parse failed\n"); ++ return -EINVAL; ++ } ++ ++ max_addr = elf_max_addr(&ehdr); ++ old_base_addr = max_addr; ++ old_start_addr = max_addr; ++ ++ /* ++ * Get the memory footprint, base physical ++ * and start address of the ELF image ++ */ ++ for (i = 0; i < ehdr.e_phnum; i++) { ++ phdr = &ehdr.e_phdr[i]; ++ if (phdr->p_type != PT_LOAD) ++ continue; ++ ++ /* ++ * Note: According to ELF spec the loadable regions ++ * are sorted on p_vaddr, not p_paddr. ++ */ ++ if (old_base_addr > phdr->p_paddr) ++ old_base_addr = phdr->p_paddr; ++ ++ if (phdr->p_vaddr == ehdr.e_entry || ++ phdr->p_paddr == ehdr.e_entry) ++ old_start_addr = phdr->p_paddr; ++ ++ kernel_size += _ALIGN_UP(phdr->p_memsz, page_size); ++ } ++ ++ if (old_base_addr == max_addr || kernel_size == 0) { ++ fprintf(stderr, "No loadable segments present on the " ++ "provided ELF image\n"); ++ return -EINVAL; ++ } ++ ++ if (old_start_addr == max_addr) { ++ fprintf(stderr, "Could not find the entry point address of " ++ "provided ELF image\n"); ++ return -EINVAL; ++ } ++ ++ dbgprintf("Got ELF with total memsz %luKB\n" ++ "Base paddr: 0x%lX, start_addr: 0x%lX\n", ++ kernel_size / 1024, old_base_addr, old_start_addr); ++ ++ /* Get a continuous physical region that can hold the kernel */ ++ ret = riscv_find_pbase(info, &new_base_addr, kernel_size, KERNEL_ALIGN); ++ if (ret < 0) { ++ fprintf(stderr, "Could not find a memory region for the " ++ "provided ELF image\n"); ++ return ret; ++ } ++ ++ dbgprintf("New base paddr for the ELF: 0x%lX\n", new_base_addr); ++ ++ /* Re-set the base physical address of the ELF */ ++ for (i = 0; i < ehdr.e_phnum; i++) { ++ phdr = &ehdr.e_phdr[i]; ++ if (phdr->p_type != PT_LOAD) ++ continue; ++ ++ phdr->p_paddr -= old_base_addr; ++ phdr->p_paddr += new_base_addr; ++ } ++ ++ /* Re-set the entry point address */ ++ ehdr.e_entry = (old_start_addr - old_base_addr) + new_base_addr; ++ info->entry = (void *) ehdr.e_entry; ++ dbgprintf("New entry point for the ELF: 0x%llX\n", ehdr.e_entry); ++ ++ ++ /* Load the ELF executable */ ++ ret = elf_exec_load(&ehdr, info); ++ if (ret < 0) { ++ fprintf(stderr, "ELF exec load failed\n"); ++ return ret; ++ } ++ ++ ret = load_extra_segments(info, new_base_addr, ++ kernel_size, max_addr); ++ return ret; ++} ++ ++ ++/*******\ ++* STUBS * ++\*******/ ++ ++int machine_verify_elf_rel(struct mem_ehdr *ehdr) ++{ ++ if (ehdr->ei_data != ELFDATA2LSB) ++ return 0; ++#if __riscv_xlen == 64 ++ if (ehdr->ei_class != ELFCLASS64) ++#else ++ if (ehdr->ei_class != ELFCLASS32) ++#endif ++ return 0; ++ if (ehdr->e_machine != EM_RISCV) ++ return 0; ++ return 1; ++} ++ ++void machine_apply_elf_rel(struct mem_ehdr *UNUSED(ehdr), ++ struct mem_sym *UNUSED(sym), ++ unsigned long r_type, ++ void *UNUSED(location), ++ unsigned long UNUSED(address), ++ unsigned long UNUSED(value)) ++{ ++ switch (r_type) { ++ default: ++ die("Unknown rela relocation: %lu\n", r_type); ++ break; ++ } ++} +diff --git a/kexec/arch/riscv/kexec-image-riscv.c b/kexec/arch/riscv/kexec-image-riscv.c +new file mode 100644 +index 0000000..6ae7e57 +--- /dev/null ++++ b/kexec/arch/riscv/kexec-image-riscv.c +@@ -0,0 +1,95 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * RISC-V kexec binary image support. ++ * ++ * Author: Song Shuai ++ */ ++ ++#define _GNU_SOURCE ++ ++#include ++#include ++#include ++#include "image-header.h" ++#include "kexec.h" ++#include "kexec-riscv.h" ++#include "kexec-syscall.h" ++#include "arch/options.h" ++ ++int image_riscv_probe(const char *kernel_buf, off_t kernel_size) ++{ ++ const struct riscv_image_header *h; ++ ++ if (kernel_size < sizeof(struct riscv_image_header)) { ++ dbgprintf("%s: No riscv image header.\n", __func__); ++ return -1; ++ } ++ ++ h = (const struct riscv_image_header *)(kernel_buf); ++ ++ if (!riscv_header_check_magic(h)) { ++ dbgprintf("%s: Bad riscv image header.\n", __func__); ++ return -1; ++ } ++ ++ return 0; ++} ++ ++int image_riscv_load(int argc, char **argv, const char *kernel_buf, ++ off_t kernel_size, struct kexec_info *info) ++{ ++ const struct riscv_image_header *h; ++ unsigned long text_offset, image_size; ++ off_t new_base_addr = 0; ++ ++ int ret; ++ ++ if (info->file_mode) { ++ return prepare_kexec_file_options(info); ++ } ++ ++ h = (const struct riscv_image_header *)(kernel_buf); ++ ++ /* Check header */ ++ if (!h->image_size){ ++ dbgprintf("Kernel image size is NULL\n"); ++ ret = EFAILED; ++ goto exit; ++ } ++ ++ if(riscv_header_check_endiannes(h)){ ++ dbgprintf("Kernel image was built as big endian\n"); ++ ret = EFAILED; ++ goto exit; ++ } ++ ++ text_offset = riscv_header_text_offset(h); ++ image_size = riscv_header_image_size(h); ++ ++ /* Setup the entry and segments */ ++ ++ ret = riscv_find_pbase(info, &new_base_addr, image_size, text_offset); ++ if (ret < 0) { ++ fprintf(stderr, "Could not find a memory region for the " ++ "provided Image\n"); ++ goto exit; ++ } ++ ++ info->entry = (void *) new_base_addr; ++ dbgprintf("Entry point for the Image: 0x%lX\n", new_base_addr); ++ ++ add_segment(info, kernel_buf, kernel_size, new_base_addr, image_size); ++ ++ ret = load_extra_segments(info, text_offset, image_size, ULONG_MAX); ++exit: ++ if (ret) ++ fprintf(stderr, "kexec: load failed.\n"); ++ return ret; ++} ++ ++void image_riscv_usage(void) ++{ ++ printf( ++" An RISC-V binary image, uncompressed, little endian.\n" ++" Typically an Image file.\n\n"); ++} +diff --git a/kexec/arch/riscv/kexec-riscv.c b/kexec/arch/riscv/kexec-riscv.c +new file mode 100644 +index 0000000..f5e0262 +--- /dev/null ++++ b/kexec/arch/riscv/kexec-riscv.c +@@ -0,0 +1,478 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2019 FORTH-ICS/CARV ++ * Nick Kossifidis ++ */ ++ ++#include "kexec-syscall.h" /* For KEXEC_ARCH_RISCV */ ++#include "kexec.h" /* For OPT_MAX and concat_cmdline() */ ++#include "mem_regions.h" /* For mem_regions_sort() */ ++#include "dt-ops.h" /* For dtb_set_bootargs() */ ++#include /* For KEXEC_ARCH_OPTIONS */ ++#include /* For struct option */ ++#include /* For stat() and struct stat */ ++#include /* For free() */ ++#include /* For EINVAL */ ++#include /* For DeviceTree handling */ ++#include "kexec-riscv.h" ++#include "iomem.h" ++#include ++#include ++#include ++#ifndef _O_BINARY ++#define _O_BINARY 0 ++#endif ++ ++ ++ ++const struct arch_map_entry arches[] = { ++ { "riscv32", KEXEC_ARCH_RISCV }, ++ { "riscv64", KEXEC_ARCH_RISCV }, ++ { NULL, 0 }, ++}; ++ ++ ++struct file_type file_type[] = { ++ {"elf-riscv", elf_riscv_probe, elf_riscv_load, elf_riscv_usage}, ++ {"image-riscv", image_riscv_probe, image_riscv_load, image_riscv_usage}, ++}; ++int file_types = sizeof(file_type) / sizeof(file_type[0]); ++ ++static const char riscv_opts_usage[] = ++" --append=STRING Append STRING to the kernel command line.\n" ++" --dtb=FILE Use FILE as the device tree blob.\n" ++" --initrd=FILE Use FILE as the kernel initial ramdisk.\n" ++" --command-line=STRING Use STRING as the kernel's command line.\n" ++" --reuse-cmdline Use kernel command line from running system.\n"; ++ ++static struct riscv_opts arch_options = {0}; ++static struct fdt_image provided_fdt = {0}; ++ ++/****************\ ++* COMMON HELPERS * ++\****************/ ++ ++/* ++ * Go through the available physical memory regions and ++ * find one that can hold an image of the specified size ++ * and start address should be aligned up with `align`. ++ * Note: This is called after get_memory_ranges so ++ * info->memory_range[] should be populated. Also note that ++ * memory ranges are sorted, so we'll return the first region ++ * that's big enough for holding the image. ++ */ ++int riscv_find_pbase(struct kexec_info *info, off_t *addr, ++ off_t size, off_t align) ++{ ++ int i = 0; ++ off_t start = 0; ++ off_t end = 0; ++ int ret = 0; ++ ++ /* ++ * If this image is for a crash kernel, use the region ++ * the primary kernel has already reserved for us. ++ */ ++ if (info->kexec_flags & KEXEC_ON_CRASH) { ++ ret = get_crash_kernel_load_range((uint64_t *) &start, ++ (uint64_t *) &end); ++ if (!ret) { ++ start = _ALIGN_UP(start, align); ++ ++ if (end > start && ((end - start) >= size)) { ++ *addr = start; ++ return 0; ++ } ++ ++ return -EFBIG; ++ } else ++ return ENOCRASHKERNEL; ++ } ++ ++ for (i = 0; i < info->memory_ranges; i++) { ++ if (info->memory_range[i].type != RANGE_RAM) ++ continue; ++ ++ start = info->memory_range[i].start; ++ end = info->memory_range[i].end; ++ ++ start = _ALIGN_UP(start, align); ++ ++ if (end > start && ((end - start) >= size)) { ++ *addr = start; ++ return 0; ++ } ++ } ++ ++ return -EFBIG; ++} ++ ++int load_extra_segments(struct kexec_info *info, uint64_t kernel_base, ++ uint64_t kernel_size, uint64_t max_addr) ++{ ++ struct fdt_image *fdt = arch_options.fdt; ++ char *initrd_buf = NULL; ++ off_t initrd_size = 0; ++ uint64_t initrd_base = 0; ++ uint64_t start = 0; ++ uint64_t end = 0; ++ uint64_t min_usable = kernel_base + kernel_size; ++ uint64_t max_usable = max_addr; ++ int ret = 0; ++ ++ /* Prepare the device tree */ ++ if (info->kexec_flags & KEXEC_ON_CRASH) { ++ ret = load_elfcorehdr(info); ++ if (ret) { ++ fprintf(stderr, "Couldn't create elfcorehdr\n"); ++ return ret; ++ } ++ ++ ret = dtb_add_range_property(&fdt->buf, &fdt->size, ++ elfcorehdr_mem.start, elfcorehdr_mem.end, ++ "chosen", "linux,elfcorehdr"); ++ if (ret) { ++ fprintf(stderr, "Couldn't add elfcorehdr to fdt\n"); ++ return ret; ++ } ++ ++ ret = get_crash_kernel_load_range(&start, &end); ++ if (ret) { ++ fprintf(stderr, "Couldn't get crashkenel region\n"); ++ return ret; ++ } ++ ++ ret = dtb_add_range_property(&fdt->buf, &fdt->size, start, end, ++ "chosen", "linux,usable-memory-range"); ++ if (ret) { ++ fprintf(stderr, "Couldn't add usable-memory-range to fdt\n"); ++ return ret; ++ } ++ ++ max_usable = end; ++ } else { ++ /* ++ * Make sure we remove elfcorehdr and usable-memory-range ++ * when switching from crash kernel to a normal one. ++ */ ++ dtb_delete_property(fdt->buf, "chosen", "linux,elfcorehdr"); ++ dtb_delete_property(fdt->buf, "chosen", "linux,usable-memory-range"); ++ } ++ ++ /* Do we need to include an initrd image ? */ ++ if (!arch_options.initrd_path && !arch_options.initrd_end) ++ dtb_clear_initrd(&fdt->buf, &fdt->size); ++ else if (arch_options.initrd_path) { ++ if (arch_options.initrd_end) ++ fprintf(stderr, "Warning: An initrd image was provided" ++ ", will ignore reuseinitrd\n"); ++ ++ initrd_buf = slurp_file(arch_options.initrd_path, ++ &initrd_size); ++ if (!initrd_buf) { ++ fprintf(stderr, "Couldn't read provided initrd\n"); ++ return -EINVAL; ++ } ++ ++ initrd_base = add_buffer_phys_virt(info, initrd_buf, ++ initrd_size, ++ initrd_size, 0, ++ min_usable, ++ max_usable, 1, 0); ++ ++ dtb_set_initrd(&fdt->buf, &fdt->size, initrd_base, ++ initrd_base + initrd_size); ++ ++ dbgprintf("Base addr for initrd image: 0x%lX\n", initrd_base); ++ min_usable = initrd_base; ++ } ++ ++ /* Add device tree */ ++ add_buffer_phys_virt(info, fdt->buf, fdt->size, fdt->size, 0, ++ min_usable, max_usable, -1, 0); ++ ++ return 0; ++} ++ ++ ++/**************\ ++* ENTRY POINTS * ++\**************/ ++ ++void arch_usage(void) ++{ ++ printf(riscv_opts_usage); ++} ++ ++int prepare_kexec_file_options(struct kexec_info *info) ++{ ++ int fd; ++ ssize_t result; ++ struct stat stats; ++ ++ if (arch_options.cmdline) { ++ info->command_line = (char *)arch_options.cmdline; ++ info->command_line_len = strlen(info->command_line) + 1; ++ } ++ ++ if (!arch_options.initrd_path) { ++ info->initrd_fd = -1; ++ return 0; ++ } ++ ++ fd = open(arch_options.initrd_path, O_RDONLY | _O_BINARY); ++ if (fd < 0) { ++ fprintf(stderr, "Cannot open `%s': %s\n", arch_options.initrd_path, ++ strerror(errno)); ++ return -EINVAL; ++ } ++ result = fstat(fd, &stats); ++ if (result < 0) { ++ close(fd); ++ fprintf(stderr, "Cannot stat: %s: %s\n", arch_options.initrd_path, ++ strerror(errno)); ++ return -EINVAL; ++ } ++ info->initrd_fd = fd; ++ return 0; ++} ++ ++int arch_process_options(int argc, char **argv) ++{ ++ static const struct option options[] = { ++ KEXEC_ARCH_OPTIONS ++ { 0 }, ++ }; ++ static const char short_options[] = KEXEC_ARCH_OPT_STR; ++ struct stat st = {0}; ++ char *append = NULL; ++ char *cmdline = NULL; ++ void *tmp = NULL; ++ off_t tmp_size = 0; ++ int opt = 0; ++ int ret = 0; ++ ++ while ((opt = getopt_long(argc, argv, short_options, ++ options, 0)) != -1) { ++ switch (opt) { ++ case OPT_APPEND: ++ append = optarg; ++ break; ++ case OPT_CMDLINE: ++ if (cmdline) ++ fprintf(stderr, ++ "Warning: Kernel's cmdline " ++ "set twice !\n"); ++ cmdline = optarg; ++ break; ++ case OPT_REUSE_CMDLINE: ++ if (cmdline) ++ fprintf(stderr, ++ "Warning: Kernel's cmdline " ++ "set twice !\n"); ++ cmdline = get_command_line(); ++ break; ++ case OPT_DTB: ++ ret = stat(optarg, &st); ++ if (ret) { ++ fprintf(stderr, ++ "Could not find the provided dtb !\n"); ++ return -EINVAL; ++ } ++ arch_options.fdt_path = optarg; ++ break; ++ case OPT_INITRD: ++ ret = stat(optarg, &st); ++ if (ret) { ++ fprintf(stderr, ++ "Could not find the provided " ++ "initrd image !\n"); ++ return -EINVAL; ++ } ++ arch_options.initrd_path = optarg; ++ break; ++ default: ++ break; ++ } ++ } ++ ++ /* Handle Kernel's command line */ ++ if (append && !cmdline) ++ fprintf(stderr, "Warning: No cmdline provided, " ++ "using append string as cmdline\n"); ++ if (!append && !cmdline) ++ fprintf(stderr, "Warning: No cmdline or append string " ++ "provided\n"); ++ ++ if (append || cmdline) ++ /* ++ * Note that this also handles the case where "cmdline" ++ * or "append" is NULL. ++ */ ++ arch_options.cmdline = concat_cmdline(cmdline, append); ++ ++ /* Handle FDT image */ ++ if (!arch_options.fdt_path) { ++ ret = stat("/sys/firmware/fdt", &st); ++ if (ret) { ++ fprintf(stderr, "No dtb provided and " ++ "/sys/firmware/fdt is not present\n"); ++ return -EINVAL; ++ } ++ fprintf(stderr, "Warning: No dtb provided, " ++ "using /sys/firmware/fdt\n"); ++ arch_options.fdt_path = "/sys/firmware/fdt"; ++ } ++ ++ tmp = slurp_file(arch_options.fdt_path, &tmp_size); ++ if (!tmp) { ++ fprintf(stderr, "Couldn't read provided fdt\n"); ++ return -EINVAL; ++ } ++ ++ ret = fdt_check_header(tmp); ++ if (ret) { ++ fprintf(stderr, "Got an ivalid fdt image !\n"); ++ free(tmp); ++ return -EINVAL; ++ } ++ provided_fdt.buf = tmp; ++ provided_fdt.size = tmp_size; ++ ++ if (arch_options.cmdline) { ++ ret = dtb_set_bootargs(&provided_fdt.buf, &provided_fdt.size, ++ arch_options.cmdline); ++ if (ret < 0) { ++ fprintf(stderr, "Could not set bootargs on " ++ "the fdt image\n"); ++ return ret; ++ } ++ } ++ ++ arch_options.fdt = &provided_fdt; ++ ++ return 0; ++} ++ ++/* ++ * This one is called after arch_process_options so we already ++ * have an fdt image in place. ++ */ ++void arch_reuse_initrd(void) ++{ ++ const uint32_t *prop32 = NULL; ++ uint32_t addr_cells = 0; ++ const void *prop = 0; ++ int prop_size = 0; ++ uint64_t initrd_start = 0; ++ uint64_t initrd_end = 0; ++ int chosen_offset = 0; ++ struct fdt_image *fdt = &provided_fdt; ++ ++ chosen_offset = fdt_subnode_offset(fdt->buf, 0, "chosen"); ++ if (chosen_offset < 0) { ++ fprintf(stderr, "No /chosen node found on fdt image " ++ "unable to reuse initrd\n"); ++ return; ++ } ++ ++ prop32 = fdt_getprop(fdt->buf, 0, "#address-cells", NULL); ++ if (!prop32) { ++ fprintf(stderr, "No #address-cells property on root node\n"); ++ return; ++ } ++ addr_cells = be32_to_cpu(*prop32); ++ ++ prop = fdt_getprop(fdt->buf, chosen_offset, ++ "linux,initrd-start", &prop_size); ++ if (!prop) { ++ fprintf(stderr, "Could not get linux,initrd-start\n"); ++ return; ++ } ++ dtb_extract_int_property(&initrd_start, prop, addr_cells); ++ ++ prop = fdt_getprop(fdt->buf, chosen_offset, ++ "linux,initrd-end", &prop_size); ++ if (!prop) { ++ fprintf(stderr, "Could not get linux,initrd-end\n"); ++ return; ++ } ++ dtb_extract_int_property(&initrd_end, prop, addr_cells); ++ ++ arch_options.initrd_start = initrd_start; ++ arch_options.initrd_end = initrd_end; ++ dbgprintf("initrd_start: 0x%lX, initrd_end: 0x%lX\n", ++ initrd_start, initrd_end); ++ ++} ++ ++int get_memory_ranges(struct memory_range **range, int *num_ranges, ++ unsigned long kexec_flags) ++{ ++ struct memory_ranges sysmem_ranges = {0}; ++ int ret = 0; ++ ++ const char *iomem = proc_iomem(); ++ char line[MAX_LINE], *str; ++ FILE *fp; ++ unsigned long long start, end; ++ int consumed, count; ++ ++ fp = fopen(iomem, "r"); ++ if (!fp) { ++ fprintf(stderr, "Cannot open %s: %s\n", iomem, strerror(errno)); ++ return -1; ++ } ++ ++ while (fgets(line, sizeof(line), fp) != 0) { ++ count = sscanf(line, "%llx-%llx : %n", &start, &end, &consumed); ++ if (count != 2) ++ continue; ++ str = line + consumed; ++ ++ if (!strncmp(str, SYSTEM_RAM, strlen(SYSTEM_RAM))){ ++ ret = mem_regions_alloc_and_add(&sysmem_ranges, ++ start, end - start + 1, RANGE_RAM); ++ if (ret) { ++ fprintf(stderr, ++ "Cannot allocate memory for ranges\n"); ++ fclose(fp); ++ return -ENOMEM; ++ } ++ ++ } else if (!strncmp(str, IOMEM_RESERVED, strlen(IOMEM_RESERVED))){ ++ ret = mem_regions_alloc_and_add(&sysmem_ranges, ++ start, end - start + 1, RANGE_RESERVED); ++ if (ret) { ++ fprintf(stderr, ++ "Cannot allocate memory for ranges\n"); ++ fclose(fp); ++ return -ENOMEM; ++ } ++ } else ++ continue; ++ } ++ ++ fclose(fp); ++ ++ *range = sysmem_ranges.ranges; ++ *num_ranges = sysmem_ranges.size; ++ ++ dbgprint_mem_range("System RAM ranges;", ++ sysmem_ranges.ranges, sysmem_ranges.size); ++ ++ return 0; ++} ++ ++/*******\ ++* STUBS * ++\*******/ ++ ++int arch_compat_trampoline(struct kexec_info *UNUSED(info)) ++{ ++ return 0; ++} ++ ++void arch_update_purgatory(struct kexec_info *UNUSED(info)) ++{ ++} +diff --git a/kexec/arch/riscv/kexec-riscv.h b/kexec/arch/riscv/kexec-riscv.h +new file mode 100644 +index 0000000..cfb0377 +--- /dev/null ++++ b/kexec/arch/riscv/kexec-riscv.h +@@ -0,0 +1,53 @@ ++/* SPDX-License-Identifier: GPL-2.0 */ ++/* ++ * Copyright (C) 2019 FORTH-ICS/CARV ++ * Nick Kossifidis ++ */ ++ ++/* ++ * Kernel should be aligned to the nearest ++ * hugepage (2MB for RV64, 4MB for RV32). ++ */ ++ ++#if __riscv_xlen == 64 ++#define KERNEL_ALIGN 0x200000 ++#else ++#define KERNEL_ALIGN 0x400000 ++#endif ++ ++struct fdt_image { ++ char *buf; ++ off_t size; ++}; ++ ++struct riscv_opts { ++ char *cmdline; ++ char *fdt_path; ++ char *initrd_path; ++ uint64_t initrd_start; ++ uint64_t initrd_end; ++ struct fdt_image *fdt; ++}; ++ ++/* crashdump-riscv.c */ ++extern struct memory_range elfcorehdr_mem; ++int load_elfcorehdr(struct kexec_info *info); ++ ++/* kexec-riscv.c */ ++int prepare_kexec_file_options(struct kexec_info *info); ++int load_extra_segments(struct kexec_info *info, uint64_t kernel_base, ++ uint64_t kernel_size, uint64_t max_addr); ++int riscv_find_pbase(struct kexec_info *info, off_t *addr, ++ off_t size, off_t align); ++ ++/* kexec-elf-riscv.c */ ++int elf_riscv_probe(const char *buf, off_t len); ++void elf_riscv_usage(void); ++int elf_riscv_load(int argc, char **argv, const char *buf, off_t len, ++ struct kexec_info *info); ++ ++/* kexec-image-riscv.c */ ++int image_riscv_probe(const char *buf, off_t len); ++void image_riscv_usage(void); ++int image_riscv_load(int argc, char **argv, const char *buf, off_t len, ++ struct kexec_info *info); +diff --git a/kexec/dt-ops.c b/kexec/dt-ops.c +index 0a96b75..3e285ab 100644 +--- a/kexec/dt-ops.c ++++ b/kexec/dt-ops.c +@@ -4,9 +4,11 @@ + #include + #include + #include ++#include + + #include "kexec.h" + #include "dt-ops.h" ++#include "mem_regions.h" + + static const char n_chosen[] = "chosen"; + +@@ -95,7 +97,7 @@ int dtb_set_property(char **dtb, off_t *dtb_size, const char *node, + + strcpy(new_node, "/"); + strcat(new_node, node); +- ++ + nodeoffset = fdt_path_offset(new_dtb, new_node); + + if (nodeoffset == -FDT_ERR_NOTFOUND) { +@@ -174,3 +176,441 @@ int dtb_delete_property(char *dtb, const char *node, const char *prop) + free(new_node); + return result; + } ++ ++static int dtb_get_num_cells(char *dtb, int nodeoffset, uint32_t *addr_cells, ++ uint32_t *size_cells, bool recursive) ++{ ++ const uint32_t *prop32 = NULL; ++ int curr_offset = nodeoffset; ++ int prop_len = 0; ++ *addr_cells = 0; ++ *size_cells = 0; ++ ++ do { ++ prop32 = fdt_getprop(dtb, curr_offset, "#address-cells", &prop_len); ++ curr_offset = fdt_parent_offset(dtb, curr_offset); ++ } while (!prop32 && prop_len == -FDT_ERR_NOTFOUND && recursive); ++ ++ if (!prop32) { ++ dbgprintf("Could not get #address-cells property for %s (%s)\n", ++ fdt_get_name(dtb, nodeoffset, NULL), fdt_strerror(nodeoffset)); ++ return -EINVAL; ++ } ++ *addr_cells = fdt32_to_cpu(*prop32); ++ ++ curr_offset = nodeoffset; ++ do { ++ prop32 = fdt_getprop(dtb, curr_offset, "#size-cells", &prop_len); ++ curr_offset = fdt_parent_offset(dtb, curr_offset); ++ } while (!prop32 && prop_len == -FDT_ERR_NOTFOUND && recursive); ++ ++ if (!prop32) { ++ dbgprintf("Could not get #size-cells property for %s (%s)\n", ++ fdt_get_name(dtb, nodeoffset, NULL), fdt_strerror(nodeoffset)); ++ return -EINVAL; ++ } ++ *size_cells = fdt32_to_cpu(*prop32); ++ ++ dbgprintf("%s: #address-cells:%d #size-cells:%d\n", ++ fdt_get_name(dtb, nodeoffset, NULL), *addr_cells, *size_cells); ++ ++ return 0; ++} ++ ++void dtb_extract_int_property(uint64_t *val, const void *buf, uint32_t cells) ++{ ++ const uint32_t *prop32 = NULL; ++ const uint64_t *prop64 = NULL; ++ ++ if (cells == 1) { ++ prop32 = (const uint32_t *) buf; ++ *val = (uint64_t) be32_to_cpu(*prop32); ++ } else { ++ /* Skip any leading cells */ ++ prop64 = (const uint64_t *) (uint32_t *)buf + cells - 2; ++ *val = (uint64_t) be64_to_cpu(*prop64); ++ } ++} ++ ++void dtb_fill_int_property(void *buf, uint64_t val, uint32_t cells) ++{ ++ uint32_t prop32 = 0; ++ uint64_t prop64 = 0; ++ ++ if (cells == 1) { ++ prop32 = cpu_to_fdt32((uint32_t) val); ++ memcpy(buf, &prop32, sizeof(uint32_t)); ++ } else { ++ prop64 = cpu_to_fdt64(val); ++ /* Skip any leading cells */ ++ memcpy((uint64_t *)(uint32_t *)buf + cells - 2, ++ &prop64, sizeof(uint64_t)); ++ } ++} ++ ++int dtb_add_range_property(char **dtb, off_t *dtb_size, uint64_t start, uint64_t end, ++ const char *parent, const char *name) ++{ ++ uint32_t addr_cells = 0; ++ uint32_t size_cells = 0; ++ char *nodepath = NULL; ++ void *prop = NULL; ++ int nodeoffset = 0; ++ int prop_size = 0; ++ int ret = 0; ++ ++ nodepath = malloc(strlen("/") + strlen(parent) + 1); ++ if (!nodepath) { ++ dbgprintf("%s: malloc failed\n", __func__); ++ return -ENOMEM; ++ } ++ ++ strcpy(nodepath, "/"); ++ strcat(nodepath, parent); ++ ++ nodeoffset = fdt_path_offset(*dtb, nodepath); ++ if (nodeoffset < 0) { ++ dbgprintf("%s: fdt_path_offset(%s) failed: %s\n", __func__, ++ nodepath, fdt_strerror(nodeoffset)); ++ free(nodepath); ++ return nodeoffset; ++ } ++ free(nodepath); ++ ++ ret = dtb_get_num_cells(*dtb, nodeoffset, &addr_cells, &size_cells, true); ++ if (ret < 0) ++ return ret; ++ ++ /* Can the range fit with the given address/size cells ? */ ++ if ((addr_cells == 1) && (start >= (1ULL << 32))) ++ return -EINVAL; ++ ++ if ((size_cells == 1) && ((end - start + 1) >= (1ULL << 32))) ++ return -EINVAL; ++ ++ prop_size = sizeof(uint32_t) * (addr_cells + size_cells); ++ prop = malloc(prop_size); ++ ++ dtb_fill_int_property(prop, start, addr_cells); ++ dtb_fill_int_property((void *)((uint32_t *)prop + addr_cells), ++ end - start + 1, size_cells); ++ ++ /* Add by node path name */ ++ return dtb_set_property(dtb, dtb_size, parent, name, prop, prop_size); ++} ++ ++/************************\ ++* MEMORY RANGES HANDLING * ++\************************/ ++ ++static int dtb_add_memory_range(struct memory_ranges *mem_ranges, uint64_t start, ++ uint64_t end, unsigned type) ++{ ++ struct memory_range this_region = {0}; ++ struct memory_range *ranges = mem_ranges->ranges; ++ int i = 0; ++ int ret = 0; ++ ++ if (start == end) { ++ dbgprintf("Ignoring empty region\n"); ++ return -EINVAL; ++ } ++ ++ /* Check if we are adding an existing region */ ++ for (i = 0; i < mem_ranges->size; i++) { ++ if (start == ranges[i].start && end == ranges[i].end) { ++ dbgprintf("Duplicate: 0x%lx - 0x%lx\n", start, end); ++ ++ if (type == ranges[i].type) ++ return 0; ++ else if (type == RANGE_RESERVED) { ++ ranges[i].type = RANGE_RESERVED; ++ return 0; ++ } ++ ++ dbgprintf("Conflicting types for region: 0x%lx - 0x%lx\n", ++ start, end); ++ return -EINVAL; ++ } ++ } ++ ++ /* ++ * Reserved regions may be part of an existing /memory ++ * region and shouldn't overlap according to spec, so ++ * since we add /memory regions first, we can exclude ++ * reserved regions here from the existing /memory regions ++ * included in ranges[], so that we don't have the same ++ * region twice. ++ */ ++ if (type == RANGE_RESERVED) { ++ this_region.start = start; ++ this_region.end = end - 1; ++ this_region.type = type; ++ ret = mem_regions_exclude(mem_ranges, &this_region); ++ if (ret) ++ return ret; ++ } ++ ++ ret = mem_regions_alloc_and_add(mem_ranges, start, ++ end - start, type); ++ ++ return ret; ++} ++ ++static int dtb_add_memory_region(char *dtb, int nodeoffset, ++ struct memory_ranges *mem_ranges, int type) ++{ ++ uint32_t root_addr_cells = 0; ++ uint32_t root_size_cells = 0; ++ uint64_t addr = 0; ++ uint64_t size = 0; ++ const char *reg = NULL; ++ int prop_size = 0; ++ int offset = 0; ++ int entry_size = 0; ++ int num_entries = 0; ++ int ret = 0; ++ ++ /* ++ * Get address-cells and size-cells properties (according to ++ * binding spec these are the same as in the root node) ++ */ ++ ret = dtb_get_num_cells(dtb, 0, &root_addr_cells, &root_size_cells, false); ++ if (ret < 0) { ++ dbgprintf("No address/size cells on root node !\n"); ++ return ret; ++ } ++ ++ /* ++ * Parse the reg array, acording to device tree spec it includes ++ * an arbitary number of
pairs ++ */ ++ entry_size = (root_addr_cells + root_size_cells) * sizeof(uint32_t); ++ reg = fdt_getprop(dtb, nodeoffset, "reg", &prop_size); ++ if (!reg) { ++ dbgprintf("Warning: Malformed memory region with no reg property (%s) !\n", ++ fdt_get_name(dtb, nodeoffset, NULL)); ++ return -EINVAL; ++ } ++ ++ num_entries = prop_size / entry_size; ++ dbgprintf("Got region with %i entries: %s\n", num_entries, ++ fdt_get_name(dtb, nodeoffset, NULL)); ++ ++ for (num_entries--; num_entries >= 0; num_entries--) { ++ offset = num_entries * entry_size; ++ ++ dtb_extract_int_property(&addr, reg + offset, ++ root_addr_cells); ++ offset += root_addr_cells * sizeof(uint32_t); ++ ++ dtb_extract_int_property(&size, reg + offset, ++ root_size_cells); ++ ++ ret = dtb_add_memory_range(mem_ranges, addr, ++ addr + size, type); ++ if (ret) ++ return ret; ++ } ++ ++ return 0; ++} ++ ++static int dtb_parse_memory_reservations_table(char *dtb, struct memory_ranges *mem_ranges) ++{ ++ int total_memrsrv = 0; ++ uint64_t addr = 0; ++ uint64_t size = 0; ++ int ret = 0; ++ int i = 0; ++ ++ total_memrsrv = fdt_num_mem_rsv(dtb); ++ for (i = 0; i < total_memrsrv; i++) { ++ ret = fdt_get_mem_rsv(dtb, i, &addr, &size); ++ if (ret) ++ continue; ++ ret = dtb_add_memory_range(mem_ranges, addr, addr + size - 1, ++ RANGE_RESERVED); ++ if (ret) ++ return ret; ++ } ++ ++ return 0; ++} ++ ++static int dtb_get_reserved_memory_node(char *dtb) ++{ ++ uint32_t root_addr_cells = 0; ++ uint32_t root_size_cells = 0; ++ uint32_t addr_cells = 0; ++ uint32_t size_cells = 0; ++ int prop_size = 0; ++ int nodeoffset = 0; ++ int ret = 0; ++ ++ /* Get address / size cells from root node */ ++ ret = dtb_get_num_cells(dtb, 0, &root_addr_cells, &root_size_cells, false); ++ if (ret < 0) { ++ dbgprintf("No address/size cells on root node !\n"); ++ return ret; ++ } ++ ++ /* This calls fdt_next_node internaly */ ++ nodeoffset = fdt_subnode_offset(dtb, 0, "reserved-memory"); ++ if (nodeoffset == -FDT_ERR_NOTFOUND) { ++ return nodeoffset; ++ } else if (nodeoffset < 0) { ++ dbgprintf("Error while looking for reserved-memory: %s\n", ++ fdt_strerror(nodeoffset)); ++ return nodeoffset; ++ } ++ ++ /* Look for the ranges property */ ++ fdt_getprop(dtb, nodeoffset, "ranges", &prop_size); ++ if (prop_size < 0) { ++ fprintf(stderr, "Malformed reserved-memory node (no ranges property) !\n"); ++ return -EINVAL; ++ } ++ ++ /* Verify address-cells / size-cells */ ++ ret = dtb_get_num_cells(dtb, nodeoffset, &addr_cells, &size_cells, false); ++ if (ret < 0) { ++ dbgprintf("No address/size cells property on reserved-memory node\n"); ++ return ret; ++ } ++ ++ if (addr_cells != root_addr_cells) { ++ fprintf(stderr, "Invalid #address-cells property on reserved-memory node\n"); ++ return -EINVAL; ++ } ++ ++ if (size_cells != root_size_cells) { ++ fprintf(stderr, "Invalid #size-cells property on reserved-memory node\n"); ++ return -EINVAL; ++ ++ } ++ ++ return nodeoffset; ++} ++ ++static int dtb_parse_reserved_memory_node(char *dtb, struct memory_ranges *mem_ranges) ++{ ++ int nodeoffset = 0; ++ int node_depth = 0; ++ int parent_depth = 0; ++ int ret = 0; ++ ++ nodeoffset = dtb_get_reserved_memory_node(dtb); ++ if (nodeoffset == -FDT_ERR_NOTFOUND) ++ return 0; ++ else if (nodeoffset < 0) ++ return nodeoffset; ++ ++ /* Got the parent node, check for sub-nodes */ ++ ++ /* fdt_next_node() increases or decreases depth */ ++ node_depth = parent_depth; ++ nodeoffset = fdt_next_node(dtb, nodeoffset, &node_depth); ++ if (ret < 0) { ++ dbgprintf("Unable to get next node: %s\n", ++ fdt_strerror(ret)); ++ return -EINVAL; ++ } ++ ++ while (node_depth != parent_depth) { ++ ++ ret = dtb_add_memory_region(dtb, nodeoffset, ++ mem_ranges, RANGE_RESERVED); ++ if (ret) ++ return ret; ++ ++ nodeoffset = fdt_next_node(dtb, nodeoffset, &node_depth); ++ if (ret < 0) { ++ dbgprintf("Unable to get next node: %s\n", ++ fdt_strerror(ret)); ++ return -EINVAL; ++ } ++ } ++ ++ return 0; ++} ++ ++static int dtb_parse_memory_nodes(char *dtb, struct memory_ranges *mem_ranges) ++{ ++ int nodeoffset = 0; ++ int num_regions = 0; ++ const char* dev_type = 0; ++ int prop_size = 0; ++ int ret = 0; ++ ++ for (; ; num_regions++) { ++ nodeoffset = fdt_subnode_offset(dtb, nodeoffset, ++ "memory"); ++ if (nodeoffset < 0) ++ break; ++ ++ dbgprintf("Got memory node at depth: %i\n", fdt_node_depth(dtb, nodeoffset)); ++ ++ /* Look for the device_type property */ ++ dev_type = fdt_getprop(dtb, nodeoffset, "device_type", &prop_size); ++ if (prop_size < 0) { ++ fprintf(stderr, "Malformed /memory node (no device-type property) !\n"); ++ return -EINVAL; ++ } ++ ++ if (strncmp(dev_type, "memory", prop_size)) { ++ dbgprintf("Got unknown dev_type property: %s\n", dev_type); ++ continue; ++ } ++ ++ ret = dtb_add_memory_region(dtb, nodeoffset, mem_ranges, RANGE_RAM); ++ if (ret) ++ return ret; ++ } ++ ++ if (!num_regions) { ++ dbgprintf("Malformed dtb, no /memory nodes present !\n"); ++ return -EINVAL; ++ } ++ ++ dbgprintf("Got %i /memory nodes\n", num_regions); ++ ++ return 0; ++} ++ ++int dtb_get_memory_ranges(char *dtb, struct memory_ranges *mem_ranges, struct memory_ranges *extra_ranges) ++{ ++ int i = 0; ++ int ret = 0; ++ ++ /* Fill mem_ranges[] by parsing the device tree */ ++ ret = dtb_parse_memory_nodes(dtb, mem_ranges); ++ if (ret) ++ return ret; ++ ++ ret = dtb_parse_memory_reservations_table(dtb, mem_ranges); ++ if (ret) ++ return ret; ++ ++ ret = dtb_parse_reserved_memory_node(dtb, mem_ranges); ++ if (ret) ++ return ret; ++ ++ /* Append any extra ranges provided by the caller (e.g. initrd) */ ++ for (i = 0; extra_ranges != NULL && i < extra_ranges->size; i++) { ++ dbgprintf("Adding extra range: 0x%llx - 0x%llx (%s)\n", ++ extra_ranges->ranges[i].start, ++ extra_ranges->ranges[i].end, ++ extra_ranges->ranges[i].type == RANGE_RESERVED ? ++ "RANGE_RESERVED" : "RANGE_RAM"); ++ ++ ret = dtb_add_memory_range(mem_ranges, extra_ranges->ranges[i].start, ++ extra_ranges->ranges[i].end, extra_ranges->ranges[i].type); ++ if (ret) ++ return ret; ++ } ++ ++ mem_regions_sort(mem_ranges); ++ ++ return 0; ++} +diff --git a/kexec/dt-ops.h b/kexec/dt-ops.h +index 03659ce..3014205 100644 +--- a/kexec/dt-ops.h ++++ b/kexec/dt-ops.h +@@ -11,4 +11,11 @@ int dtb_set_property(char **dtb, off_t *dtb_size, const char *node, + + int dtb_delete_property(char *dtb, const char *node, const char *prop); + ++void dtb_extract_int_property(uint64_t *val, const void *buf, uint32_t cells); ++void dtb_fill_int_property(void *buf, uint64_t val, uint32_t cells); ++int dtb_add_range_property(char **dtb, off_t *dtb_size, uint64_t start, uint64_t end, ++ const char *node, const char* parent); ++int dtb_get_memory_ranges(char *dtb, struct memory_ranges *mem_ranges, ++ struct memory_ranges *extra_ranges); ++ + #endif +diff --git a/kexec/kexec-iomem.c b/kexec/kexec-iomem.c +index d00b6b6..1ace808 100644 +--- a/kexec/kexec-iomem.c ++++ b/kexec/kexec-iomem.c +@@ -76,7 +76,7 @@ static int kexec_iomem_single_callback(void *data, int nr, + { + struct memory_range *range = data; + +- if (nr == 0) { ++ if (nr >= 0) { + range->start = base; + range->end = base + length - 1; + } +@@ -94,7 +94,7 @@ int parse_iomem_single(char *str, uint64_t *start, uint64_t *end) + ret = kexec_iomem_for_each_line(str, + kexec_iomem_single_callback, &range); + +- if (ret == 1) { ++ if (ret >= 1) { + if (start) + *start = range.start; + if (end) +diff --git a/kexec/kexec-syscall.h b/kexec/kexec-syscall.h +index be6ccd5..2310b98 100644 +--- a/kexec/kexec-syscall.h ++++ b/kexec/kexec-syscall.h +@@ -80,6 +80,9 @@ + #ifdef __hppa__ + #define __NR_kexec_file_load 355 + #endif ++#if defined(__riscv__) || defined(__riscv) ++#define __NR_kexec_file_load 294 ++#endif + + #ifndef __NR_kexec_file_load + /* system call not available for the arch */ +@@ -137,6 +140,7 @@ static inline long kexec_file_load(int kernel_fd, int initrd_fd, + #define KEXEC_ARCH_MIPS_LE (10 << 16) + #define KEXEC_ARCH_MIPS ( 8 << 16) + #define KEXEC_ARCH_CRIS (76 << 16) ++#define KEXEC_ARCH_RISCV (243 << 16) + #define KEXEC_ARCH_LOONGARCH (258 << 16) + + #define KEXEC_MAX_SEGMENTS 16 +@@ -184,5 +188,8 @@ static inline long kexec_file_load(int kernel_fd, int initrd_fd, + #if defined(__loongarch__) + #define KEXEC_ARCH_NATIVE KEXEC_ARCH_LOONGARCH + #endif ++#if defined(__riscv__) || defined(__riscv) ++#define KEXEC_ARCH_NATIVE KEXEC_ARCH_RISCV ++#endif + + #endif /* KEXEC_SYSCALL_H */ +diff --git a/purgatory/Makefile b/purgatory/Makefile +index 4d2d071..7d1175f 100644 +--- a/purgatory/Makefile ++++ b/purgatory/Makefile +@@ -25,6 +25,7 @@ include $(srcdir)/purgatory/arch/ia64/Makefile + include $(srcdir)/purgatory/arch/mips/Makefile + include $(srcdir)/purgatory/arch/ppc/Makefile + include $(srcdir)/purgatory/arch/ppc64/Makefile ++include $(srcdir)/purgatory/arch/riscv/Makefile + include $(srcdir)/purgatory/arch/s390/Makefile + include $(srcdir)/purgatory/arch/sh/Makefile + include $(srcdir)/purgatory/arch/x86_64/Makefile +diff --git a/purgatory/arch/riscv/Makefile b/purgatory/arch/riscv/Makefile +new file mode 100644 +index 0000000..49a6fef +--- /dev/null ++++ b/purgatory/arch/riscv/Makefile +@@ -0,0 +1,7 @@ ++# ++# Purgatory riscv ++# ++ ++riscv_PURGATORY_SRCS = ++ ++dist += purgatory/arch/riscv/Makefile $(riscv_PURGATORY_SRCS) +-- +2.34.1 + diff --git a/kexec-tools.spec b/kexec-tools.spec index ea846c9..70c4646 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 2 +Release: 4 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -34,6 +34,7 @@ Source27: early-kdump-howto.txt Source28: kdump-udev-throttler Source29: kdump.sysconfig.aarch64 Source30: kdump.sysconfig.loongarch64 +Source31: kdump.sysconfig.riscv64 Source100: dracut-kdump.sh Source101: dracut-module-setup.sh @@ -78,6 +79,11 @@ Patch0004: sw_64.patch Patch0005: makedumpfile-1.7.2-sw.patch %endif +%ifarch riscv64 +Patch0006: kexec-tools-Add-riscv-support.patch +Patch0007: riscv-makedumpfile-1.7.3.patch +%endif + %description kexec-tools provides /sbin/kexec binary that facilitates a new kernel to boot using the kernel's kexec feature either on a @@ -110,7 +116,7 @@ rm -f kexec-tools.spec.in cp %{SOURCE21} %{SOURCE26} %{SOURCE27} . make -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 make -C eppic-%{eppic_ver}/libeppic make -C makedumpfile-%{mkdf_ver} LINKTYPE=dynamic USELZO=on USESNAPPY=on make -C makedumpfile-%{mkdf_ver} LDFLAGS="$LDFLAGS -I../eppic-%{eppic_ver}/libeppic -L../eppic-%{eppic_ver}/libeppic" eppic_makedumpfile.so @@ -129,6 +135,11 @@ mkdir -p %{buildroot}%{_unitdir} mkdir -p -m755 %{buildroot}%{_bindir} mkdir -p -m755 %{buildroot}%{_libdir} mkdir -p -m755 %{buildroot}%{_prefix}/lib/kdump + +%ifarch riscv64 +sed -i 's/--initrd=$TARGET_INITRD //g' %{SOURCE1} +%endif + install -m 755 %{SOURCE1} %{buildroot}%{_bindir}/kdumpctl install -m 755 build/sbin/kexec %{buildroot}/usr/sbin/kexec @@ -154,7 +165,7 @@ install -m 644 %{SOURCE16} %{buildroot}%{_unitdir}/kdump.service install -m 755 -D %{SOURCE22} %{buildroot}%{_prefix}/lib/systemd/system-generators/kdump-dep-generator.sh install -m 644 %{SOURCE13} $RPM_BUILD_ROOT%{_udevrulesdir}/98-kexec.rules -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 install -m 755 makedumpfile-%{mkdf_ver}/makedumpfile $RPM_BUILD_ROOT/usr/sbin/makedumpfile install -m 644 makedumpfile-%{mkdf_ver}/makedumpfile.8 $RPM_BUILD_ROOT/%{_mandir}/man8/makedumpfile.8 install -m 644 makedumpfile-%{mkdf_ver}/makedumpfile.conf.5 $RPM_BUILD_ROOT/%{_mandir}/man5/makedumpfile.conf.5 @@ -259,14 +270,14 @@ done %{dracutlibdir}/modules.d/* %{_unitdir}/kdump.service %{_prefix}/lib/systemd/system-generators/kdump-dep-generator.sh -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 %{_libdir}/eppic_makedumpfile.so /usr/share/makedumpfile/ %endif -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 %{_sysconfdir}/makedumpfile.conf.sample %endif -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 /usr/sbin/makedumpfile %endif @@ -279,11 +290,14 @@ done %{_mandir}/man8/mkdumprd.8.gz %{_mandir}/man8/vmcore-dmesg.8.gz %{_mandir}/man5/* -%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le +%ifarch %{ix86} x86_64 aarch64 sw_64 loongarch64 ppc64le riscv64 %{_mandir}/man8/makedumpfile.8.gz %endif %changelog +* Thu Apr 18 2024 Mingzheng Xing - 2.0.26-4 +- Add riscv64 support + * Mon Jan 30 2023 chenhaixiang - 2.0.26-3 - update makedumpfile to makedumpfile-1.7.3 diff --git a/riscv-makedumpfile-1.7.3.patch b/riscv-makedumpfile-1.7.3.patch new file mode 100644 index 0000000..18ae058 --- /dev/null +++ b/riscv-makedumpfile-1.7.3.patch @@ -0,0 +1,910 @@ +From a88a07451eee09aac9b0c3f6ce54f959b2d08432 Mon Sep 17 00:00:00 2001 +From: Mingzheng Xing +Date: Wed, 17 Apr 2024 17:13:33 +0800 +Subject: [PATCH] riscv: makedumpfile 1.7.3 + +Upgrade to upstream version 1.7.4, which provides support for the riscv +architecture. + +This patch will be maintained until the openEuler community upgrade. + +Signed-off-by: Mingzheng Xing +--- + makedumpfile-1.7.3/Makefile | 6 +- + makedumpfile-1.7.3/README | 3 + + makedumpfile-1.7.3/arch/ppc64.c | 111 ++++++++++---- + makedumpfile-1.7.3/arch/riscv64.c | 219 +++++++++++++++++++++++++++ + makedumpfile-1.7.3/dwarf_info.c | 29 +++- + makedumpfile-1.7.3/makedumpfile.c | 74 ++++++++- + makedumpfile-1.7.3/makedumpfile.h | 122 ++++++++++++++- + makedumpfile-1.7.3/makedumpfile.spec | 2 +- + 8 files changed, 519 insertions(+), 47 deletions(-) + create mode 100644 makedumpfile-1.7.3/arch/riscv64.c + +diff --git a/makedumpfile-1.7.3/Makefile b/makedumpfile-1.7.3/Makefile +index 9436f2a..0934f14 100644 +--- a/makedumpfile-1.7.3/Makefile ++++ b/makedumpfile-1.7.3/Makefile +@@ -1,7 +1,7 @@ + # makedumpfile + +-VERSION=1.7.3 +-DATE=25 Apr 2023 ++VERSION=1.7.4 ++DATE=6 Nov 2023 + + # Honour the environment variable CC + ifeq ($(strip $CC),) +@@ -47,7 +47,7 @@ endif + SRC_BASE = makedumpfile.c makedumpfile.h diskdump_mod.h sadump_mod.h sadump_info.h + SRC_PART = print_info.c dwarf_info.c elf_info.c erase_info.c sadump_info.c cache.c tools.c printk.c detect_cycle.c + OBJ_PART=$(patsubst %.c,%.o,$(SRC_PART)) +-SRC_ARCH = arch/arm.c arch/arm64.c arch/x86.c arch/x86_64.c arch/ia64.c arch/ppc64.c arch/s390x.c arch/ppc.c arch/sparc64.c arch/mips64.c arch/loongarch64.c ++SRC_ARCH = arch/arm.c arch/arm64.c arch/x86.c arch/x86_64.c arch/ia64.c arch/ppc64.c arch/s390x.c arch/ppc.c arch/sparc64.c arch/mips64.c arch/loongarch64.c arch/riscv64.c + OBJ_ARCH=$(patsubst %.c,%.o,$(SRC_ARCH)) + + LIBS = -ldw -lbz2 -ldl -lelf -lz +diff --git a/makedumpfile-1.7.3/README b/makedumpfile-1.7.3/README +index 4a9d0c0..858ae30 100644 +--- a/makedumpfile-1.7.3/README ++++ b/makedumpfile-1.7.3/README +@@ -169,6 +169,9 @@ + 6.1 | | ** | | | | ** | | -- | | OK | | | + 6.2 | | ** | | | | ** | | -- | | OK | | | + 6.3 | | ** | | | | ** | | -- | | OK | | | ++ 6.4 | | ** | | | | ** | | -- | | OK | | | ++ 6.5 | | ** | | | | ** | | -- | | OK | | | ++ 6.6 | | ** | | | | ** | | -- | | OK | | | + + OK : Support. + -- : Not support. +diff --git a/makedumpfile-1.7.3/arch/ppc64.c b/makedumpfile-1.7.3/arch/ppc64.c +index 5e70acb..96c357c 100644 +--- a/makedumpfile-1.7.3/arch/ppc64.c ++++ b/makedumpfile-1.7.3/arch/ppc64.c +@@ -196,6 +196,10 @@ ppc64_vmemmap_init(void) + int psize, shift; + ulong head; + ++ /* initialise vmemmap_list in case SYMBOL(vmemmap_list) is not found */ ++ info->vmemmap_list = NULL; ++ info->vmemmap_cnt = 0; ++ + if ((SYMBOL(vmemmap_list) == NOT_FOUND_SYMBOL) + || (SYMBOL(mmu_psize_defs) == NOT_FOUND_SYMBOL) + || (SYMBOL(mmu_vmemmap_psize) == NOT_FOUND_SYMBOL) +@@ -216,15 +220,24 @@ ppc64_vmemmap_init(void) + return FALSE; + info->vmemmap_psize = 1 << shift; + +- if (!readmem(VADDR, SYMBOL(vmemmap_list), &head, sizeof(unsigned long))) +- return FALSE; +- + /* +- * Get vmemmap list count and populate vmemmap regions info +- */ +- info->vmemmap_cnt = get_vmemmap_list_info(head); +- if (info->vmemmap_cnt == 0) +- return FALSE; ++ * vmemmap_list symbol can be missing or set to 0 in the kernel. ++ * This would imply vmemmap region is mapped in the kernel pagetable. ++ * ++ * So, read vmemmap_list anyway, and use 'vmemmap_list' if it's not empty ++ * (head != NULL), or we will do a kernel pagetable walk for vmemmap address ++ * translation later ++ **/ ++ readmem(VADDR, SYMBOL(vmemmap_list), &head, sizeof(unsigned long)); ++ ++ if (head) { ++ /* ++ * Get vmemmap list count and populate vmemmap regions info ++ */ ++ info->vmemmap_cnt = get_vmemmap_list_info(head); ++ if (info->vmemmap_cnt == 0) ++ return FALSE; ++ } + + info->flag_vmemmap = TRUE; + return TRUE; +@@ -347,29 +360,6 @@ ppc64_vmalloc_init(void) + return TRUE; + } + +-/* +- * If the vmemmap address translation information is stored in the kernel, +- * make the translation. +- */ +-static unsigned long long +-ppc64_vmemmap_to_phys(unsigned long vaddr) +-{ +- int i; +- ulong offset; +- unsigned long long paddr = NOT_PADDR; +- +- for (i = 0; i < info->vmemmap_cnt; i++) { +- if ((vaddr >= info->vmemmap_list[i].virt) && (vaddr < +- (info->vmemmap_list[i].virt + info->vmemmap_psize))) { +- offset = vaddr - info->vmemmap_list[i].virt; +- paddr = info->vmemmap_list[i].phys + offset; +- break; +- } +- } +- +- return paddr; +-} +- + static unsigned long long + ppc64_vtop_level4(unsigned long vaddr) + { +@@ -379,6 +369,8 @@ ppc64_vtop_level4(unsigned long vaddr) + unsigned long long pgd_pte, pud_pte; + unsigned long long pmd_pte, pte; + unsigned long long paddr = NOT_PADDR; ++ uint is_hugepage = 0; ++ uint pdshift; + uint swap = 0; + + if (info->page_buf == NULL) { +@@ -413,6 +405,13 @@ ppc64_vtop_level4(unsigned long vaddr) + if (!pgd_pte) + return NOT_PADDR; + ++ if (IS_HUGEPAGE(pgd_pte)) { ++ is_hugepage = 1; ++ pte = pgd_pte; ++ pdshift = info->l4_shift; ++ goto out; ++ } ++ + /* + * Sometimes we don't have level3 pagetable entries + */ +@@ -426,6 +425,13 @@ ppc64_vtop_level4(unsigned long vaddr) + pud_pte = swap64(ULONG((info->page_buf + PAGEOFFSET(page_upper))), swap); + if (!pud_pte) + return NOT_PADDR; ++ ++ if (IS_HUGEPAGE(pud_pte)) { ++ is_hugepage = 1; ++ pte = pud_pte; ++ pdshift = info->l3_shift; ++ goto out; ++ } + } else { + pud_pte = pgd_pte; + } +@@ -440,6 +446,13 @@ ppc64_vtop_level4(unsigned long vaddr) + if (!(pmd_pte)) + return NOT_PADDR; + ++ if (IS_HUGEPAGE(pmd_pte)) { ++ is_hugepage = 1; ++ pte = pmd_pte; ++ pdshift = info->l2_shift; ++ goto out; ++ } ++ + pmd_pte = pmd_page_vaddr_l4(pmd_pte); + page_table = (ulong *)(pmd_pte) + + (BTOP(vaddr) & (info->ptrs_per_l1 - 1)); +@@ -456,8 +469,40 @@ ppc64_vtop_level4(unsigned long vaddr) + if (!pte) + return NOT_PADDR; + +- paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) ++out: ++ if (is_hugepage) { ++ paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) ++ + (vaddr & ((1UL << pdshift) - 1)); ++ } else { ++ paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) + + PAGEOFFSET(vaddr); ++ } ++ ++ return paddr; ++} ++ ++/* ++ * If the vmemmap address translation information is stored in the kernel, ++ * make the translation. ++ */ ++static unsigned long long ++ppc64_vmemmap_to_phys(unsigned long vaddr) ++{ ++ int i; ++ ulong offset; ++ unsigned long long paddr = NOT_PADDR; ++ ++ if (!info->vmemmap_list) ++ return ppc64_vtop_level4(vaddr); ++ ++ for (i = 0; i < info->vmemmap_cnt; i++) { ++ if ((vaddr >= info->vmemmap_list[i].virt) && (vaddr < ++ (info->vmemmap_list[i].virt + info->vmemmap_psize))) { ++ offset = vaddr - info->vmemmap_list[i].virt; ++ paddr = info->vmemmap_list[i].phys + offset; ++ break; ++ } ++ } + + return paddr; + } +@@ -567,8 +612,8 @@ get_machdep_info_ppc64(void) + return FALSE; + } + ++ info->vmemmap_start = VMEMMAP_REGION_ID << REGION_SHIFT; + if (SYMBOL(vmemmap_list) != NOT_FOUND_SYMBOL) { +- info->vmemmap_start = VMEMMAP_REGION_ID << REGION_SHIFT; + info->vmemmap_end = info->vmemmap_start; + if (ppc64_vmemmap_init() == FALSE) { + ERRMSG("Can't get vmemmap list info.\n"); +diff --git a/makedumpfile-1.7.3/arch/riscv64.c b/makedumpfile-1.7.3/arch/riscv64.c +new file mode 100644 +index 0000000..1b43ec4 +--- /dev/null ++++ b/makedumpfile-1.7.3/arch/riscv64.c +@@ -0,0 +1,219 @@ ++/* ++ * riscv64.c ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ */ ++#ifdef __riscv64__ ++ ++#include "../print_info.h" ++#include "../elf_info.h" ++#include "../makedumpfile.h" ++ ++int ++get_phys_base_riscv64(void) ++{ ++ if (NUMBER(phys_ram_base) != NOT_FOUND_NUMBER) ++ info->phys_base = NUMBER(phys_ram_base); ++ else ++ /* In case that you are using qemu rv64 env */ ++ info->phys_base = 0x80200000; ++ ++ DEBUG_MSG("phys_base : %lx\n", info->phys_base); ++ return TRUE; ++} ++ ++int ++get_machdep_info_riscv64(void) ++{ ++ ++ if(NUMBER(va_bits) == NOT_FOUND_NUMBER || NUMBER(page_offset) == NOT_FOUND_NUMBER || ++ NUMBER(vmalloc_start) == NOT_FOUND_NUMBER || NUMBER(vmalloc_end) == NOT_FOUND_NUMBER || ++ NUMBER(vmemmap_start) == NOT_FOUND_NUMBER || NUMBER(vmemmap_end) == NOT_FOUND_NUMBER || ++ NUMBER(modules_vaddr) == NOT_FOUND_NUMBER || NUMBER(modules_end) == NOT_FOUND_NUMBER || ++ NUMBER(kernel_link_addr) == NOT_FOUND_NUMBER || NUMBER(va_kernel_pa_offset) == NOT_FOUND_NUMBER) ++ return FALSE; ++ ++ if (NUMBER(MAX_PHYSMEM_BITS) != NOT_FOUND_NUMBER) ++ info->max_physmem_bits = NUMBER(MAX_PHYSMEM_BITS); ++ else ++ info->max_physmem_bits = _MAX_PHYSMEM_BITS; ++ ++ if (NUMBER(SECTION_SIZE_BITS) != NOT_FOUND_NUMBER) ++ info->section_size_bits = NUMBER(SECTION_SIZE_BITS); ++ else ++ info->section_size_bits = _SECTION_SIZE_BITS; ++ ++ info->page_offset = NUMBER(page_offset); ++ ++ DEBUG_MSG("va_bits : %ld\n", NUMBER(va_bits)); ++ DEBUG_MSG("page_offset : %lx\n", NUMBER(page_offset)); ++ DEBUG_MSG("vmalloc_start : %lx\n", NUMBER(vmalloc_start)); ++ DEBUG_MSG("vmalloc_end : %lx\n", NUMBER(vmalloc_end)); ++ DEBUG_MSG("vmemmap_start : %lx\n", NUMBER(vmemmap_start)); ++ DEBUG_MSG("vmemmap_end : %lx\n", NUMBER(vmemmap_end)); ++ DEBUG_MSG("modules_vaddr : %lx\n", NUMBER(modules_vaddr)); ++ DEBUG_MSG("modules_end : %lx\n", NUMBER(modules_end)); ++ DEBUG_MSG("kernel_link_addr : %lx\n", NUMBER(kernel_link_addr)); ++ DEBUG_MSG("va_kernel_pa_offset : %lx\n", NUMBER(va_kernel_pa_offset)); ++ ++ return TRUE; ++} ++ ++/* ++ * For direct memory mapping ++ */ ++ ++#define VTOP(X) ({ \ ++ ulong _X = X; \ ++ (_X) >= NUMBER(kernel_link_addr) ? ((_X) - (NUMBER(va_kernel_pa_offset))): \ ++ ((_X) - PAGE_OFFSET + (info->phys_base)); \ ++ }) ++ ++static unsigned long long ++vtop_riscv64(pgd_t * pgd, unsigned long vaddr, long va_bits) ++{ ++ unsigned long long paddr = NOT_PADDR; ++ pgd_t *pgda; ++ p4d_t *p4da; ++ pud_t *puda; ++ pmd_t *pmda; ++ pte_t *ptea; ++ ulong pt_val, pt_phys; ++ ++#define pgd_index(X) ((va_bits == VA_BITS_SV57) ? pgd_index_l5(X) : \ ++ ((va_bits == VA_BITS_SV48) ? pgd_index_l4(X) : pgd_index_l3(X))) ++ ++ /* PGD */ ++ pgda = (pgd_t *)(pgd) + pgd_index(vaddr); ++ if (!readmem(PADDR, (unsigned long long)pgda, &pt_val, sizeof(pt_val))) { ++ ERRMSG("Can't read pgd\n"); ++ goto invalid; ++ } ++ ++ pt_val &= PTE_PFN_PROT_MASK; ++ ++ if (!(pt_val & _PAGE_PRESENT)) { ++ ERRMSG("Can't get a valid pgd.\n"); ++ goto invalid; ++ } ++ ++ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); ++ ++ if (pt_val & _PAGE_LEAF) ++ goto out; ++ ++ if (va_bits == VA_BITS_SV57) ++ goto p4d; ++ else if (va_bits == VA_BITS_SV48) ++ goto pud; ++ else ++ goto pmd; ++p4d: ++ /* P4D */ ++ p4da = (p4d_t *)(pt_phys) + p4d_index(vaddr); ++ if (!readmem(PADDR, (unsigned long long)p4da, &pt_val, sizeof(pt_val))) { ++ ERRMSG("Can't read p4d\n"); ++ goto invalid; ++ } ++ ++ pt_val &= PTE_PFN_PROT_MASK; ++ ++ if (!(pt_val & _PAGE_PRESENT)) { ++ ERRMSG("Can't get a valid p4d.\n"); ++ goto invalid; ++ } ++ ++ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); ++ ++ if (pt_val & _PAGE_LEAF) ++ goto out; ++pud: ++ /* PUD */ ++ puda = (pud_t *)(pt_phys) + pud_index(vaddr); ++ if (!readmem(PADDR, (unsigned long long)puda, &pt_val, sizeof(pt_val))) { ++ ERRMSG("Can't read pud\n"); ++ goto invalid; ++ } ++ ++ pt_val &= PTE_PFN_PROT_MASK; ++ ++ if (!(pt_val & _PAGE_PRESENT)) { ++ ERRMSG("Can't get a valid pud.\n"); ++ goto invalid; ++ } ++ ++ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); ++ ++ if(pt_val & _PAGE_LEAF) ++ goto out; ++pmd: ++ /* PMD */ ++ pmda = (pmd_t *)(pt_phys) + pmd_index(vaddr); ++ if (!readmem(PADDR, (unsigned long long)pmda, &pt_val, sizeof(pt_val))) { ++ ERRMSG("Can't read pmd\n"); ++ goto invalid; ++ } ++ ++ pt_val &= PTE_PFN_PROT_MASK; ++ ++ if (!(pt_val & _PAGE_PRESENT)) { ++ ERRMSG("Can't get a valid pmd.\n"); ++ goto invalid; ++ } ++ ++ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); ++ ++ if (pt_val & _PAGE_LEAF) ++ goto out; ++ ++ /* PTE */ ++ ptea = (pte_t *)(pt_phys) + pte_index(vaddr); ++ if (!readmem(PADDR, (unsigned long long)ptea, &pt_val, sizeof(pt_val))) { ++ ERRMSG("Can't read pte\n"); ++ goto invalid; ++ } ++ ++ pt_val &= PTE_PFN_PROT_MASK; ++ ++ if (!(pt_val & _PAGE_PRESENT)) { ++ ERRMSG("Can't get a valid pte.\n"); ++ goto invalid; ++ } ++ ++ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); ++ ++out: ++ paddr = pt_phys + PAGEOFFSET(vaddr); ++invalid: ++ return paddr; ++} ++ ++unsigned long long ++vaddr_to_paddr_riscv64(unsigned long vaddr) ++{ ++ unsigned long long swapper_phys; ++ ++ if (vaddr >= PAGE_OFFSET && ++ !(vaddr >= NUMBER(modules_vaddr) && vaddr <= NUMBER(modules_end))){ ++ return VTOP(vaddr); ++ } ++ ++ if (SYMBOL(swapper_pg_dir) == NOT_FOUND_SYMBOL) { ++ ERRMSG("Can't get the symbol of swapper_pg_dir.\n"); ++ return NOT_PADDR; ++ } ++ ++ swapper_phys = VTOP(SYMBOL(swapper_pg_dir)); ++ ++ return vtop_riscv64((pgd_t *)swapper_phys, vaddr, NUMBER(va_bits)); ++} ++ ++#endif /* __riscv64__ */ +diff --git a/makedumpfile-1.7.3/dwarf_info.c b/makedumpfile-1.7.3/dwarf_info.c +index 543588b..a3a2fd6 100644 +--- a/makedumpfile-1.7.3/dwarf_info.c ++++ b/makedumpfile-1.7.3/dwarf_info.c +@@ -1091,6 +1091,8 @@ get_symbol_addr(char *symname) + out: + clean_dwfl_info(); + ++ DEBUG_MSG("%s : %s %llx\n", __func__, symname, symbol); ++ + return symbol; + } + +@@ -1175,6 +1177,8 @@ get_next_symbol_addr(char *symname) + out: + clean_dwfl_info(); + ++ DEBUG_MSG("%s: %s %lx\n", __func__, symname, next_symbol); ++ + return next_symbol; + } + +@@ -1192,8 +1196,12 @@ get_structure_size(char *structname, int flag_typedef) + dwarf_info.struct_name = structname; + dwarf_info.struct_size = NOT_FOUND_STRUCTURE; + +- if (!get_debug_info()) ++ if (!get_debug_info()) { ++ DEBUG_MSG("%s: %s failed\n", __func__, structname); + return FAILED_DWARFINFO; ++ } ++ ++ DEBUG_MSG("%s: %s %ld\n", __func__, structname, dwarf_info.struct_size); + + return dwarf_info.struct_size; + } +@@ -1251,8 +1259,13 @@ get_member_offset(char *structname, char *membername, int cmd) + else + dwarf_info.member_name = membername; + +- if (!get_debug_info()) ++ if (!get_debug_info()) { ++ DEBUG_MSG("%s : %s.%s failed\n", __func__, structname, membername); + return FAILED_DWARFINFO; ++ } ++ ++ DEBUG_MSG("%s : %s.%s %ld\n", __func__, structname, membername, ++ dwarf_info.member_offset); + + return dwarf_info.member_offset; + } +@@ -1309,8 +1322,12 @@ get_array_length(char *name01, char *name02, unsigned int cmd) + dwarf_info.member_offset = NOT_FOUND_STRUCTURE; + dwarf_info.array_length = NOT_FOUND_STRUCTURE; + +- if (!get_debug_info()) ++ if (!get_debug_info()) { ++ DEBUG_MSG("%s : %s.%s failed\n", __func__, name01, name02); + return FAILED_DWARFINFO; ++ } ++ ++ DEBUG_MSG("%s : %s.%s %ld\n", __func__, name01, name02, dwarf_info.array_length); + + return dwarf_info.array_length; + } +@@ -1322,8 +1339,12 @@ get_enum_number(char *enum_name) + dwarf_info.enum_name = enum_name; + dwarf_info.enum_number = NOT_FOUND_NUMBER; + +- if (!get_debug_info()) ++ if (!get_debug_info()) { ++ DEBUG_MSG("%s : %s failed\n", __func__, enum_name); + return FAILED_DWARFINFO; ++ } ++ ++ DEBUG_MSG("%s : %s %ld\n", __func__, enum_name, dwarf_info.enum_number); + + return dwarf_info.enum_number; + } +diff --git a/makedumpfile-1.7.3/makedumpfile.c b/makedumpfile-1.7.3/makedumpfile.c +index ba2bb46..a6ec9d4 100644 +--- a/makedumpfile-1.7.3/makedumpfile.c ++++ b/makedumpfile-1.7.3/makedumpfile.c +@@ -262,13 +262,17 @@ is_in_same_page(unsigned long vaddr1, unsigned long vaddr2) + return FALSE; + } + ++/* For Linux 6.6 and later */ ++#define IS_HUGETLB ((unsigned long)-1) ++ + static inline int + isHugetlb(unsigned long dtor) + { +- return ((NUMBER(HUGETLB_PAGE_DTOR) != NOT_FOUND_NUMBER) +- && (NUMBER(HUGETLB_PAGE_DTOR) == dtor)) +- || ((SYMBOL(free_huge_page) != NOT_FOUND_SYMBOL) +- && (SYMBOL(free_huge_page) == dtor)); ++ return (dtor == IS_HUGETLB) ++ || ((NUMBER(HUGETLB_PAGE_DTOR) != NOT_FOUND_NUMBER) ++ && (NUMBER(HUGETLB_PAGE_DTOR) == dtor)) ++ || ((SYMBOL(free_huge_page) != NOT_FOUND_SYMBOL) ++ && (SYMBOL(free_huge_page) == dtor)); + } + + static int +@@ -1710,6 +1714,9 @@ get_symbol_info(void) + return TRUE; + } + ++#define MOD_DATA 1 ++#define MOD_INIT_DATA 5 ++ + int + get_structure_info(void) + { +@@ -1817,6 +1824,26 @@ get_structure_info(void) + OFFSET_INIT(module.num_symtab, "module", "num_symtab"); + OFFSET_INIT(module.list, "module", "list"); + OFFSET_INIT(module.name, "module", "name"); ++ ++ /* kernel >= 6.4 */ ++ SIZE_INIT(module_memory, "module_memory"); ++ if (SIZE(module_memory) != NOT_FOUND_STRUCTURE) { ++ OFFSET_INIT(module.mem, "module", "mem"); ++ OFFSET_INIT(module_memory.base, "module_memory", "base"); ++ OFFSET_INIT(module_memory.size, "module_memory", "size"); ++ ++ OFFSET(module.module_core) = OFFSET(module.mem) + ++ SIZE(module_memory) * MOD_DATA + OFFSET(module_memory.base); ++ OFFSET(module.core_size) = OFFSET(module.mem) + ++ SIZE(module_memory) * MOD_DATA + OFFSET(module_memory.size); ++ OFFSET(module.module_init) = OFFSET(module.mem) + ++ SIZE(module_memory) * MOD_INIT_DATA + OFFSET(module_memory.base); ++ OFFSET(module.init_size) = OFFSET(module.mem) + ++ SIZE(module_memory) * MOD_INIT_DATA + OFFSET(module_memory.size); ++ ++ goto module_end; ++ } ++ + OFFSET_INIT(module.module_core, "module", "module_core"); + if (OFFSET(module.module_core) == NOT_FOUND_STRUCTURE) { + /* for kernel version 4.5 and above */ +@@ -1858,6 +1885,7 @@ get_structure_info(void) + OFFSET(module.init_size) += init_layout; + } + ++module_end: + ENUM_NUMBER_INIT(NR_FREE_PAGES, "NR_FREE_PAGES"); + ENUM_NUMBER_INIT(N_ONLINE, "N_ONLINE"); + ENUM_NUMBER_INIT(pgtable_l5_enabled, "pgtable_l5_enabled"); +@@ -1869,6 +1897,7 @@ get_structure_info(void) + ENUM_NUMBER_INIT(PG_buddy, "PG_buddy"); + ENUM_NUMBER_INIT(PG_slab, "PG_slab"); + ENUM_NUMBER_INIT(PG_hwpoison, "PG_hwpoison"); ++ ENUM_NUMBER_INIT(PG_hugetlb, "PG_hugetlb"); + + ENUM_NUMBER_INIT(PG_head_mask, "PG_head_mask"); + if (NUMBER(PG_head_mask) == NOT_FOUND_NUMBER) { +@@ -2483,6 +2512,7 @@ write_vmcoreinfo_data(void) + WRITE_NUMBER("PG_buddy", PG_buddy); + WRITE_NUMBER("PG_slab", PG_slab); + WRITE_NUMBER("PG_hwpoison", PG_hwpoison); ++ WRITE_NUMBER("PG_hugetlb", PG_hugetlb); + + WRITE_NUMBER("PAGE_BUDDY_MAPCOUNT_VALUE", PAGE_BUDDY_MAPCOUNT_VALUE); + WRITE_NUMBER("PAGE_OFFLINE_MAPCOUNT_VALUE", +@@ -2932,6 +2962,7 @@ read_vmcoreinfo(void) + READ_NUMBER("PG_slab", PG_slab); + READ_NUMBER("PG_buddy", PG_buddy); + READ_NUMBER("PG_hwpoison", PG_hwpoison); ++ READ_NUMBER("PG_hugetlb", PG_hugetlb); + READ_NUMBER("SECTION_SIZE_BITS", SECTION_SIZE_BITS); + READ_NUMBER("MAX_PHYSMEM_BITS", MAX_PHYSMEM_BITS); + +@@ -2948,6 +2979,20 @@ read_vmcoreinfo(void) + READ_NUMBER_UNSIGNED("kimage_voffset", kimage_voffset); + #endif + ++#ifdef __riscv64__ ++ READ_NUMBER("VA_BITS", va_bits); ++ READ_NUMBER_UNSIGNED("phys_ram_base", phys_ram_base); ++ READ_NUMBER_UNSIGNED("PAGE_OFFSET", page_offset); ++ READ_NUMBER_UNSIGNED("VMALLOC_START", vmalloc_start); ++ READ_NUMBER_UNSIGNED("VMALLOC_END", vmalloc_end); ++ READ_NUMBER_UNSIGNED("VMEMMAP_START", vmemmap_start); ++ READ_NUMBER_UNSIGNED("VMEMMAP_END", vmemmap_end); ++ READ_NUMBER_UNSIGNED("MODULES_VADDR", modules_vaddr); ++ READ_NUMBER_UNSIGNED("MODULES_END", modules_end); ++ READ_NUMBER_UNSIGNED("KERNEL_LINK_ADDR", kernel_link_addr); ++ READ_NUMBER_UNSIGNED("va_kernel_pa_offset", va_kernel_pa_offset); ++#endif ++ + READ_NUMBER("HUGETLB_PAGE_DTOR", HUGETLB_PAGE_DTOR); + + return TRUE; +@@ -3264,7 +3309,11 @@ get_mm_flatmem(void) + if (is_xen_memory()) + dump_mem_map(0, info->dom0_mapnr, mem_map, 0); + else ++#ifdef __riscv64__ ++ dump_mem_map((info->phys_base >> PAGESHIFT()), info->max_mapnr, mem_map, 0); ++#else + dump_mem_map(0, info->max_mapnr, mem_map, 0); ++#endif + + return TRUE; + } +@@ -6451,6 +6500,21 @@ __exclude_unnecessary_pages(unsigned long mem_map, + if ((index_pg < PGMM_CACHED - 1) && isCompoundHead(flags)) { + unsigned char *addr = pcache + SIZE(page); + ++ /* ++ * Linux 6.6 and later. Kernels that have PG_hugetlb should also ++ * have the compound order in the low byte of folio._flags_1. ++ */ ++ if (NUMBER(PG_hugetlb) != NOT_FOUND_NUMBER) { ++ unsigned long _flags_1 = ULONG(addr + OFFSET(page.flags)); ++ ++ compound_order = _flags_1 & 0xff; ++ ++ if (_flags_1 & (1UL << NUMBER(PG_hugetlb))) ++ compound_dtor = IS_HUGETLB; ++ ++ goto check_order; ++ } ++ + if (order_offset) { + if (info->kernel_version >= KERNEL_VERSION(4, 16, 0)) + compound_order = UCHAR(addr + order_offset); +@@ -6470,7 +6534,7 @@ __exclude_unnecessary_pages(unsigned long mem_map, + else + compound_dtor = ULONG(addr + dtor_offset); + } +- ++check_order: + if ((compound_order >= sizeof(unsigned long) * 8) + || ((pfn & ((1UL << compound_order) - 1)) != 0)) { + /* Invalid order */ +diff --git a/makedumpfile-1.7.3/makedumpfile.h b/makedumpfile-1.7.3/makedumpfile.h +index 99ccf0a..59a809c 100644 +--- a/makedumpfile-1.7.3/makedumpfile.h ++++ b/makedumpfile-1.7.3/makedumpfile.h +@@ -498,7 +498,7 @@ do { \ + #define KVER_MIN_SHIFT 16 + #define KERNEL_VERSION(x,y,z) (((x) << KVER_MAJ_SHIFT) | ((y) << KVER_MIN_SHIFT) | (z)) + #define OLDEST_VERSION KERNEL_VERSION(2, 6, 15) /* linux-2.6.15 */ +-#define LATEST_VERSION KERNEL_VERSION(6, 3, 0) /* linux-6.3.0 */ ++#define LATEST_VERSION KERNEL_VERSION(6, 6, 0) /* linux-6.6.0 */ + + /* + * vmcoreinfo in /proc/vmcore +@@ -678,6 +678,12 @@ unsigned long get_kvbase_arm64(void); + #define REGION_SHIFT (60UL) + #define VMEMMAP_REGION_ID (0xfUL) + ++/* ++ * If PAGE_PTE is set, then it's a leaf PTE for hugepage ++ */ ++#define PAGE_PTE (1UL << 62) ++#define IS_HUGEPAGE(pte) (!!((pte) & PAGE_PTE)) ++ + /* 4-level page table support */ + + /* 4K pagesize */ +@@ -1046,6 +1052,77 @@ typedef unsigned long pgd_t; + + #endif /* loongarch64 */ + ++#ifdef __riscv64__ ++/* ++ * Referencing the riscv64_is_kvaddr() in Crash-utility, ++ * set the vmemmap start address as the lowest kernel virtual base. ++ */ ++#define KVBASE (NUMBER(vmemmap_start)) ++#define _SECTION_SIZE_BITS (27) ++#define _MAX_PHYSMEM_BITS (56) ++ ++typedef ulong pgd_t; ++typedef ulong p4d_t; ++typedef ulong pud_t; ++typedef ulong pmd_t; ++typedef ulong pte_t; ++ ++/* arch/riscv/include/asm/pgtable-64.h */ ++ ++#define PGD_SHIFT_L3 (30) ++#define PGD_SHIFT_L4 (39) ++#define PGD_SHIFT_L5 (48) ++ ++#define P4D_SHIFT (39) ++#define PUD_SHIFT (30) ++#define PMD_SHIFT (21) ++ ++#define PTRS_PER_PGD (512) ++#define PTRS_PER_P4D (512) ++#define PTRS_PER_PUD (512) ++#define PTRS_PER_PMD (512) ++#define PTRS_PER_PTE (512) ++ ++/* ++ * 3/4/5-levels pg indexs ++ */ ++#define pgd_index_l3(addr) (((addr) >> PGD_SHIFT_L3) & (PTRS_PER_PGD - 1)) ++#define pgd_index_l4(addr) (((addr) >> PGD_SHIFT_L4) & (PTRS_PER_PGD - 1)) ++#define pgd_index_l5(addr) (((addr) >> PGD_SHIFT_L5) & (PTRS_PER_PGD - 1)) ++#define p4d_index(addr) (((addr) >> P4D_SHIFT) & (PTRS_PER_P4D - 1)) ++#define pud_index(addr) (((addr) >> PUD_SHIFT) & (PTRS_PER_PUD - 1)) ++#define pmd_index(addr) (((addr) >> PMD_SHIFT) & (PTRS_PER_PMD - 1)) ++#define pte_index(addr) (((addr) >> PAGESHIFT()) & (PTRS_PER_PTE - 1)) ++ ++/* arch/riscv/include/asm/pgtable-bits.h */ ++ ++#define _PAGE_PRESENT (1 << 0) ++#define _PAGE_READ (1 << 1) /* Readable */ ++#define _PAGE_WRITE (1 << 2) /* Writable */ ++#define _PAGE_EXEC (1 << 3) /* Executable */ ++#define _PAGE_USER (1 << 4) /* User */ ++#define _PAGE_GLOBAL (1 << 5) /* Global */ ++#define _PAGE_ACCESSED (1 << 6) /* Set by hardware on any access */ ++#define _PAGE_DIRTY (1 << 7) /* Set by hardware on any write */ ++#define _PAGE_SOFT (1 << 8) /* Reserved for software */ ++ ++#define _PAGE_PFN_SHIFT (10) ++#define _PAGE_LEAF (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC) ++ ++/* ++ * Mask for bit 0~53(PROT and PPN) of PTE ++ * 63 6261 60 54 53 10 9 8 7 6 5 4 3 2 1 0 ++ * N PBMT Reserved P P N RSW D A G U X W R V ++ */ ++#define PTE_PFN_PROT_MASK 0x3FFFFFFFFFFFFF ++ ++#define VA_BITS_SV39 (39) ++#define VA_BITS_SV48 (48) ++#define VA_BITS_SV57 (57) ++ ++#endif /* riscv64 */ ++ ++ + /* + * The function of dependence on machine + */ +@@ -1233,6 +1310,22 @@ unsigned long long vaddr_to_paddr_loongarch64(unsigned long vaddr); + #define arch_crashkernel_mem_size() stub_false() + #endif /* loongarch64 */ + ++#ifdef __riscv64__ ++int get_phys_base_riscv64(void); ++int get_machdep_info_riscv64(void); ++unsigned long long vaddr_to_paddr_riscv64(unsigned long vaddr); ++#define paddr_to_vaddr_riscv64(X) ((X) + PAGE_OFFSET - info->phys_base) ++#define find_vmemmap() stub_false() ++#define get_phys_base() get_phys_base_riscv64() ++#define get_machdep_info() get_machdep_info_riscv64() ++#define get_versiondep_info() stub_true() ++#define get_kaslr_offset(X) stub_false() ++#define vaddr_to_paddr(X) vaddr_to_paddr_riscv64(X) ++#define paddr_to_vaddr(X) paddr_to_vaddr_riscv64(X) ++#define is_phys_addr(X) stub_true_ul(X) ++#define arch_crashkernel_mem_size() stub_false() ++#endif /* riscv64 */ ++ + typedef unsigned long long mdf_pfn_t; + + #ifndef ARCH_PFN_OFFSET +@@ -1842,6 +1935,7 @@ struct size_table { + * for loading module symbol data + */ + long module; ++ long module_memory; + + /* + * for sadump +@@ -1944,8 +2038,14 @@ struct offset_table { + long num_symtab; + long symtab; + long strtab; ++ long mem; + } module; + ++ struct module_memory { ++ long base; ++ long size; ++ } module_memory; ++ + /* + * for loading elf_prstaus symbol data + */ +@@ -2131,6 +2231,7 @@ struct number_table { + long PG_buddy; + long PG_slab; + long PG_hwpoison; ++ long PG_hugetlb; + + long PAGE_BUDDY_MAPCOUNT_VALUE; + long PAGE_OFFLINE_MAPCOUNT_VALUE; +@@ -2145,6 +2246,19 @@ struct number_table { + unsigned long PHYS_OFFSET; + unsigned long kimage_voffset; + #endif ++#ifdef __riscv64__ ++ long va_bits; ++ unsigned long phys_ram_base; ++ unsigned long page_offset; ++ unsigned long vmalloc_start; ++ unsigned long vmalloc_end; ++ unsigned long vmemmap_start; ++ unsigned long vmemmap_end; ++ unsigned long modules_vaddr; ++ unsigned long modules_end; ++ unsigned long kernel_link_addr; ++ unsigned long va_kernel_pa_offset; ++#endif + }; + + struct srcfile_table { +@@ -2383,6 +2497,12 @@ int get_xen_info_ia64(void); + #define get_xen_info_arch(X) FALSE + #endif /* loongarch64 */ + ++#ifdef __riscv64__ /* riscv64 */ ++#define kvtop_xen(X) FALSE ++#define get_xen_basic_info_arch(X) FALSE ++#define get_xen_info_arch(X) FALSE ++#endif /* riscv64 */ ++ + struct cycle { + mdf_pfn_t start_pfn; + mdf_pfn_t end_pfn; +diff --git a/makedumpfile-1.7.3/makedumpfile.spec b/makedumpfile-1.7.3/makedumpfile.spec +index 182db54..3b53847 100644 +--- a/makedumpfile-1.7.3/makedumpfile.spec ++++ b/makedumpfile-1.7.3/makedumpfile.spec +@@ -1,6 +1,6 @@ + Name: makedumpfile + Summary: makedumpfile package +-Version: 1.7.3 ++Version: 1.7.4 + Release: 1 + Group: Applications/Text + License: GPL +-- +2.34.1 + -- Gitee From 8de77cea6052cbdc8306ef30df8e764e93937b64 Mon Sep 17 00:00:00 2001 From: huangwenhua Date: Mon, 13 May 2024 16:17:55 +0800 Subject: [PATCH 2/7] Add loongarch iomem.h --- Add-loongarch-iomem.h.patch | 29 +++++++++++++++++++++++++++++ kexec-tools.spec | 9 ++++++++- 2 files changed, 37 insertions(+), 1 deletion(-) create mode 100644 Add-loongarch-iomem.h.patch diff --git a/Add-loongarch-iomem.h.patch b/Add-loongarch-iomem.h.patch new file mode 100644 index 0000000..137ed9b --- /dev/null +++ b/Add-loongarch-iomem.h.patch @@ -0,0 +1,29 @@ +From 7a26c60ffa31f54606063855348a4c6aaeabfe13 Mon Sep 17 00:00:00 2001 +From: huangwenhua +Date: Mon, 13 May 2024 11:43:20 +0800 +Subject: [PATCH] Add loongarch/iomem.h + +--- + kexec/arch/loongarch/iomem.h | 10 ++++++++++ + 1 file changed, 10 insertions(+) + create mode 100644 kexec/arch/loongarch/iomem.h + +diff --git a/kexec/arch/loongarch/iomem.h b/kexec/arch/loongarch/iomem.h +new file mode 100644 +index 0000000..7671e26 +--- /dev/null ++++ b/kexec/arch/loongarch/iomem.h +@@ -0,0 +1,10 @@ ++#ifndef IOMEM_H ++#define IOMEM_H ++ ++#define SYSTEM_RAM "System RAM\n" ++#define KERNEL_CODE "Kernel code\n" ++#define KERNEL_DATA "Kernel data\n" ++#define CRASH_KERNEL "Crash kernel\n" ++#define IOMEM_RESERVED "Reserved\n" ++ ++#endif +-- +2.43.0 + diff --git a/kexec-tools.spec b/kexec-tools.spec index 70c4646..fed2e4a 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 4 +Release: 5 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -84,6 +84,10 @@ Patch0006: kexec-tools-Add-riscv-support.patch Patch0007: riscv-makedumpfile-1.7.3.patch %endif +%ifarch loongarch64 +Patch0008: Add-loongarch-iomem.h.patch +%endif + %description kexec-tools provides /sbin/kexec binary that facilitates a new kernel to boot using the kernel's kexec feature either on a @@ -295,6 +299,9 @@ done %endif %changelog +* Mon May 13 2024 Wenhua Huang - 2.0.26-5 +- Add loongarch iomem.h + * Thu Apr 18 2024 Mingzheng Xing - 2.0.26-4 - Add riscv64 support -- Gitee From ade55ee8786b85c4011b0b22553bf953791c39ee Mon Sep 17 00:00:00 2001 From: chenhaixiang Date: Mon, 8 Jul 2024 03:02:44 -0400 Subject: [PATCH 3/7] Undo the deletion of rd.lvm.lv in cmdline Signed-off-by: chenhaixiang --- kdump-lib.sh | 2 +- kexec-tools.spec | 5 ++++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/kdump-lib.sh b/kdump-lib.sh index b079f27..efc1a37 100755 --- a/kdump-lib.sh +++ b/kdump-lib.sh @@ -640,7 +640,7 @@ prepare_cmdline() cmdline=$(remove_cmdline_param "$cmdline" root) # With the help of "--hostonly-cmdline", we can avoid some interitage. - cmdline=$(remove_cmdline_param "$cmdline" rd.lvm.lv rd.luks.uuid rd.dm.uuid rd.md.uuid fcoe) + cmdline=$(remove_cmdline_param "$cmdline" rd.luks.uuid rd.dm.uuid rd.md.uuid fcoe) # Remove netroot, rd.iscsi.initiator and iscsi_initiator since # we get duplicate entries for the same in case iscsi code adds diff --git a/kexec-tools.spec b/kexec-tools.spec index fed2e4a..160b456 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 5 +Release: 6 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -299,6 +299,9 @@ done %endif %changelog +* Mon Jul 8 2024 chenhaixiang - 2.0.26-6 +- Undo the deletion of rd.lvm.lv in cmdline + * Mon May 13 2024 Wenhua Huang - 2.0.26-5 - Add loongarch iomem.h -- Gitee From 5756bf61947c4d0645469212f9670829f83fc31a Mon Sep 17 00:00:00 2001 From: zhangzikang1992 Date: Wed, 24 Jul 2024 14:05:36 +0800 Subject: [PATCH 4/7] Fix "grep: warning: stray \ before -" --- kdump-lib.sh | 10 +++++----- kdumpctl | 4 ++-- kexec-tools.spec | 5 ++++- 3 files changed, 11 insertions(+), 8 deletions(-) diff --git a/kdump-lib.sh b/kdump-lib.sh index efc1a37..9d0779d 100755 --- a/kdump-lib.sh +++ b/kdump-lib.sh @@ -44,7 +44,7 @@ is_nfs_dump_target() return 0; fi - if is_fs_type_nfs $(get_dracut_args_fstype "$(grep "^dracut_args .*\-\-mount" /etc/kdump.conf)"); then + if is_fs_type_nfs $(get_dracut_args_fstype "$(grep "^dracut_args .*--mount" /etc/kdump.conf)"); then return 0 fi @@ -127,7 +127,7 @@ get_user_configured_dump_disk() _target=$(egrep "^ext[234]|^xfs|^btrfs|^minix|^raw" /etc/kdump.conf 2>/dev/null |awk '{print $2}') [ -n "$_target" ] && echo $_target && return - _target=$(get_dracut_args_target "$(grep "^dracut_args .*\-\-mount" /etc/kdump.conf)") + _target=$(get_dracut_args_target "$(grep "^dracut_args .*--mount" /etc/kdump.conf)") [ -b "$_target" ] && echo $_target } @@ -448,19 +448,19 @@ is_wdt_mod_omitted() { # its correctness). is_mount_in_dracut_args() { - grep -q "^dracut_args .*\-\-mount" /etc/kdump.conf + grep -q "^dracut_args .*--mount" /etc/kdump.conf } # If $1 contains dracut_args "--mount", return get_dracut_args_fstype() { - echo $1 | grep "\-\-mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f3 + echo $1 | grep "\--mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f3 } # If $1 contains dracut_args "--mount", return get_dracut_args_target() { - echo $1 | grep "\-\-mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f1 + echo $1 | grep "\--mount" | sed "s/.*--mount .\(.*\)/\1/" | cut -d' ' -f1 } check_crash_mem_reserved() diff --git a/kdumpctl b/kdumpctl index 00c0064..fc50b2a 100755 --- a/kdumpctl +++ b/kdumpctl @@ -227,7 +227,7 @@ check_config() return 1 } - nr=$(grep "^dracut_args .*\-\-mount" $KDUMP_CONFIG_FILE | grep -o "\-\-mount" | wc -l) + nr=$(grep "^dracut_args .*--mount" $KDUMP_CONFIG_FILE | grep -o "\--mount" | wc -l) [ $nr -gt 1 ] && { echo "Multiple mount targets specified in one \"dracut_args\"." return 1 @@ -492,7 +492,7 @@ check_dump_fs_modified() # if --mount argument present then match old and new target, mount # point and file system. If any of them mismatches then rebuild - echo $_dracut_args | grep "\-\-mount" &> /dev/null + echo $_dracut_args | grep "\--mount" &> /dev/null if [[ $? -eq 0 ]];then set -- $(echo $_dracut_args | awk -F "--mount '" '{print $2}' | cut -d' ' -f1,2,3) _old_dev=$1 diff --git a/kexec-tools.spec b/kexec-tools.spec index 160b456..fb3ba1d 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 6 +Release: 7 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -299,6 +299,9 @@ done %endif %changelog +* Wed Jul 24 2024 zhangzikang - 2.0.26-7 +- Fix "grep: warning: stray \ before -" + * Mon Jul 8 2024 chenhaixiang - 2.0.26-6 - Undo the deletion of rd.lvm.lv in cmdline -- Gitee From a18d6e55fe07281ced257668383b9fec721fd682 Mon Sep 17 00:00:00 2001 From: EulerOSWander <314264452@qq.com> Date: Tue, 30 Jul 2024 17:09:42 +0800 Subject: [PATCH 5/7] update makedumpfile to makedumpfile-1.7.4 (cherry picked from commit 0b7f2dba217a63af9b20df2ca6d379dd62dc9b1b) --- ...cure-compile-options-for-makedumpfile.patch | 6 +++--- kexec-tools.spec | 7 +++++-- makedumpfile-1.7.3.tar.gz | Bin 206343 -> 0 bytes makedumpfile-1.7.4.tar.gz | Bin 0 -> 209058 bytes 4 files changed, 8 insertions(+), 5 deletions(-) delete mode 100644 makedumpfile-1.7.3.tar.gz create mode 100644 makedumpfile-1.7.4.tar.gz diff --git a/add-secure-compile-options-for-makedumpfile.patch b/add-secure-compile-options-for-makedumpfile.patch index a3207c3..21ca0ef 100644 --- a/add-secure-compile-options-for-makedumpfile.patch +++ b/add-secure-compile-options-for-makedumpfile.patch @@ -10,10 +10,10 @@ Signed-off-by: pengyeqing Makefile | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) -diff --git a/makedumpfile-1.6.7/Makefile b/makedumpfile-1.6.7/Makefile +diff --git a/makedumpfile-1.7.4/Makefile b/makedumpfile-1.7.4/Makefile index 612b9d0..180a64f 100644 ---- a/makedumpfile-1.7.3/Makefile -+++ b/makedumpfile-1.7.3/Makefile +--- a/makedumpfile-1.7.4/Makefile ++++ b/makedumpfile-1.7.4/Makefile @@ -10,9 +10,10 @@ endif CFLAGS_BASE := $(CFLAGS) -g -O2 -Wall -D_FILE_OFFSET_BITS=64 \ diff --git a/kexec-tools.spec b/kexec-tools.spec index 160b456..a3748ed 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -1,10 +1,10 @@ %global eppic_ver e8844d3793471163ae4a56d8f95897be9e5bd554 %global eppic_shortver %(c=%{eppic_ver}; echo ${c:0:7}) -%global mkdf_ver 1.7.3 +%global mkdf_ver 1.7.4 Name: kexec-tools Version: 2.0.26 -Release: 6 +Release: 7 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -299,6 +299,9 @@ done %endif %changelog +* Tue Jul 30 2024 chenhaixiang - 2.0.26-7 +- update makedumpfile to makedumpfile-1.7.4 + * Mon Jul 8 2024 chenhaixiang - 2.0.26-6 - Undo the deletion of rd.lvm.lv in cmdline diff --git a/makedumpfile-1.7.3.tar.gz b/makedumpfile-1.7.3.tar.gz deleted file mode 100644 index 9a94f6db9b7b58539e57720d6db3d4363f1999a9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 206343 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

~2pSp|r1O!{Mm1Veu=D+9H2x$y|MT;fpZ(`gd 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

I$X78A9}1&*;m;_fDBx7xz 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

_BvWI~4W*xwGF4bS3(ZXjeC*Yht)r)tqr+L# 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 Date: Sat, 21 Sep 2024 05:31:53 +0800 Subject: [PATCH 6/7] Fix risc-v kexec-tools support of file_load formats and initrd * Add support for zImage with file_load * Fix initrd address overlapping issue * Fix firmware overwrite issues --- kdump.sysconfig.riscv64 | 2 +- kexec-tools-fix-riscv-support.patch | 635 +++++++++++++++++++ kexec-tools.spec | 11 +- riscv-makedumpfile-1.7.3.patch | 910 ---------------------------- 4 files changed, 641 insertions(+), 917 deletions(-) create mode 100644 kexec-tools-fix-riscv-support.patch delete mode 100644 riscv-makedumpfile-1.7.3.patch diff --git a/kdump.sysconfig.riscv64 b/kdump.sysconfig.riscv64 index 1e65df8..39fcc56 100644 --- a/kdump.sysconfig.riscv64 +++ b/kdump.sysconfig.riscv64 @@ -21,7 +21,7 @@ KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet" # This variable lets us append arguments to the current kdump commandline # after processed by KDUMP_COMMANDLINE_REMOVE -KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices novmcoredd noinitrd" +KDUMP_COMMANDLINE_APPEND="irqpoll nr_cpus=1 reset_devices novmcoredd" # Any additional kexec arguments required. In most situations, this should # be left empty diff --git a/kexec-tools-fix-riscv-support.patch b/kexec-tools-fix-riscv-support.patch new file mode 100644 index 0000000..4ae9260 --- /dev/null +++ b/kexec-tools-fix-riscv-support.patch @@ -0,0 +1,635 @@ +diff -ruN kexec_orig/kexec/arch/riscv/Makefile kexec_new/kexec/arch/riscv/Makefile +--- kexec_orig/kexec/arch/riscv/Makefile 2024-09-21 04:10:02.056885713 +0800 ++++ kexec_new/kexec/arch/riscv/Makefile 2024-09-21 04:27:49.269821895 +0800 +@@ -3,6 +3,8 @@ + # + riscv_KEXEC_SRCS = kexec/arch/riscv/kexec-riscv.c + riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-elf-riscv.c ++riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-elf-utils-riscv.c ++riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-zImage-riscv.c + riscv_KEXEC_SRCS += kexec/arch/riscv/kexec-image-riscv.c + riscv_KEXEC_SRCS += kexec/arch/riscv/crashdump-riscv.c + +diff -ruN kexec_orig/kexec/arch/riscv/kexec-elf-utils-riscv.c kexec_new/kexec/arch/riscv/kexec-elf-utils-riscv.c +--- kexec_orig/kexec/arch/riscv/kexec-elf-utils-riscv.c 1970-01-01 08:00:00.000000000 +0800 ++++ kexec_new/kexec/arch/riscv/kexec-elf-utils-riscv.c 2024-09-21 04:27:49.277821062 +0800 +@@ -0,0 +1,212 @@ ++ ++ ++#include ++#include ++#include ++#include ++#include ++#include "elf.h" ++#include "../../kexec.h" ++ ++#if __riscv_xlen == 64 ++typedef Elf64_Ehdr Elf_Ehdr; ++typedef Elf64_Phdr Elf_Phdr; ++typedef Elf64_Shdr Elf_Shdr; ++typedef Elf64_Sym Elf_Sym; ++typedef uint64_t xlen_t; ++#define ELFCLASS ELFCLASS64 ++#elif __riscv_xlen == 32 ++typedef Elf32_Ehdr Elf_Ehdr; ++typedef Elf32_Phdr Elf_Phdr; ++typedef Elf32_Shdr Elf_Shdr; ++typedef Elf32_Sym Elf_Sym; ++typedef uint32_t xlen_t; ++#define ELFCLASS ELFCLASS32 ++#else ++#error Unsupported ISA length ++#endif ++ ++#define ELF_EXTRA_SIZE 0x1000 ++#define KERNEL_SECTION_COUNT 1 ++#define EXTRA_SECTION_COUNT 3 /* shstrtab + strtab + symtab */ ++ ++static Elf_Ehdr eh = ++{ ++ .e_ident = {ELFMAG0, 'E', 'L', 'F', ELFCLASS, ELFDATA2LSB, EV_CURRENT}, ++ .e_type = 2, ++ .e_machine = EM_RISCV, ++ .e_version = 1, ++ .e_phoff = sizeof(Elf_Ehdr), ++ .e_flags = 0x1, /* RVC */ ++ .e_ehsize = sizeof(Elf_Ehdr), ++ .e_phentsize = sizeof(Elf_Phdr), ++ .e_shentsize = sizeof(Elf_Shdr), ++}; ++ ++static char section_header_string_table[] = "\x00.shstrtab\x00.text\x00.strtab\x00.symtab"; ++static char string_table[] = "\x00r\x00"; ++ ++ ++/* Add ELF wrapper to raw kernel image */ ++char * imageToElf(const char *kernel_buf, unsigned long kernel_size) ++{ ++ Elf_Phdr ph; ++ Elf_Shdr sh; ++ Elf_Sym st; ++ xlen_t elf_offset, entry_addr = 1; ++ char *elf_buf; ++ xlen_t elf_write_offset = 0; ++ ++ elf_buf = malloc(kernel_size + ELF_EXTRA_SIZE); ++ ++ /* determine address that does not overlap */ ++ struct memory_range *range; ++ int ranges; ++ unsigned long start, end; ++ get_memory_ranges(&range, &ranges, 0); ++ for (int i = 0; i < ranges; i++) { ++ if (range[i].type != RANGE_RAM) ++ continue; ++ start = range[i].start; ++ end = range[i].end; ++ ++ start = _ALIGN_UP(start, 0x200000); ++ if (end > start && ((end - start) >= kernel_size)) { ++ entry_addr = start; ++ break; ++ } ++ } ++ if (entry_addr == 1) { ++ fprintf(stderr, "Cannot find proper memory range for given ELF\n"); ++ free(elf_buf); ++ return NULL; ++ } ++ ++ /* write ELF Header */ ++ eh.e_entry = entry_addr; ++ eh.e_phnum = KERNEL_SECTION_COUNT; ++ eh.e_shnum = 1 /* first NULL section */ + KERNEL_SECTION_COUNT + EXTRA_SECTION_COUNT; ++ eh.e_shstrndx = KERNEL_SECTION_COUNT + EXTRA_SECTION_COUNT; /* index to Elf_Shdr for shstrtab */ ++ eh.e_shoff = eh.e_phoff + KERNEL_SECTION_COUNT * sizeof(Elf_Phdr) + kernel_size; ++ memcpy(elf_buf, &eh, sizeof(eh)); ++ elf_write_offset += sizeof(eh); ++ ++ elf_offset = eh.e_phoff + KERNEL_SECTION_COUNT * sizeof(Elf_Phdr); ++ ++ /* write Program Headers */ ++ ph.p_type = 1; ++ ph.p_offset = elf_offset; ++ ph.p_vaddr = ph.p_paddr = entry_addr; ++ ph.p_filesz = ph.p_memsz = kernel_size; ++ ph.p_flags = 0x5; ++ ph.p_align = 1; ++ ++ memcpy(elf_buf + elf_write_offset, &ph, sizeof(ph)); ++ elf_write_offset += sizeof(ph); ++ ++ /* write kernel image */ ++ memcpy(elf_buf + elf_write_offset, kernel_buf, kernel_size); ++ elf_write_offset += kernel_size; ++ ++ /* write prefix Section Header */ ++ ++ memset(&sh, 0, sizeof(sh)); ++ memcpy(elf_buf + elf_write_offset, &sh, sizeof(sh)); ++ elf_write_offset += sizeof(sh); ++ ++ /* write kernel Section Header */ ++ sh.sh_name = 11; // point to .text in shstrtab ++ sh.sh_type = SHT_PROGBITS; ++ sh.sh_flags = SHF_ALLOC | SHF_EXECINSTR; ++ sh.sh_addr = entry_addr; ++ sh.sh_offset = elf_offset; ++ sh.sh_size = kernel_size; ++ sh.sh_link = 0; ++ sh.sh_info = 0; ++ sh.sh_addralign = 0; ++ sh.sh_entsize = 0; ++ ++ memcpy(elf_buf + elf_write_offset, &sh, sizeof(sh)); ++ elf_write_offset += sizeof(sh); ++ ++ elf_offset += kernel_size; ++ elf_offset += (1 + KERNEL_SECTION_COUNT + EXTRA_SECTION_COUNT) * sizeof(sh); ++ ++ /* write Section Header for extra_sections */ ++ ++ sh.sh_name = 25; // point to .symtab in shstrtab ++ sh.sh_type = SHT_SYMTAB; ++ sh.sh_flags = 0; ++ sh.sh_addr = 0; ++ sh.sh_offset = elf_offset; ++ sh.sh_size = (KERNEL_SECTION_COUNT + 1) * sizeof(Elf_Sym); ++ sh.sh_link = 2 + KERNEL_SECTION_COUNT; ++ sh.sh_info = 2; ++ sh.sh_addralign = 4; ++ sh.sh_entsize = sizeof(Elf_Sym); ++ ++ memcpy(elf_buf + elf_write_offset, &sh, sizeof(sh)); ++ elf_write_offset += sizeof(sh); ++ ++ elf_offset += sh.sh_size; ++ ++ sh.sh_name = 17; // point to .strtab in shstrtab ++ sh.sh_type = SHT_STRTAB; ++ sh.sh_flags = 0; ++ sh.sh_addr = 0; ++ sh.sh_offset = elf_offset; ++ sh.sh_size = sizeof(string_table); ++ sh.sh_link = 0; ++ sh.sh_info = 0; ++ sh.sh_addralign = 1; ++ sh.sh_entsize = 0; ++ ++ memcpy(elf_buf + elf_write_offset, &sh, sizeof(sh)); ++ elf_write_offset += sizeof(sh); ++ ++ elf_offset += sh.sh_size; ++ ++ sh.sh_name = 1; // point to .shstrtab in shstrtab ++ sh.sh_type = SHT_STRTAB; ++ sh.sh_flags = 0; ++ sh.sh_addr = 0; ++ sh.sh_offset = elf_offset; ++ sh.sh_size = sizeof(section_header_string_table); ++ sh.sh_link = 0; ++ sh.sh_info = 0; ++ sh.sh_addralign = 1; ++ sh.sh_entsize = 0; ++ ++ memcpy(elf_buf + elf_write_offset, &sh, sizeof(sh)); ++ elf_write_offset += sizeof(sh); ++ ++ elf_offset += sh.sh_size; ++ ++ /* write Symbol Table */ ++ ++ memset(&st, 0, sizeof(st)); ++ memcpy(elf_buf + elf_write_offset, &st, sizeof(st)); ++ elf_write_offset += sizeof(st); ++ ++ st.st_name = 1; /* point to r in strtab */ ++ st.st_value = entry_addr; ++ st.st_size = 0; ++ st.st_info = 0; ++ st.st_other = 0; ++ st.st_shndx = 1; ++ memcpy(elf_buf + elf_write_offset, &st, sizeof(st)); ++ elf_write_offset += sizeof(st); ++ ++ /* write String Table */ ++ ++ memcpy(elf_buf + elf_write_offset, &string_table, sizeof(string_table)); ++ elf_write_offset += sizeof(string_table); ++ ++ /* write Section Header String Table */ ++ ++ memcpy(elf_buf + elf_write_offset, §ion_header_string_table, sizeof(section_header_string_table)); ++ elf_write_offset += sizeof(section_header_string_table); ++ ++ return elf_buf; ++} ++ +diff -ruN kexec_orig/kexec/arch/riscv/kexec-riscv.c kexec_new/kexec/arch/riscv/kexec-riscv.c +--- kexec_orig/kexec/arch/riscv/kexec-riscv.c 2024-09-21 05:07:29.701070532 +0800 ++++ kexec_new/kexec/arch/riscv/kexec-riscv.c 2024-09-21 04:27:49.281820646 +0800 +@@ -17,13 +17,24 @@ + #include "kexec-riscv.h" + #include "iomem.h" + #include +-#include + #include ++#include ++#include ++ + #ifndef _O_BINARY + #define _O_BINARY 0 + #endif + ++#if __riscv_xlen == 64 ++#define DT_SIZE 8 ++#define bswap __builtin_bswap64 ++#else ++#define DT_SIZE 4 ++#define bswap __builtin_bswap32 ++#endif ++ + ++static const char *dirpath = "/proc/device-tree/reserved-memory"; + + const struct arch_map_entry arches[] = { + { "riscv32", KEXEC_ARCH_RISCV }, +@@ -35,6 +46,7 @@ + struct file_type file_type[] = { + {"elf-riscv", elf_riscv_probe, elf_riscv_load, elf_riscv_usage}, + {"image-riscv", image_riscv_probe, image_riscv_load, image_riscv_usage}, ++ {"zImage", zImage_riscv_probe, zImage_riscv_load, zImage_riscv_usage}, + }; + int file_types = sizeof(file_type) / sizeof(file_type[0]); + +@@ -45,7 +57,7 @@ + " --command-line=STRING Use STRING as the kernel's command line.\n" + " --reuse-cmdline Use kernel command line from running system.\n"; + +-static struct riscv_opts arch_options = {0}; ++struct riscv_opts arch_options = {0}; + static struct fdt_image provided_fdt = {0}; + + /****************\ +@@ -116,7 +128,7 @@ + uint64_t initrd_base = 0; + uint64_t start = 0; + uint64_t end = 0; +- uint64_t min_usable = kernel_base + kernel_size; ++ uint64_t min_usable = kernel_base + kernel_size + BSS_PADDING; + uint64_t max_usable = max_addr; + int ret = 0; + +@@ -148,7 +160,7 @@ + fprintf(stderr, "Couldn't add usable-memory-range to fdt\n"); + return ret; + } +- ++ min_usable = start + kernel_size + BSS_PADDING; + max_usable = end; + } else { + /* +@@ -458,6 +470,50 @@ + *range = sysmem_ranges.ranges; + *num_ranges = sysmem_ranges.size; + ++ // iomem can miss reservation for firmwares, add from device tree ++ DIR *dir = opendir(dirpath); ++ if (!dir) { ++ fprintf(stderr, "Cannot found reservation info from devicetree, skipping\n"); ++ } else { ++ struct dirent *dir_ent; ++ struct stat stat_buf; ++ while ((dir_ent = readdir(dir)) != NULL) { ++ if (dir_ent->d_type == DT_DIR) { ++ if (strcmp(dir_ent->d_name, ".") == 0 || ++ strcmp(dir_ent->d_name, "..") == 0) { ++ continue; ++ } ++ char full_path[PATH_MAX]; ++ char reg_path[PATH_MAX + 4]; ++ snprintf(full_path, PATH_MAX, "%s/%s", dirpath, dir_ent->d_name); ++ if (stat(full_path, &stat_buf) == 0 && S_ISDIR(stat_buf.st_mode)) { ++ // found reservation region ++ snprintf(reg_path, PATH_MAX, "%s/reg", full_path); ++ fp = fopen(reg_path, "r"); ++ if (!fp) { ++ fprintf(stderr, "Cannot determine reservation range, check your device tree!\n"); ++ return -ENOMEM; ++ } ++ unsigned long long length, succ; ++ succ = fread(&start, DT_SIZE, 1, fp); // just skip ++ if (!succ) goto skip_reserve; ++ succ = fread(&length, DT_SIZE, 1, fp); ++ if (!succ) goto skip_reserve; ++ // big endian to little endian ++ start = bswap(start); ++ length = bswap(length); ++ end = start + length - 1; ++ dbgprintf("Reservation from FDT %llx - %llx size %llx\n", start, end, length); ++ struct memory_range reserved_range; ++ reserved_range.start = start; ++ reserved_range.end = end; ++ reserved_range.type = RANGE_RESERVED; ++ mem_regions_exclude(&sysmem_ranges, &reserved_range); ++ skip_reserve: ++ } ++ } ++ } ++ } + dbgprint_mem_range("System RAM ranges;", + sysmem_ranges.ranges, sysmem_ranges.size); + +diff -ruN kexec_orig/kexec/arch/riscv/kexec-riscv.h kexec_new/kexec/arch/riscv/kexec-riscv.h +--- kexec_orig/kexec/arch/riscv/kexec-riscv.h 2024-09-21 04:10:02.080885907 +0800 ++++ kexec_new/kexec/arch/riscv/kexec-riscv.h 2024-09-21 04:27:49.285820230 +0800 +@@ -15,6 +15,10 @@ + #define KERNEL_ALIGN 0x400000 + #endif + ++// kernel size may not include BSS section ++// leave space for them ++#define BSS_PADDING 0x4000000 ++ + struct fdt_image { + char *buf; + off_t size; +@@ -51,3 +55,8 @@ + void image_riscv_usage(void); + int image_riscv_load(int argc, char **argv, const char *buf, off_t len, + struct kexec_info *info); ++ ++int zImage_riscv_probe(const char *kernel_buf, off_t kernel_size); ++int zImage_riscv_load(int argc, char **argv, const char *kernel_buf, ++ off_t kernel_size, struct kexec_info *info); ++void zImage_riscv_usage(void); +diff -ruN kexec_orig/kexec/arch/riscv/kexec-zImage-riscv.c kexec_new/kexec/arch/riscv/kexec-zImage-riscv.c +--- kexec_orig/kexec/arch/riscv/kexec-zImage-riscv.c 1970-01-01 08:00:00.000000000 +0800 ++++ kexec_new/kexec/arch/riscv/kexec-zImage-riscv.c 2024-09-21 04:27:49.285820230 +0800 +@@ -0,0 +1,234 @@ ++/* ++ * RISC-V kexec zImage (Image.gz) support. ++ * Modified based on ARM64 implementaton ++ * ++ * Several distros install the RISC-V ++ * Image.gz compressed file inside the boot destination ++ * directory (for e.g. /boot). ++ * ++ * Currently we cannot use kexec_file_load() to load vmlinuz ++ * (or Image.gz). ++ * ++ * To support Image.gz, we should: ++ * a). Copy the contents of Image.gz to a temporary file. ++ * b). Decompress (gunzip-decompress) the contents inside the ++ * temporary file. ++ * c). Pass the 'fd' of the temporary file to the kernel space. ++ * ++ * So basically the kernel space still gets a decompressed ++ * kernel image to load via kexec-tools. ++ */ ++ ++#define _GNU_SOURCE ++ ++#include ++#include ++#include ++#include ++#include "image-header.h" ++#include "kexec.h" ++#include "kexec-riscv.h" ++#include "kexec-syscall.h" ++#include "kexec-zlib.h" ++#include "arch/options.h" ++ ++extern struct riscv_opts arch_options; ++ ++#define FILENAME_IMAGE "/tmp/ImageXXXXXX" ++ ++/* Returns: ++ * -1 : in case of error/invalid format (not a valid Image.gz format. ++ * fd : File descriptor of the temp file containing the decompressed ++ * Image. ++ */ ++int zImage_riscv_probe(const char *kernel_buf, off_t kernel_size) ++{ ++ int ret = -1; ++ int fd = 0; ++ int kernel_fd = 0; ++ char *fname = NULL; ++ char *kernel_uncompressed_buf = NULL; ++ const struct riscv_image_header *h; ++ ++ if (!is_zlib_file(kernel_buf, &kernel_size)) { ++ dbgprintf("%s: Not an zImage file (Image.gz).\n", __func__); ++ return -1; ++ } ++ ++ if (!(fname = strdup(FILENAME_IMAGE))) { ++ dbgprintf("%s: Can't duplicate strings\n", __func__); ++ return -1; ++ } ++ ++ if ((fd = mkstemp(fname)) < 0) { ++ dbgprintf("%s: Can't open file %s\n", __func__, ++ fname); ++ ret = -1; ++ goto fail_mkstemp; ++ } ++ ++ kernel_uncompressed_buf = ++ (char *) calloc(kernel_size, sizeof(off_t)); ++ if (!kernel_uncompressed_buf) { ++ dbgprintf("%s: Can't calloc %ld bytes\n", ++ __func__, kernel_size); ++ ret= -ENOMEM; ++ goto fail_calloc; ++ } ++ ++ /* slurp in the input kernel */ ++ dbgprintf("%s: ", __func__); ++ kernel_uncompressed_buf = slurp_decompress_file(kernel_buf, ++ &kernel_size); ++ dbgprintf("Probe decompression\n"); ++ /* check for correct header magic */ ++ if (kernel_size < sizeof(struct riscv_image_header)) { ++ dbgprintf("%s: No risc-v image header.\n", __func__); ++ ret = -1; ++ goto fail_bad_header; ++ } ++ ++ h = (const struct riscv_image_header *)(kernel_uncompressed_buf); ++ ++ if (!riscv_header_check_magic(h)) { ++ dbgprintf("%s: Bad risc-v image header.\n", __func__); ++ ret = -1; ++ goto fail_bad_header; ++ } ++ ++ /* convert to ELF image */ ++ char *old_buf = kernel_uncompressed_buf; ++ ++ extern char *imageToElf(char*, unsigned long); ++ kernel_uncompressed_buf = imageToElf(kernel_uncompressed_buf, kernel_size); ++ free(old_buf); ++ kernel_size += 0x1000; ++ ++ if (write(fd, kernel_uncompressed_buf, ++ kernel_size) != kernel_size) { ++ dbgprintf("%s: Can't write the uncompressed file %s\n", ++ __func__, fname); ++ ret = -1; ++ goto fail_bad_header; ++ } ++ ++ // Padding for bss ++ char *buf = (char *)malloc(BSS_PADDING); ++ memset(buf, 0, BSS_PADDING); ++ if (write(fd, buf, BSS_PADDING) != BSS_PADDING) { ++ dbgprintf("Can't write padding file %s\n", fname); ++ ret = -1; ++ goto fail_bad_header; ++ } ++ ++ close(fd); ++ ++ /* Open the tmp file again, this time in O_RDONLY mode, as ++ * opening the file in O_RDWR and calling kexec_file_load() ++ * causes the kernel to return -ETXTBSY ++ */ ++ kernel_fd = open(fname, O_RDONLY); ++ if (kernel_fd == -1) { ++ dbgprintf("%s: Failed to open file %s\n", ++ __func__, fname); ++ ret = -1; ++ goto fail_bad_header; ++ } ++ ++ unlink(fname); ++ ++ free(kernel_uncompressed_buf); ++ free(fname); ++ ++ return kernel_fd; ++ ++fail_bad_header: ++ free(kernel_uncompressed_buf); ++ ++fail_calloc: ++ if (fd >= 0) ++ close(fd); ++ ++ unlink(fname); ++ ++fail_mkstemp: ++ free(fname); ++ ++ return ret; ++} ++ ++int zImage_riscv_load(int argc, char **argv, const char *kernel_buf, ++ off_t kernel_size, struct kexec_info *info) ++{ ++ const struct riscv_image_header *header; ++ unsigned long text_offset, image_size; ++ off_t new_base_addr = 0; ++ int result = -1; ++ ++ if (info->file_mode) { ++ if (arch_options.initrd_path) { ++ info->initrd_fd = open(arch_options.initrd_path, O_RDONLY); ++ if (info->initrd_fd == -1) { ++ fprintf(stderr, ++ "Could not open initrd file %s:%s\n", ++ arch_options.initrd_path, strerror(errno)); ++ result = EFAILED; ++ goto exit; ++ } ++ } ++ ++ if (arch_options.cmdline) { ++ info->command_line = (char *)arch_options.cmdline; ++ info->command_line_len = ++ strlen(arch_options.cmdline) + 1; ++ } ++ ++ return 0; ++ } ++ ++ header = (const struct riscv_image_header *)(kernel_buf); ++ text_offset = riscv_header_text_offset(header); ++ image_size = riscv_header_image_size(header); ++ int ret; ++ ret = riscv_find_pbase(info, &new_base_addr, image_size, text_offset); ++ if (ret < 0) { ++ fprintf(stderr, "Could not find a memory region for the " ++ "provided Image\n"); ++ goto exit; ++ } ++ ++ dbgprintf("kernel base %lx\n", new_base_addr); ++ dbgprintf("kernel size %lx\n", kernel_size); ++ dbgprintf("text_offset %lx\n", text_offset); ++ dbgprintf("image size %lx\n", image_size); ++ ++ /* create and initialize elf core header segment */ ++ if (info->kexec_flags & KEXEC_ON_CRASH) { ++ result = load_elfcorehdr(info); ++ if (result) { ++ dbgprintf("%s: Creating eflcorehdr failed.\n", ++ __func__); ++ goto exit; ++ } ++ } ++ ++ /* load the kernel */ ++ add_segment_phys_virt(info, kernel_buf, kernel_size, ++ new_base_addr, ++ image_size, 0); ++ ++ /* load additional data */ ++ result = load_extra_segments(info, text_offset, image_size, ULONG_MAX); ++ ++exit: ++ if (result) ++ fprintf(stderr, "kexec: load failed.\n"); ++ return result; ++} ++ ++void zImage_riscv_usage(void) ++{ ++ printf( ++" An RICS-V zImage, compressed, big or little endian.\n" ++" Typically an Image.gz or Image.lzma file.\n\n"); ++} +diff -ruN kexec_orig/kexec/kexec.c kexec_new/kexec/kexec.c +--- kexec_orig/kexec/kexec.c 2024-09-21 04:33:19.962930418 +0800 ++++ kexec_new/kexec/kexec.c 2024-09-21 04:34:46.596691847 +0800 +@@ -650,7 +650,6 @@ + return; + } + arch_update_purgatory(info); +- + if (info->skip_checks) { + unsigned int tmp = 1; + +@@ -1302,16 +1301,17 @@ + kernel_buf = slurp_decompress_file(kernel, &kernel_size); + + for (i = 0; i < file_types; i++) { +-#ifdef __aarch64__ ++#if defined(__aarch64__) || defined(__riscv__) || defined(__riscv) + /* handle Image.gz like cases */ + if (is_zlib_file(kernel, &kernel_size)) { + if ((ret = file_type[i].probe(kernel, kernel_size)) >= 0) { + kernel_fd = ret; + break; + } +- } else ++ } else { + if (file_type[i].probe(kernel_buf, kernel_size) >= 0) + break; ++ } + #else + if (file_type[i].probe(kernel_buf, kernel_size) >= 0) + break; diff --git a/kexec-tools.spec b/kexec-tools.spec index bc2a6d2..b7dd693 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 8 +Release: 9 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -81,7 +81,7 @@ Patch0005: makedumpfile-1.7.2-sw.patch %ifarch riscv64 Patch0006: kexec-tools-Add-riscv-support.patch -Patch0007: riscv-makedumpfile-1.7.3.patch +Patch0007: kexec-tools-fix-riscv-support.patch %endif %ifarch loongarch64 @@ -140,10 +140,6 @@ mkdir -p -m755 %{buildroot}%{_bindir} mkdir -p -m755 %{buildroot}%{_libdir} mkdir -p -m755 %{buildroot}%{_prefix}/lib/kdump -%ifarch riscv64 -sed -i 's/--initrd=$TARGET_INITRD //g' %{SOURCE1} -%endif - install -m 755 %{SOURCE1} %{buildroot}%{_bindir}/kdumpctl install -m 755 build/sbin/kexec %{buildroot}/usr/sbin/kexec @@ -299,6 +295,9 @@ done %endif %changelog +* Fri Sep 20 2024 chenguokai - 2.0.26-9 +- Fix multiple issues of riscv image format & initrd support + * Wed Aug 14 2024 zhangzikang - 2.0.26-8 - Fix "grep: warning: stray \ before -" diff --git a/riscv-makedumpfile-1.7.3.patch b/riscv-makedumpfile-1.7.3.patch deleted file mode 100644 index 18ae058..0000000 --- a/riscv-makedumpfile-1.7.3.patch +++ /dev/null @@ -1,910 +0,0 @@ -From a88a07451eee09aac9b0c3f6ce54f959b2d08432 Mon Sep 17 00:00:00 2001 -From: Mingzheng Xing -Date: Wed, 17 Apr 2024 17:13:33 +0800 -Subject: [PATCH] riscv: makedumpfile 1.7.3 - -Upgrade to upstream version 1.7.4, which provides support for the riscv -architecture. - -This patch will be maintained until the openEuler community upgrade. - -Signed-off-by: Mingzheng Xing ---- - makedumpfile-1.7.3/Makefile | 6 +- - makedumpfile-1.7.3/README | 3 + - makedumpfile-1.7.3/arch/ppc64.c | 111 ++++++++++---- - makedumpfile-1.7.3/arch/riscv64.c | 219 +++++++++++++++++++++++++++ - makedumpfile-1.7.3/dwarf_info.c | 29 +++- - makedumpfile-1.7.3/makedumpfile.c | 74 ++++++++- - makedumpfile-1.7.3/makedumpfile.h | 122 ++++++++++++++- - makedumpfile-1.7.3/makedumpfile.spec | 2 +- - 8 files changed, 519 insertions(+), 47 deletions(-) - create mode 100644 makedumpfile-1.7.3/arch/riscv64.c - -diff --git a/makedumpfile-1.7.3/Makefile b/makedumpfile-1.7.3/Makefile -index 9436f2a..0934f14 100644 ---- a/makedumpfile-1.7.3/Makefile -+++ b/makedumpfile-1.7.3/Makefile -@@ -1,7 +1,7 @@ - # makedumpfile - --VERSION=1.7.3 --DATE=25 Apr 2023 -+VERSION=1.7.4 -+DATE=6 Nov 2023 - - # Honour the environment variable CC - ifeq ($(strip $CC),) -@@ -47,7 +47,7 @@ endif - SRC_BASE = makedumpfile.c makedumpfile.h diskdump_mod.h sadump_mod.h sadump_info.h - SRC_PART = print_info.c dwarf_info.c elf_info.c erase_info.c sadump_info.c cache.c tools.c printk.c detect_cycle.c - OBJ_PART=$(patsubst %.c,%.o,$(SRC_PART)) --SRC_ARCH = arch/arm.c arch/arm64.c arch/x86.c arch/x86_64.c arch/ia64.c arch/ppc64.c arch/s390x.c arch/ppc.c arch/sparc64.c arch/mips64.c arch/loongarch64.c -+SRC_ARCH = arch/arm.c arch/arm64.c arch/x86.c arch/x86_64.c arch/ia64.c arch/ppc64.c arch/s390x.c arch/ppc.c arch/sparc64.c arch/mips64.c arch/loongarch64.c arch/riscv64.c - OBJ_ARCH=$(patsubst %.c,%.o,$(SRC_ARCH)) - - LIBS = -ldw -lbz2 -ldl -lelf -lz -diff --git a/makedumpfile-1.7.3/README b/makedumpfile-1.7.3/README -index 4a9d0c0..858ae30 100644 ---- a/makedumpfile-1.7.3/README -+++ b/makedumpfile-1.7.3/README -@@ -169,6 +169,9 @@ - 6.1 | | ** | | | | ** | | -- | | OK | | | - 6.2 | | ** | | | | ** | | -- | | OK | | | - 6.3 | | ** | | | | ** | | -- | | OK | | | -+ 6.4 | | ** | | | | ** | | -- | | OK | | | -+ 6.5 | | ** | | | | ** | | -- | | OK | | | -+ 6.6 | | ** | | | | ** | | -- | | OK | | | - - OK : Support. - -- : Not support. -diff --git a/makedumpfile-1.7.3/arch/ppc64.c b/makedumpfile-1.7.3/arch/ppc64.c -index 5e70acb..96c357c 100644 ---- a/makedumpfile-1.7.3/arch/ppc64.c -+++ b/makedumpfile-1.7.3/arch/ppc64.c -@@ -196,6 +196,10 @@ ppc64_vmemmap_init(void) - int psize, shift; - ulong head; - -+ /* initialise vmemmap_list in case SYMBOL(vmemmap_list) is not found */ -+ info->vmemmap_list = NULL; -+ info->vmemmap_cnt = 0; -+ - if ((SYMBOL(vmemmap_list) == NOT_FOUND_SYMBOL) - || (SYMBOL(mmu_psize_defs) == NOT_FOUND_SYMBOL) - || (SYMBOL(mmu_vmemmap_psize) == NOT_FOUND_SYMBOL) -@@ -216,15 +220,24 @@ ppc64_vmemmap_init(void) - return FALSE; - info->vmemmap_psize = 1 << shift; - -- if (!readmem(VADDR, SYMBOL(vmemmap_list), &head, sizeof(unsigned long))) -- return FALSE; -- - /* -- * Get vmemmap list count and populate vmemmap regions info -- */ -- info->vmemmap_cnt = get_vmemmap_list_info(head); -- if (info->vmemmap_cnt == 0) -- return FALSE; -+ * vmemmap_list symbol can be missing or set to 0 in the kernel. -+ * This would imply vmemmap region is mapped in the kernel pagetable. -+ * -+ * So, read vmemmap_list anyway, and use 'vmemmap_list' if it's not empty -+ * (head != NULL), or we will do a kernel pagetable walk for vmemmap address -+ * translation later -+ **/ -+ readmem(VADDR, SYMBOL(vmemmap_list), &head, sizeof(unsigned long)); -+ -+ if (head) { -+ /* -+ * Get vmemmap list count and populate vmemmap regions info -+ */ -+ info->vmemmap_cnt = get_vmemmap_list_info(head); -+ if (info->vmemmap_cnt == 0) -+ return FALSE; -+ } - - info->flag_vmemmap = TRUE; - return TRUE; -@@ -347,29 +360,6 @@ ppc64_vmalloc_init(void) - return TRUE; - } - --/* -- * If the vmemmap address translation information is stored in the kernel, -- * make the translation. -- */ --static unsigned long long --ppc64_vmemmap_to_phys(unsigned long vaddr) --{ -- int i; -- ulong offset; -- unsigned long long paddr = NOT_PADDR; -- -- for (i = 0; i < info->vmemmap_cnt; i++) { -- if ((vaddr >= info->vmemmap_list[i].virt) && (vaddr < -- (info->vmemmap_list[i].virt + info->vmemmap_psize))) { -- offset = vaddr - info->vmemmap_list[i].virt; -- paddr = info->vmemmap_list[i].phys + offset; -- break; -- } -- } -- -- return paddr; --} -- - static unsigned long long - ppc64_vtop_level4(unsigned long vaddr) - { -@@ -379,6 +369,8 @@ ppc64_vtop_level4(unsigned long vaddr) - unsigned long long pgd_pte, pud_pte; - unsigned long long pmd_pte, pte; - unsigned long long paddr = NOT_PADDR; -+ uint is_hugepage = 0; -+ uint pdshift; - uint swap = 0; - - if (info->page_buf == NULL) { -@@ -413,6 +405,13 @@ ppc64_vtop_level4(unsigned long vaddr) - if (!pgd_pte) - return NOT_PADDR; - -+ if (IS_HUGEPAGE(pgd_pte)) { -+ is_hugepage = 1; -+ pte = pgd_pte; -+ pdshift = info->l4_shift; -+ goto out; -+ } -+ - /* - * Sometimes we don't have level3 pagetable entries - */ -@@ -426,6 +425,13 @@ ppc64_vtop_level4(unsigned long vaddr) - pud_pte = swap64(ULONG((info->page_buf + PAGEOFFSET(page_upper))), swap); - if (!pud_pte) - return NOT_PADDR; -+ -+ if (IS_HUGEPAGE(pud_pte)) { -+ is_hugepage = 1; -+ pte = pud_pte; -+ pdshift = info->l3_shift; -+ goto out; -+ } - } else { - pud_pte = pgd_pte; - } -@@ -440,6 +446,13 @@ ppc64_vtop_level4(unsigned long vaddr) - if (!(pmd_pte)) - return NOT_PADDR; - -+ if (IS_HUGEPAGE(pmd_pte)) { -+ is_hugepage = 1; -+ pte = pmd_pte; -+ pdshift = info->l2_shift; -+ goto out; -+ } -+ - pmd_pte = pmd_page_vaddr_l4(pmd_pte); - page_table = (ulong *)(pmd_pte) - + (BTOP(vaddr) & (info->ptrs_per_l1 - 1)); -@@ -456,8 +469,40 @@ ppc64_vtop_level4(unsigned long vaddr) - if (!pte) - return NOT_PADDR; - -- paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) -+out: -+ if (is_hugepage) { -+ paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) -+ + (vaddr & ((1UL << pdshift) - 1)); -+ } else { -+ paddr = PAGEBASE(PTOB((pte & info->pte_rpn_mask) >> info->pte_rpn_shift)) - + PAGEOFFSET(vaddr); -+ } -+ -+ return paddr; -+} -+ -+/* -+ * If the vmemmap address translation information is stored in the kernel, -+ * make the translation. -+ */ -+static unsigned long long -+ppc64_vmemmap_to_phys(unsigned long vaddr) -+{ -+ int i; -+ ulong offset; -+ unsigned long long paddr = NOT_PADDR; -+ -+ if (!info->vmemmap_list) -+ return ppc64_vtop_level4(vaddr); -+ -+ for (i = 0; i < info->vmemmap_cnt; i++) { -+ if ((vaddr >= info->vmemmap_list[i].virt) && (vaddr < -+ (info->vmemmap_list[i].virt + info->vmemmap_psize))) { -+ offset = vaddr - info->vmemmap_list[i].virt; -+ paddr = info->vmemmap_list[i].phys + offset; -+ break; -+ } -+ } - - return paddr; - } -@@ -567,8 +612,8 @@ get_machdep_info_ppc64(void) - return FALSE; - } - -+ info->vmemmap_start = VMEMMAP_REGION_ID << REGION_SHIFT; - if (SYMBOL(vmemmap_list) != NOT_FOUND_SYMBOL) { -- info->vmemmap_start = VMEMMAP_REGION_ID << REGION_SHIFT; - info->vmemmap_end = info->vmemmap_start; - if (ppc64_vmemmap_init() == FALSE) { - ERRMSG("Can't get vmemmap list info.\n"); -diff --git a/makedumpfile-1.7.3/arch/riscv64.c b/makedumpfile-1.7.3/arch/riscv64.c -new file mode 100644 -index 0000000..1b43ec4 ---- /dev/null -+++ b/makedumpfile-1.7.3/arch/riscv64.c -@@ -0,0 +1,219 @@ -+/* -+ * riscv64.c -+ * -+ * This program is free software; you can redistribute it and/or modify -+ * it under the terms of the GNU General Public License as published by -+ * the Free Software Foundation; either version 2 of the License, or -+ * (at your option) any later version. -+ * -+ * This program is distributed in the hope that it will be useful, -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -+ * GNU General Public License for more details. -+ */ -+#ifdef __riscv64__ -+ -+#include "../print_info.h" -+#include "../elf_info.h" -+#include "../makedumpfile.h" -+ -+int -+get_phys_base_riscv64(void) -+{ -+ if (NUMBER(phys_ram_base) != NOT_FOUND_NUMBER) -+ info->phys_base = NUMBER(phys_ram_base); -+ else -+ /* In case that you are using qemu rv64 env */ -+ info->phys_base = 0x80200000; -+ -+ DEBUG_MSG("phys_base : %lx\n", info->phys_base); -+ return TRUE; -+} -+ -+int -+get_machdep_info_riscv64(void) -+{ -+ -+ if(NUMBER(va_bits) == NOT_FOUND_NUMBER || NUMBER(page_offset) == NOT_FOUND_NUMBER || -+ NUMBER(vmalloc_start) == NOT_FOUND_NUMBER || NUMBER(vmalloc_end) == NOT_FOUND_NUMBER || -+ NUMBER(vmemmap_start) == NOT_FOUND_NUMBER || NUMBER(vmemmap_end) == NOT_FOUND_NUMBER || -+ NUMBER(modules_vaddr) == NOT_FOUND_NUMBER || NUMBER(modules_end) == NOT_FOUND_NUMBER || -+ NUMBER(kernel_link_addr) == NOT_FOUND_NUMBER || NUMBER(va_kernel_pa_offset) == NOT_FOUND_NUMBER) -+ return FALSE; -+ -+ if (NUMBER(MAX_PHYSMEM_BITS) != NOT_FOUND_NUMBER) -+ info->max_physmem_bits = NUMBER(MAX_PHYSMEM_BITS); -+ else -+ info->max_physmem_bits = _MAX_PHYSMEM_BITS; -+ -+ if (NUMBER(SECTION_SIZE_BITS) != NOT_FOUND_NUMBER) -+ info->section_size_bits = NUMBER(SECTION_SIZE_BITS); -+ else -+ info->section_size_bits = _SECTION_SIZE_BITS; -+ -+ info->page_offset = NUMBER(page_offset); -+ -+ DEBUG_MSG("va_bits : %ld\n", NUMBER(va_bits)); -+ DEBUG_MSG("page_offset : %lx\n", NUMBER(page_offset)); -+ DEBUG_MSG("vmalloc_start : %lx\n", NUMBER(vmalloc_start)); -+ DEBUG_MSG("vmalloc_end : %lx\n", NUMBER(vmalloc_end)); -+ DEBUG_MSG("vmemmap_start : %lx\n", NUMBER(vmemmap_start)); -+ DEBUG_MSG("vmemmap_end : %lx\n", NUMBER(vmemmap_end)); -+ DEBUG_MSG("modules_vaddr : %lx\n", NUMBER(modules_vaddr)); -+ DEBUG_MSG("modules_end : %lx\n", NUMBER(modules_end)); -+ DEBUG_MSG("kernel_link_addr : %lx\n", NUMBER(kernel_link_addr)); -+ DEBUG_MSG("va_kernel_pa_offset : %lx\n", NUMBER(va_kernel_pa_offset)); -+ -+ return TRUE; -+} -+ -+/* -+ * For direct memory mapping -+ */ -+ -+#define VTOP(X) ({ \ -+ ulong _X = X; \ -+ (_X) >= NUMBER(kernel_link_addr) ? ((_X) - (NUMBER(va_kernel_pa_offset))): \ -+ ((_X) - PAGE_OFFSET + (info->phys_base)); \ -+ }) -+ -+static unsigned long long -+vtop_riscv64(pgd_t * pgd, unsigned long vaddr, long va_bits) -+{ -+ unsigned long long paddr = NOT_PADDR; -+ pgd_t *pgda; -+ p4d_t *p4da; -+ pud_t *puda; -+ pmd_t *pmda; -+ pte_t *ptea; -+ ulong pt_val, pt_phys; -+ -+#define pgd_index(X) ((va_bits == VA_BITS_SV57) ? pgd_index_l5(X) : \ -+ ((va_bits == VA_BITS_SV48) ? pgd_index_l4(X) : pgd_index_l3(X))) -+ -+ /* PGD */ -+ pgda = (pgd_t *)(pgd) + pgd_index(vaddr); -+ if (!readmem(PADDR, (unsigned long long)pgda, &pt_val, sizeof(pt_val))) { -+ ERRMSG("Can't read pgd\n"); -+ goto invalid; -+ } -+ -+ pt_val &= PTE_PFN_PROT_MASK; -+ -+ if (!(pt_val & _PAGE_PRESENT)) { -+ ERRMSG("Can't get a valid pgd.\n"); -+ goto invalid; -+ } -+ -+ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); -+ -+ if (pt_val & _PAGE_LEAF) -+ goto out; -+ -+ if (va_bits == VA_BITS_SV57) -+ goto p4d; -+ else if (va_bits == VA_BITS_SV48) -+ goto pud; -+ else -+ goto pmd; -+p4d: -+ /* P4D */ -+ p4da = (p4d_t *)(pt_phys) + p4d_index(vaddr); -+ if (!readmem(PADDR, (unsigned long long)p4da, &pt_val, sizeof(pt_val))) { -+ ERRMSG("Can't read p4d\n"); -+ goto invalid; -+ } -+ -+ pt_val &= PTE_PFN_PROT_MASK; -+ -+ if (!(pt_val & _PAGE_PRESENT)) { -+ ERRMSG("Can't get a valid p4d.\n"); -+ goto invalid; -+ } -+ -+ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); -+ -+ if (pt_val & _PAGE_LEAF) -+ goto out; -+pud: -+ /* PUD */ -+ puda = (pud_t *)(pt_phys) + pud_index(vaddr); -+ if (!readmem(PADDR, (unsigned long long)puda, &pt_val, sizeof(pt_val))) { -+ ERRMSG("Can't read pud\n"); -+ goto invalid; -+ } -+ -+ pt_val &= PTE_PFN_PROT_MASK; -+ -+ if (!(pt_val & _PAGE_PRESENT)) { -+ ERRMSG("Can't get a valid pud.\n"); -+ goto invalid; -+ } -+ -+ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); -+ -+ if(pt_val & _PAGE_LEAF) -+ goto out; -+pmd: -+ /* PMD */ -+ pmda = (pmd_t *)(pt_phys) + pmd_index(vaddr); -+ if (!readmem(PADDR, (unsigned long long)pmda, &pt_val, sizeof(pt_val))) { -+ ERRMSG("Can't read pmd\n"); -+ goto invalid; -+ } -+ -+ pt_val &= PTE_PFN_PROT_MASK; -+ -+ if (!(pt_val & _PAGE_PRESENT)) { -+ ERRMSG("Can't get a valid pmd.\n"); -+ goto invalid; -+ } -+ -+ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); -+ -+ if (pt_val & _PAGE_LEAF) -+ goto out; -+ -+ /* PTE */ -+ ptea = (pte_t *)(pt_phys) + pte_index(vaddr); -+ if (!readmem(PADDR, (unsigned long long)ptea, &pt_val, sizeof(pt_val))) { -+ ERRMSG("Can't read pte\n"); -+ goto invalid; -+ } -+ -+ pt_val &= PTE_PFN_PROT_MASK; -+ -+ if (!(pt_val & _PAGE_PRESENT)) { -+ ERRMSG("Can't get a valid pte.\n"); -+ goto invalid; -+ } -+ -+ pt_phys = (pt_val >> _PAGE_PFN_SHIFT) << PAGESHIFT(); -+ -+out: -+ paddr = pt_phys + PAGEOFFSET(vaddr); -+invalid: -+ return paddr; -+} -+ -+unsigned long long -+vaddr_to_paddr_riscv64(unsigned long vaddr) -+{ -+ unsigned long long swapper_phys; -+ -+ if (vaddr >= PAGE_OFFSET && -+ !(vaddr >= NUMBER(modules_vaddr) && vaddr <= NUMBER(modules_end))){ -+ return VTOP(vaddr); -+ } -+ -+ if (SYMBOL(swapper_pg_dir) == NOT_FOUND_SYMBOL) { -+ ERRMSG("Can't get the symbol of swapper_pg_dir.\n"); -+ return NOT_PADDR; -+ } -+ -+ swapper_phys = VTOP(SYMBOL(swapper_pg_dir)); -+ -+ return vtop_riscv64((pgd_t *)swapper_phys, vaddr, NUMBER(va_bits)); -+} -+ -+#endif /* __riscv64__ */ -diff --git a/makedumpfile-1.7.3/dwarf_info.c b/makedumpfile-1.7.3/dwarf_info.c -index 543588b..a3a2fd6 100644 ---- a/makedumpfile-1.7.3/dwarf_info.c -+++ b/makedumpfile-1.7.3/dwarf_info.c -@@ -1091,6 +1091,8 @@ get_symbol_addr(char *symname) - out: - clean_dwfl_info(); - -+ DEBUG_MSG("%s : %s %llx\n", __func__, symname, symbol); -+ - return symbol; - } - -@@ -1175,6 +1177,8 @@ get_next_symbol_addr(char *symname) - out: - clean_dwfl_info(); - -+ DEBUG_MSG("%s: %s %lx\n", __func__, symname, next_symbol); -+ - return next_symbol; - } - -@@ -1192,8 +1196,12 @@ get_structure_size(char *structname, int flag_typedef) - dwarf_info.struct_name = structname; - dwarf_info.struct_size = NOT_FOUND_STRUCTURE; - -- if (!get_debug_info()) -+ if (!get_debug_info()) { -+ DEBUG_MSG("%s: %s failed\n", __func__, structname); - return FAILED_DWARFINFO; -+ } -+ -+ DEBUG_MSG("%s: %s %ld\n", __func__, structname, dwarf_info.struct_size); - - return dwarf_info.struct_size; - } -@@ -1251,8 +1259,13 @@ get_member_offset(char *structname, char *membername, int cmd) - else - dwarf_info.member_name = membername; - -- if (!get_debug_info()) -+ if (!get_debug_info()) { -+ DEBUG_MSG("%s : %s.%s failed\n", __func__, structname, membername); - return FAILED_DWARFINFO; -+ } -+ -+ DEBUG_MSG("%s : %s.%s %ld\n", __func__, structname, membername, -+ dwarf_info.member_offset); - - return dwarf_info.member_offset; - } -@@ -1309,8 +1322,12 @@ get_array_length(char *name01, char *name02, unsigned int cmd) - dwarf_info.member_offset = NOT_FOUND_STRUCTURE; - dwarf_info.array_length = NOT_FOUND_STRUCTURE; - -- if (!get_debug_info()) -+ if (!get_debug_info()) { -+ DEBUG_MSG("%s : %s.%s failed\n", __func__, name01, name02); - return FAILED_DWARFINFO; -+ } -+ -+ DEBUG_MSG("%s : %s.%s %ld\n", __func__, name01, name02, dwarf_info.array_length); - - return dwarf_info.array_length; - } -@@ -1322,8 +1339,12 @@ get_enum_number(char *enum_name) - dwarf_info.enum_name = enum_name; - dwarf_info.enum_number = NOT_FOUND_NUMBER; - -- if (!get_debug_info()) -+ if (!get_debug_info()) { -+ DEBUG_MSG("%s : %s failed\n", __func__, enum_name); - return FAILED_DWARFINFO; -+ } -+ -+ DEBUG_MSG("%s : %s %ld\n", __func__, enum_name, dwarf_info.enum_number); - - return dwarf_info.enum_number; - } -diff --git a/makedumpfile-1.7.3/makedumpfile.c b/makedumpfile-1.7.3/makedumpfile.c -index ba2bb46..a6ec9d4 100644 ---- a/makedumpfile-1.7.3/makedumpfile.c -+++ b/makedumpfile-1.7.3/makedumpfile.c -@@ -262,13 +262,17 @@ is_in_same_page(unsigned long vaddr1, unsigned long vaddr2) - return FALSE; - } - -+/* For Linux 6.6 and later */ -+#define IS_HUGETLB ((unsigned long)-1) -+ - static inline int - isHugetlb(unsigned long dtor) - { -- return ((NUMBER(HUGETLB_PAGE_DTOR) != NOT_FOUND_NUMBER) -- && (NUMBER(HUGETLB_PAGE_DTOR) == dtor)) -- || ((SYMBOL(free_huge_page) != NOT_FOUND_SYMBOL) -- && (SYMBOL(free_huge_page) == dtor)); -+ return (dtor == IS_HUGETLB) -+ || ((NUMBER(HUGETLB_PAGE_DTOR) != NOT_FOUND_NUMBER) -+ && (NUMBER(HUGETLB_PAGE_DTOR) == dtor)) -+ || ((SYMBOL(free_huge_page) != NOT_FOUND_SYMBOL) -+ && (SYMBOL(free_huge_page) == dtor)); - } - - static int -@@ -1710,6 +1714,9 @@ get_symbol_info(void) - return TRUE; - } - -+#define MOD_DATA 1 -+#define MOD_INIT_DATA 5 -+ - int - get_structure_info(void) - { -@@ -1817,6 +1824,26 @@ get_structure_info(void) - OFFSET_INIT(module.num_symtab, "module", "num_symtab"); - OFFSET_INIT(module.list, "module", "list"); - OFFSET_INIT(module.name, "module", "name"); -+ -+ /* kernel >= 6.4 */ -+ SIZE_INIT(module_memory, "module_memory"); -+ if (SIZE(module_memory) != NOT_FOUND_STRUCTURE) { -+ OFFSET_INIT(module.mem, "module", "mem"); -+ OFFSET_INIT(module_memory.base, "module_memory", "base"); -+ OFFSET_INIT(module_memory.size, "module_memory", "size"); -+ -+ OFFSET(module.module_core) = OFFSET(module.mem) + -+ SIZE(module_memory) * MOD_DATA + OFFSET(module_memory.base); -+ OFFSET(module.core_size) = OFFSET(module.mem) + -+ SIZE(module_memory) * MOD_DATA + OFFSET(module_memory.size); -+ OFFSET(module.module_init) = OFFSET(module.mem) + -+ SIZE(module_memory) * MOD_INIT_DATA + OFFSET(module_memory.base); -+ OFFSET(module.init_size) = OFFSET(module.mem) + -+ SIZE(module_memory) * MOD_INIT_DATA + OFFSET(module_memory.size); -+ -+ goto module_end; -+ } -+ - OFFSET_INIT(module.module_core, "module", "module_core"); - if (OFFSET(module.module_core) == NOT_FOUND_STRUCTURE) { - /* for kernel version 4.5 and above */ -@@ -1858,6 +1885,7 @@ get_structure_info(void) - OFFSET(module.init_size) += init_layout; - } - -+module_end: - ENUM_NUMBER_INIT(NR_FREE_PAGES, "NR_FREE_PAGES"); - ENUM_NUMBER_INIT(N_ONLINE, "N_ONLINE"); - ENUM_NUMBER_INIT(pgtable_l5_enabled, "pgtable_l5_enabled"); -@@ -1869,6 +1897,7 @@ get_structure_info(void) - ENUM_NUMBER_INIT(PG_buddy, "PG_buddy"); - ENUM_NUMBER_INIT(PG_slab, "PG_slab"); - ENUM_NUMBER_INIT(PG_hwpoison, "PG_hwpoison"); -+ ENUM_NUMBER_INIT(PG_hugetlb, "PG_hugetlb"); - - ENUM_NUMBER_INIT(PG_head_mask, "PG_head_mask"); - if (NUMBER(PG_head_mask) == NOT_FOUND_NUMBER) { -@@ -2483,6 +2512,7 @@ write_vmcoreinfo_data(void) - WRITE_NUMBER("PG_buddy", PG_buddy); - WRITE_NUMBER("PG_slab", PG_slab); - WRITE_NUMBER("PG_hwpoison", PG_hwpoison); -+ WRITE_NUMBER("PG_hugetlb", PG_hugetlb); - - WRITE_NUMBER("PAGE_BUDDY_MAPCOUNT_VALUE", PAGE_BUDDY_MAPCOUNT_VALUE); - WRITE_NUMBER("PAGE_OFFLINE_MAPCOUNT_VALUE", -@@ -2932,6 +2962,7 @@ read_vmcoreinfo(void) - READ_NUMBER("PG_slab", PG_slab); - READ_NUMBER("PG_buddy", PG_buddy); - READ_NUMBER("PG_hwpoison", PG_hwpoison); -+ READ_NUMBER("PG_hugetlb", PG_hugetlb); - READ_NUMBER("SECTION_SIZE_BITS", SECTION_SIZE_BITS); - READ_NUMBER("MAX_PHYSMEM_BITS", MAX_PHYSMEM_BITS); - -@@ -2948,6 +2979,20 @@ read_vmcoreinfo(void) - READ_NUMBER_UNSIGNED("kimage_voffset", kimage_voffset); - #endif - -+#ifdef __riscv64__ -+ READ_NUMBER("VA_BITS", va_bits); -+ READ_NUMBER_UNSIGNED("phys_ram_base", phys_ram_base); -+ READ_NUMBER_UNSIGNED("PAGE_OFFSET", page_offset); -+ READ_NUMBER_UNSIGNED("VMALLOC_START", vmalloc_start); -+ READ_NUMBER_UNSIGNED("VMALLOC_END", vmalloc_end); -+ READ_NUMBER_UNSIGNED("VMEMMAP_START", vmemmap_start); -+ READ_NUMBER_UNSIGNED("VMEMMAP_END", vmemmap_end); -+ READ_NUMBER_UNSIGNED("MODULES_VADDR", modules_vaddr); -+ READ_NUMBER_UNSIGNED("MODULES_END", modules_end); -+ READ_NUMBER_UNSIGNED("KERNEL_LINK_ADDR", kernel_link_addr); -+ READ_NUMBER_UNSIGNED("va_kernel_pa_offset", va_kernel_pa_offset); -+#endif -+ - READ_NUMBER("HUGETLB_PAGE_DTOR", HUGETLB_PAGE_DTOR); - - return TRUE; -@@ -3264,7 +3309,11 @@ get_mm_flatmem(void) - if (is_xen_memory()) - dump_mem_map(0, info->dom0_mapnr, mem_map, 0); - else -+#ifdef __riscv64__ -+ dump_mem_map((info->phys_base >> PAGESHIFT()), info->max_mapnr, mem_map, 0); -+#else - dump_mem_map(0, info->max_mapnr, mem_map, 0); -+#endif - - return TRUE; - } -@@ -6451,6 +6500,21 @@ __exclude_unnecessary_pages(unsigned long mem_map, - if ((index_pg < PGMM_CACHED - 1) && isCompoundHead(flags)) { - unsigned char *addr = pcache + SIZE(page); - -+ /* -+ * Linux 6.6 and later. Kernels that have PG_hugetlb should also -+ * have the compound order in the low byte of folio._flags_1. -+ */ -+ if (NUMBER(PG_hugetlb) != NOT_FOUND_NUMBER) { -+ unsigned long _flags_1 = ULONG(addr + OFFSET(page.flags)); -+ -+ compound_order = _flags_1 & 0xff; -+ -+ if (_flags_1 & (1UL << NUMBER(PG_hugetlb))) -+ compound_dtor = IS_HUGETLB; -+ -+ goto check_order; -+ } -+ - if (order_offset) { - if (info->kernel_version >= KERNEL_VERSION(4, 16, 0)) - compound_order = UCHAR(addr + order_offset); -@@ -6470,7 +6534,7 @@ __exclude_unnecessary_pages(unsigned long mem_map, - else - compound_dtor = ULONG(addr + dtor_offset); - } -- -+check_order: - if ((compound_order >= sizeof(unsigned long) * 8) - || ((pfn & ((1UL << compound_order) - 1)) != 0)) { - /* Invalid order */ -diff --git a/makedumpfile-1.7.3/makedumpfile.h b/makedumpfile-1.7.3/makedumpfile.h -index 99ccf0a..59a809c 100644 ---- a/makedumpfile-1.7.3/makedumpfile.h -+++ b/makedumpfile-1.7.3/makedumpfile.h -@@ -498,7 +498,7 @@ do { \ - #define KVER_MIN_SHIFT 16 - #define KERNEL_VERSION(x,y,z) (((x) << KVER_MAJ_SHIFT) | ((y) << KVER_MIN_SHIFT) | (z)) - #define OLDEST_VERSION KERNEL_VERSION(2, 6, 15) /* linux-2.6.15 */ --#define LATEST_VERSION KERNEL_VERSION(6, 3, 0) /* linux-6.3.0 */ -+#define LATEST_VERSION KERNEL_VERSION(6, 6, 0) /* linux-6.6.0 */ - - /* - * vmcoreinfo in /proc/vmcore -@@ -678,6 +678,12 @@ unsigned long get_kvbase_arm64(void); - #define REGION_SHIFT (60UL) - #define VMEMMAP_REGION_ID (0xfUL) - -+/* -+ * If PAGE_PTE is set, then it's a leaf PTE for hugepage -+ */ -+#define PAGE_PTE (1UL << 62) -+#define IS_HUGEPAGE(pte) (!!((pte) & PAGE_PTE)) -+ - /* 4-level page table support */ - - /* 4K pagesize */ -@@ -1046,6 +1052,77 @@ typedef unsigned long pgd_t; - - #endif /* loongarch64 */ - -+#ifdef __riscv64__ -+/* -+ * Referencing the riscv64_is_kvaddr() in Crash-utility, -+ * set the vmemmap start address as the lowest kernel virtual base. -+ */ -+#define KVBASE (NUMBER(vmemmap_start)) -+#define _SECTION_SIZE_BITS (27) -+#define _MAX_PHYSMEM_BITS (56) -+ -+typedef ulong pgd_t; -+typedef ulong p4d_t; -+typedef ulong pud_t; -+typedef ulong pmd_t; -+typedef ulong pte_t; -+ -+/* arch/riscv/include/asm/pgtable-64.h */ -+ -+#define PGD_SHIFT_L3 (30) -+#define PGD_SHIFT_L4 (39) -+#define PGD_SHIFT_L5 (48) -+ -+#define P4D_SHIFT (39) -+#define PUD_SHIFT (30) -+#define PMD_SHIFT (21) -+ -+#define PTRS_PER_PGD (512) -+#define PTRS_PER_P4D (512) -+#define PTRS_PER_PUD (512) -+#define PTRS_PER_PMD (512) -+#define PTRS_PER_PTE (512) -+ -+/* -+ * 3/4/5-levels pg indexs -+ */ -+#define pgd_index_l3(addr) (((addr) >> PGD_SHIFT_L3) & (PTRS_PER_PGD - 1)) -+#define pgd_index_l4(addr) (((addr) >> PGD_SHIFT_L4) & (PTRS_PER_PGD - 1)) -+#define pgd_index_l5(addr) (((addr) >> PGD_SHIFT_L5) & (PTRS_PER_PGD - 1)) -+#define p4d_index(addr) (((addr) >> P4D_SHIFT) & (PTRS_PER_P4D - 1)) -+#define pud_index(addr) (((addr) >> PUD_SHIFT) & (PTRS_PER_PUD - 1)) -+#define pmd_index(addr) (((addr) >> PMD_SHIFT) & (PTRS_PER_PMD - 1)) -+#define pte_index(addr) (((addr) >> PAGESHIFT()) & (PTRS_PER_PTE - 1)) -+ -+/* arch/riscv/include/asm/pgtable-bits.h */ -+ -+#define _PAGE_PRESENT (1 << 0) -+#define _PAGE_READ (1 << 1) /* Readable */ -+#define _PAGE_WRITE (1 << 2) /* Writable */ -+#define _PAGE_EXEC (1 << 3) /* Executable */ -+#define _PAGE_USER (1 << 4) /* User */ -+#define _PAGE_GLOBAL (1 << 5) /* Global */ -+#define _PAGE_ACCESSED (1 << 6) /* Set by hardware on any access */ -+#define _PAGE_DIRTY (1 << 7) /* Set by hardware on any write */ -+#define _PAGE_SOFT (1 << 8) /* Reserved for software */ -+ -+#define _PAGE_PFN_SHIFT (10) -+#define _PAGE_LEAF (_PAGE_READ | _PAGE_WRITE | _PAGE_EXEC) -+ -+/* -+ * Mask for bit 0~53(PROT and PPN) of PTE -+ * 63 6261 60 54 53 10 9 8 7 6 5 4 3 2 1 0 -+ * N PBMT Reserved P P N RSW D A G U X W R V -+ */ -+#define PTE_PFN_PROT_MASK 0x3FFFFFFFFFFFFF -+ -+#define VA_BITS_SV39 (39) -+#define VA_BITS_SV48 (48) -+#define VA_BITS_SV57 (57) -+ -+#endif /* riscv64 */ -+ -+ - /* - * The function of dependence on machine - */ -@@ -1233,6 +1310,22 @@ unsigned long long vaddr_to_paddr_loongarch64(unsigned long vaddr); - #define arch_crashkernel_mem_size() stub_false() - #endif /* loongarch64 */ - -+#ifdef __riscv64__ -+int get_phys_base_riscv64(void); -+int get_machdep_info_riscv64(void); -+unsigned long long vaddr_to_paddr_riscv64(unsigned long vaddr); -+#define paddr_to_vaddr_riscv64(X) ((X) + PAGE_OFFSET - info->phys_base) -+#define find_vmemmap() stub_false() -+#define get_phys_base() get_phys_base_riscv64() -+#define get_machdep_info() get_machdep_info_riscv64() -+#define get_versiondep_info() stub_true() -+#define get_kaslr_offset(X) stub_false() -+#define vaddr_to_paddr(X) vaddr_to_paddr_riscv64(X) -+#define paddr_to_vaddr(X) paddr_to_vaddr_riscv64(X) -+#define is_phys_addr(X) stub_true_ul(X) -+#define arch_crashkernel_mem_size() stub_false() -+#endif /* riscv64 */ -+ - typedef unsigned long long mdf_pfn_t; - - #ifndef ARCH_PFN_OFFSET -@@ -1842,6 +1935,7 @@ struct size_table { - * for loading module symbol data - */ - long module; -+ long module_memory; - - /* - * for sadump -@@ -1944,8 +2038,14 @@ struct offset_table { - long num_symtab; - long symtab; - long strtab; -+ long mem; - } module; - -+ struct module_memory { -+ long base; -+ long size; -+ } module_memory; -+ - /* - * for loading elf_prstaus symbol data - */ -@@ -2131,6 +2231,7 @@ struct number_table { - long PG_buddy; - long PG_slab; - long PG_hwpoison; -+ long PG_hugetlb; - - long PAGE_BUDDY_MAPCOUNT_VALUE; - long PAGE_OFFLINE_MAPCOUNT_VALUE; -@@ -2145,6 +2246,19 @@ struct number_table { - unsigned long PHYS_OFFSET; - unsigned long kimage_voffset; - #endif -+#ifdef __riscv64__ -+ long va_bits; -+ unsigned long phys_ram_base; -+ unsigned long page_offset; -+ unsigned long vmalloc_start; -+ unsigned long vmalloc_end; -+ unsigned long vmemmap_start; -+ unsigned long vmemmap_end; -+ unsigned long modules_vaddr; -+ unsigned long modules_end; -+ unsigned long kernel_link_addr; -+ unsigned long va_kernel_pa_offset; -+#endif - }; - - struct srcfile_table { -@@ -2383,6 +2497,12 @@ int get_xen_info_ia64(void); - #define get_xen_info_arch(X) FALSE - #endif /* loongarch64 */ - -+#ifdef __riscv64__ /* riscv64 */ -+#define kvtop_xen(X) FALSE -+#define get_xen_basic_info_arch(X) FALSE -+#define get_xen_info_arch(X) FALSE -+#endif /* riscv64 */ -+ - struct cycle { - mdf_pfn_t start_pfn; - mdf_pfn_t end_pfn; -diff --git a/makedumpfile-1.7.3/makedumpfile.spec b/makedumpfile-1.7.3/makedumpfile.spec -index 182db54..3b53847 100644 ---- a/makedumpfile-1.7.3/makedumpfile.spec -+++ b/makedumpfile-1.7.3/makedumpfile.spec -@@ -1,6 +1,6 @@ - Name: makedumpfile - Summary: makedumpfile package --Version: 1.7.3 -+Version: 1.7.4 - Release: 1 - Group: Applications/Text - License: GPL --- -2.34.1 - -- Gitee From ae988f12b29989745e39e115884b3762bcf8fd24 Mon Sep 17 00:00:00 2001 From: Ming Wang Date: Mon, 6 Jan 2025 15:08:17 +0800 Subject: [PATCH 7/7] Fix loongarch64 kdump image size overflow issue. Signed-off-by: Ming Wang --- ...ge-exclusion-in-exclude_nodata_pages.patch | 26 ++ kdump.sysconfig.loongarch64 | 8 +- kexec-tools.spec | 7 +- loongarch64-fix-kernel-image-size-error.patch | 245 ++++++++++++++++++ 4 files changed, 281 insertions(+), 5 deletions(-) create mode 100644 Fix-incorrect-page-exclusion-in-exclude_nodata_pages.patch mode change 100755 => 100644 kdump.sysconfig.loongarch64 create mode 100644 loongarch64-fix-kernel-image-size-error.patch diff --git a/Fix-incorrect-page-exclusion-in-exclude_nodata_pages.patch b/Fix-incorrect-page-exclusion-in-exclude_nodata_pages.patch new file mode 100644 index 0000000..4eefd63 --- /dev/null +++ b/Fix-incorrect-page-exclusion-in-exclude_nodata_pages.patch @@ -0,0 +1,26 @@ +From fe71ffabcc7e5787b0bcf0b4cfcdab83182b84fd Mon Sep 17 00:00:00 2001 +From: Ming Wang +Date: Mon, 14 Oct 2024 16:23:08 +0800 +Subject: [PATCH] Fix incorrect page exclusion in exclude_nodata_pages() + +Signed-off-by: Ming Wang +--- + makedumpfile-1.7.4/makedumpfile.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/makedumpfile-1.7.4/makedumpfile.c b/makedumpfile-1.7.4/makedumpfile.c +index a6ec9d4..4ddbf4d 100644 +--- a/makedumpfile-1.7.4/makedumpfile.c ++++ b/makedumpfile-1.7.4/makedumpfile.c +@@ -5192,7 +5192,7 @@ exclude_nodata_pages(struct cycle *cycle) + NULL, &file_size)) { + unsigned long long pfn, pfn_end; + +- pfn = paddr_to_pfn(phys_start + file_size); ++ pfn = paddr_to_pfn(roundup(phys_start + file_size, PAGESIZE())); + pfn_end = paddr_to_pfn(roundup(phys_end, PAGESIZE())); + + if (pfn < cycle->start_pfn) +-- +2.41.0 + diff --git a/kdump.sysconfig.loongarch64 b/kdump.sysconfig.loongarch64 old mode 100755 new mode 100644 index 86c6d89..5fe26bd --- a/kdump.sysconfig.loongarch64 +++ b/kdump.sysconfig.loongarch64 @@ -21,7 +21,7 @@ KDUMP_COMMANDLINE_REMOVE="hugepages hugepagesz slub_debug quiet log_buf_len rd_s # This variable lets us append arguments to the current kdump commandline # after processed by KDUMP_COMMANDLINE_REMOVE -KDUMP_COMMANDLINE_APPEND="nr_cpus=1 init 3 irqpoll reset_devices cgroup_disable=memory udev.children-max=2 panic=10 novmcoredd" +KDUMP_COMMANDLINE_APPEND="nr_cpus=1 init 3 irqpoll reset_devices cgroup_disable=memory udev.children-max=2 panic=10 novmcoredd nokaslr" # Any additional kexec arguments required. In most situations, this should # be left empty @@ -34,7 +34,7 @@ KEXEC_ARGS="" #KDUMP_BOOTDIR="/boot" #What is the image type used for kdump -KDUMP_IMG="vmlinux" +KDUMP_IMG="vmlinuz" #Please replace with the capture kernel to be reboot and the #the corresponding initrd only for LoongArch architecture @@ -43,10 +43,10 @@ KDUMP_IMG="vmlinux" # DEFAULT_TARGET_INITRD="/boot/initramfs-4.19.190-4.lns8.loongarch64+kdump.img" # If a DEFAULT_KDUMP_KERNEL is not specified, the default is set to # "/boot/vmlinux-$(uname -r)+kdump" -DEFAULT_KDUMP_KERNEL="" +# DEFAULT_KDUMP_KERNEL="" # If a DEFAULT_TARGET_INITRD is not specified, the default is set to # "/boot/initramfs-$(uname -r)+kdump.img" -DEFAULT_TARGET_INITRD="" +# DEFAULT_TARGET_INITRD="" # Logging is controlled by following variables in the first kernel: # - @var KDUMP_STDLOGLVL - logging level to standard error (console output) diff --git a/kexec-tools.spec b/kexec-tools.spec index b7dd693..50f7822 100644 --- a/kexec-tools.spec +++ b/kexec-tools.spec @@ -4,7 +4,7 @@ Name: kexec-tools Version: 2.0.26 -Release: 9 +Release: 10 License: GPLv2 Summary: The kexec/kdump userspace component URL: https://www.kernel.org/ @@ -86,6 +86,8 @@ Patch0007: kexec-tools-fix-riscv-support.patch %ifarch loongarch64 Patch0008: Add-loongarch-iomem.h.patch +Patch0009: Fix-incorrect-page-exclusion-in-exclude_nodata_pages.patch +Patch00010: loongarch64-fix-kernel-image-size-error.patch %endif %description @@ -295,6 +297,9 @@ done %endif %changelog +* Mon Jan 6 2025 Ming Wang - 2.0.26-10 +- Fix loongarch kdump image size overflow issue. + * Fri Sep 20 2024 chenguokai - 2.0.26-9 - Fix multiple issues of riscv image format & initrd support diff --git a/loongarch64-fix-kernel-image-size-error.patch b/loongarch64-fix-kernel-image-size-error.patch new file mode 100644 index 0000000..2659815 --- /dev/null +++ b/loongarch64-fix-kernel-image-size-error.patch @@ -0,0 +1,245 @@ +From 510981a6b810c18d1bc3f5917ad743f3a6c85cf7 Mon Sep 17 00:00:00 2001 +From: Ming Wang +Date: Fri, 17 May 2024 10:39:31 +0800 +Subject: [PATCH] kexec: loongarch: fix some issue. + +Signed-off-by: Hongchen Zhang +Signed-off-by: Ming Wang +--- + kexec/arch/loongarch/crashdump-loongarch.c | 22 ++++++++++++ + kexec/arch/loongarch/crashdump-loongarch.h | 1 + + kexec/arch/loongarch/kexec-elf-loongarch.c | 40 +++++++++++++++++++--- + kexec/arch/loongarch/kexec-loongarch.c | 22 ++++++++---- + kexec/arch/loongarch/kexec-pei-loongarch.c | 7 ++++ + kexec/kexec-syscall.h | 2 +- + 6 files changed, 82 insertions(+), 12 deletions(-) + +diff --git a/kexec/arch/loongarch/crashdump-loongarch.c b/kexec/arch/loongarch/crashdump-loongarch.c +index aaf6cf3..81250e4 100644 +--- a/kexec/arch/loongarch/crashdump-loongarch.c ++++ b/kexec/arch/loongarch/crashdump-loongarch.c +@@ -183,6 +183,28 @@ int load_crashdump_segments(struct kexec_info *info) + return 0; + } + ++/* ++ * e_entry and p_paddr are actually in virtual address space. ++ * Those values will be translated to physcal addresses by using ++ * virt_to_phys() in add_segment(). ++ * So let's fix up those values for later use so the memory base will be ++ * correctly replaced with crash_reserved_mem[usablemem_rgns.size - 1].start. ++ */ ++void fixup_elf_addrs(struct mem_ehdr *ehdr) ++{ ++ struct mem_phdr *phdr; ++ int i; ++ ++ ehdr->e_entry += crash_reserved_mem[usablemem_rgns.size - 1].start; ++ ++ for (i = 0; i < ehdr->e_phnum; i++) { ++ phdr = &ehdr->e_phdr[i]; ++ if (phdr->p_type != PT_LOAD) ++ continue; ++ phdr->p_paddr += crash_reserved_mem[usablemem_rgns.size - 1].start; ++ } ++} ++ + int get_crash_kernel_load_range(uint64_t *start, uint64_t *end) + { + if (!usablemem_rgns.size) +diff --git a/kexec/arch/loongarch/crashdump-loongarch.h b/kexec/arch/loongarch/crashdump-loongarch.h +index 3eb4e0a..25ff24b 100644 +--- a/kexec/arch/loongarch/crashdump-loongarch.h ++++ b/kexec/arch/loongarch/crashdump-loongarch.h +@@ -8,6 +8,7 @@ extern struct memory_range elfcorehdr_mem; + + int load_crashdump_segments(struct kexec_info *info); + int is_crashkernel_mem_reserved(void); ++void fixup_elf_addrs(struct mem_ehdr *ehdr); + int get_crash_kernel_load_range(uint64_t *start, uint64_t *end); + + #define PAGE_OFFSET 0x9000000000000000ULL +diff --git a/kexec/arch/loongarch/kexec-elf-loongarch.c b/kexec/arch/loongarch/kexec-elf-loongarch.c +index 2bf128f..7e84d03 100644 +--- a/kexec/arch/loongarch/kexec-elf-loongarch.c ++++ b/kexec/arch/loongarch/kexec-elf-loongarch.c +@@ -54,6 +54,7 @@ int elf_loongarch_load(int argc, char **argv, const char *kernel_buf, + unsigned long kernel_segment; + struct mem_ehdr ehdr; + int result; ++ int i; + + result = build_elf_exec_info(kernel_buf, kernel_size, &ehdr, 0); + +@@ -62,6 +63,26 @@ int elf_loongarch_load(int argc, char **argv, const char *kernel_buf, + goto exit; + } + ++ /* Find and process the loongarch image header. */ ++ for (i = 0; i < ehdr.e_phnum; i++) { ++ struct mem_phdr *phdr = &ehdr.e_phdr[i]; ++ ++ if (phdr->p_type != PT_LOAD) ++ continue; ++ ++ header = (const struct loongarch_image_header *)( ++ kernel_buf + phdr->p_offset); ++ ++ if (!loongarch_process_image_header(header)) ++ break; ++ } ++ ++ if (i == ehdr.e_phnum) { ++ dbgprintf("%s: Valid loongarch image header not found\n", __func__); ++ result = EFAILED; ++ goto exit; ++ } ++ + kernel_segment = loongarch_locate_kernel_segment(info); + + if (kernel_segment == ULONG_MAX) { +@@ -72,13 +93,12 @@ int elf_loongarch_load(int argc, char **argv, const char *kernel_buf, + + dbgprintf("%s: kernel_segment: %016lx\n", __func__, kernel_segment); + dbgprintf("%s: image_size: %016lx\n", __func__, +- kernel_size); ++ loongarch_mem.image_size); + dbgprintf("%s: text_offset: %016lx\n", __func__, + loongarch_mem.text_offset); + dbgprintf("%s: phys_offset: %016lx\n", __func__, + loongarch_mem.phys_offset); +- dbgprintf("%s: PE format: %s\n", __func__, +- (loongarch_header_check_pe_sig(header) ? "yes" : "no")); ++ dbgprintf("%s: PE format: no\n", __func__); + + /* create and initialize elf core header segment */ + if (info->kexec_flags & KEXEC_ON_CRASH) { +@@ -90,6 +110,14 @@ int elf_loongarch_load(int argc, char **argv, const char *kernel_buf, + } + } + ++ /* load the kernel */ ++ if (info->kexec_flags & KEXEC_ON_CRASH) ++ /* ++ * offset addresses in elf header in order to load ++ * vmlinux (elf_exec) into crash kernel's memory. ++ */ ++ fixup_elf_addrs(&ehdr); ++ + info->entry = (void *)virt_to_phys(ehdr.e_entry); + + result = elf_exec_load(&ehdr, info); +@@ -99,8 +127,12 @@ int elf_loongarch_load(int argc, char **argv, const char *kernel_buf, + goto exit; + } + ++ /* for vmlinuz kernel image */ ++ if (kernel_size < MiB(16)) ++ kernel_size = MiB(64); ++ + /* load additional data */ +- result = loongarch_load_other_segments(info, kernel_segment + kernel_size); ++ result = loongarch_load_other_segments(info, kernel_segment + loongarch_mem.image_size); + + exit: + free_elf_info(&ehdr); +diff --git a/kexec/arch/loongarch/kexec-loongarch.c b/kexec/arch/loongarch/kexec-loongarch.c +index 4c7361c..6485080 100644 +--- a/kexec/arch/loongarch/kexec-loongarch.c ++++ b/kexec/arch/loongarch/kexec-loongarch.c +@@ -221,6 +221,10 @@ int arch_process_options(int argc, char **argv) + cmdline = get_command_line(); + remove_parameter(cmdline, "kexec"); + remove_parameter(cmdline, "initrd"); ++ remove_parameter(cmdline, "rd_start"); ++ remove_parameter(cmdline, "rd_size"); ++ remove_parameter(cmdline, "vfio_iommu_type1.allow_unsafe_interrupts"); ++ remove_parameter(cmdline, "nokaslr"); + break; + case OPT_INITRD: + arch_options.initrd_file = optarg; +@@ -253,8 +257,9 @@ unsigned long loongarch_locate_kernel_segment(struct kexec_info *info) + unsigned long hole_end; + + hole = (crash_reserved_mem[usablemem_rgns.size - 1].start < mem_min ? +- mem_min : crash_reserved_mem[usablemem_rgns.size - 1].start); +- hole = _ALIGN_UP(hole, MiB(1)); ++ mem_min : crash_reserved_mem[usablemem_rgns.size - 1].start) + ++ loongarch_mem.text_offset; ++ hole = _ALIGN_UP(hole, MiB(16)); + hole_end = hole + loongarch_mem.text_offset + loongarch_mem.image_size; + + if ((hole_end > mem_max) || +@@ -265,7 +270,7 @@ unsigned long loongarch_locate_kernel_segment(struct kexec_info *info) + } else { + hole = locate_hole(info, + loongarch_mem.text_offset + loongarch_mem.image_size, +- MiB(1), 0, ULONG_MAX, 1); ++ MiB(16), 0, ULONG_MAX, 1); + + if (hole == ULONG_MAX) + dbgprintf("%s: locate_hole failed\n", __func__); +@@ -283,6 +288,7 @@ int loongarch_load_other_segments(struct kexec_info *info, unsigned long hole_mi + unsigned long initrd_min, hole_max; + char *initrd_buf = NULL; + unsigned long pagesize = getpagesize(); ++ int i; + + if (arch_options.command_line) { + if (strlen(arch_options.command_line) > +@@ -320,15 +326,17 @@ int loongarch_load_other_segments(struct kexec_info *info, unsigned long hole_mi + cmdline_add_elfcorehdr(cmdline, elfcorehdr_mem.start, + elfcorehdr_mem.end - elfcorehdr_mem.start + 1); + +- cmdline_add_mem(cmdline, crash_reserved_mem[usablemem_rgns.size - 1].start, +- crash_reserved_mem[usablemem_rgns.size - 1].end - +- crash_reserved_mem[usablemem_rgns.size - 1].start + 1); ++ for(i = 0;i < usablemem_rgns.size; i++) { ++ cmdline_add_mem(cmdline, crash_reserved_mem[i].start, ++ crash_reserved_mem[i].end - ++ crash_reserved_mem[i].start + 1); ++ } + } + + cmdline[sizeof(cmdline) - 1] = 0; + add_buffer(info, cmdline, sizeof(cmdline), sizeof(cmdline), + sizeof(void *), _ALIGN_UP(hole_min, getpagesize()), +- 0xffffffff, 1); ++ hole_max, 1); + + dbgprintf("%s:%d: command_line: %s\n", __func__, __LINE__, cmdline); + +diff --git a/kexec/arch/loongarch/kexec-pei-loongarch.c b/kexec/arch/loongarch/kexec-pei-loongarch.c +index f86ac61..1a11103 100644 +--- a/kexec/arch/loongarch/kexec-pei-loongarch.c ++++ b/kexec/arch/loongarch/kexec-pei-loongarch.c +@@ -66,6 +66,13 @@ int pei_loongarch_load(int argc, char **argv, const char *buf, + + kernel_entry = virt_to_phys(loongarch_header_kernel_entry(header)); + ++ if (info->kexec_flags & KEXEC_ON_CRASH) ++ /* ++ * offset addresses in order to load vmlinux.efi into ++ * crash kernel's memory. ++ */ ++ kernel_entry += crash_reserved_mem[usablemem_rgns.size - 1].start; ++ + dbgprintf("%s: kernel_segment: %016lx\n", __func__, kernel_segment); + dbgprintf("%s: kernel_entry: %016lx\n", __func__, kernel_entry); + dbgprintf("%s: image_size: %016lx\n", __func__, +diff --git a/kexec/kexec-syscall.h b/kexec/kexec-syscall.h +index e392c01..f18b014 100644 +--- a/kexec/kexec-syscall.h ++++ b/kexec/kexec-syscall.h +@@ -59,7 +59,7 @@ + #endif + #endif /*ifndef __NR_kexec_load*/ + +-#ifdef __arm__ ++#if defined(__arm__) || defined(__loongarch__) + #undef __NR_kexec_file_load + #endif + +-- +2.43.0 + -- Gitee

8<{V;zQ@>J5aB9vF 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ξ#Z>YNR1g;1YDlMDh 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 diff --git a/makedumpfile-1.7.4.tar.gz b/makedumpfile-1.7.4.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..033903cb1af025ff3a2f51e2bba8371492589a8f GIT binary patch literal 209058 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%0D2y_B=kT9w+p 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