From deb14f21d21df81877d8a31624226126df5de3689a97d1123780ce86014f29c5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Tesa=C5=99=C3=ADk?= Date: Sun, 4 Apr 2021 08:44:45 +0000 Subject: [PATCH 1/3] Accepting request 882186 from home:pmladek:branches:Kernel:kdump These changes allowed me to produce crashfump with kernel-5.11 from Kernel:stable project: - Update to version 1.6.8: * Support newer kernels up to v5.9 * arm64: Add support for ARMv8.2-LPA (52-bit PA support) * Retrieve MAX_PHYSMEM_BITS from vmcoreinfo * sadump, kaslr: fix failure of calculating kaslr_offset * Introduce --check-params option * cope with not-present mem section - Drop upstreamed patches: * makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch * makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch * makedumpfile-sadump-Fix-failure-of-reading.patch - Allow to read kernel log from the lockless ringbuffer (bsc#1183965): * makedumpfile-printk-add-support-for-lockless-ringbuffer.patch * makedumpfile-printk-use-committed-finalized-state-value.patch OBS-URL: https://build.opensuse.org/request/show/882186 OBS-URL: https://build.opensuse.org/package/show/Kernel:kdump/makedumpfile?expand=0&rev=149 --- makedumpfile-1.6.7.tar.gz | 3 - makedumpfile-1.6.8.tar.gz | 3 + ...eader-offset-overflow-with-large-pfn.patch | 44 -- ...lign-PMD_SECTION_MASK-with-PHYS_MASK.patch | 38 -- ...-add-support-for-lockless-ringbuffer.patch | 589 ++++++++++++++++++ ...-use-committed-finalized-state-value.patch | 101 +++ ...mpfile-sadump-Fix-failure-of-reading.patch | 54 -- makedumpfile.changes | 18 + makedumpfile.spec | 9 +- 9 files changed, 715 insertions(+), 144 deletions(-) delete mode 100644 makedumpfile-1.6.7.tar.gz create mode 100644 makedumpfile-1.6.8.tar.gz delete mode 100644 makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch delete mode 100644 makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch create mode 100644 makedumpfile-printk-add-support-for-lockless-ringbuffer.patch create mode 100644 makedumpfile-printk-use-committed-finalized-state-value.patch delete mode 100644 makedumpfile-sadump-Fix-failure-of-reading.patch diff --git a/makedumpfile-1.6.7.tar.gz b/makedumpfile-1.6.7.tar.gz deleted file mode 100644 index 889570a..0000000 --- a/makedumpfile-1.6.7.tar.gz +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:e702fbdf62b4cd829a76e46f3e24eb3fc7501918b85ebdcd8baef4f53d6ee2c8 -size 194672 diff --git a/makedumpfile-1.6.8.tar.gz b/makedumpfile-1.6.8.tar.gz new file mode 100644 index 0000000..eb5245a --- /dev/null +++ b/makedumpfile-1.6.8.tar.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:85d79b7090e9a8ce0d426795d3bc1de2858def7e12954d9bc6ae03de160b694c +size 195709 diff --git a/makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch b/makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch deleted file mode 100644 index abb7bf8..0000000 --- a/makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch +++ /dev/null @@ -1,44 +0,0 @@ -From 6e4b2dfaed5e5e5c617e0e45f969c1f571c13e27 Mon Sep 17 00:00:00 2001 -From: Jialong Chen -Date: Mon, 23 Mar 2020 16:42:01 -0400 -Subject: Fix cd_header offset overflow with large pfn -Upstream: merged (expected 1.6.8) -Git-commit: 6e4b2dfaed5e5e5c617e0e45f969c1f571c13e27 - -In function write_kdump_pages_and_bitmap_cyclic(), cd_header->offset is -calculated by the following formula: - - cd_header->offset - = (DISKDUMP_HEADER_BLOCKS + dh->sub_hdr_size + dh->bitmap_blocks) - * dh->block_size; - -However, the variables of the right side are only int and unsigned int, -so if dh->bitmap_blocks is very large, it causes an interger overflow. - -As a result, makedumpfile created a broken vmcore in a system with a -physical address range from 0x602770ecf000 to 0x6027ffffffff, and the -crash utility failed during session initialization, ending with the -error message "crash: vmlinux and vmcore do not match!". - -Signed-off-by: Jialong Chen -Signed-off-by: Kazuhito Hagio ---- - diskdump_mod.h | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/diskdump_mod.h b/diskdump_mod.h -index 267681712a2a..3733953dee12 100644 ---- a/diskdump_mod.h -+++ b/diskdump_mod.h -@@ -22,7 +22,7 @@ - #define DISK_DUMP_SIGNATURE "DISKDUMP" - #define KDUMP_SIGNATURE "KDUMP " - #define SIG_LEN (sizeof(DUMP_PARTITION_SIGNATURE) - 1) --#define DISKDUMP_HEADER_BLOCKS (1) -+#define DISKDUMP_HEADER_BLOCKS (1UL) - - /* - * These are all remnants of the old "diskdump" facility, --- -2.23.0 - diff --git a/makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch b/makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch deleted file mode 100644 index 8fafde2..0000000 --- a/makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch +++ /dev/null @@ -1,38 +0,0 @@ -From 7242ae4cb5288df626f464ced0a8b60fd669100b Mon Sep 17 00:00:00 2001 -From: Michal Suchanek -Date: Mon, 16 Mar 2020 19:39:58 +0100 -Subject: Align PMD_SECTION_MASK with PHYS_MASK -Upstream: merged (expected 1.6.8) -Git-commit: 7242ae4cb5288df626f464ced0a8b60fd669100b - -Reportedly on some arm64 systems makedumpfile loops forever exhausting -all memory when filtering kernel core. It turns out the reason is it -cannot resolve some addresses because the PMD mask is wrong. When -physical address mask allows up to 48bits pmd mask should allow the -same. -I suppose you would need a system that needs physical addresses over 1TB -to be able to reproduce this. This may be either because you have a lot -of memory or because the firmware mapped some memory above 1TB for some -reason. - -Signed-off-by: Michal Suchanek ---- - arch/arm64.c | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - -diff --git a/arch/arm64.c b/arch/arm64.c -index 43164ccc32d4..54d60b440850 100644 ---- a/arch/arm64.c -+++ b/arch/arm64.c -@@ -81,7 +81,7 @@ static unsigned long kimage_voffset; - * Remove the highest order bits that are not a part of the - * physical address in a section - */ --#define PMD_SECTION_MASK ((1UL << 40) - 1) -+#define PMD_SECTION_MASK ((1UL << PHYS_MASK_SHIFT) - 1) - - #define PMD_TYPE_MASK 3 - #define PMD_TYPE_SECT 1 --- -2.23.0 - diff --git a/makedumpfile-printk-add-support-for-lockless-ringbuffer.patch b/makedumpfile-printk-add-support-for-lockless-ringbuffer.patch new file mode 100644 index 0000000..7ea2aa5 --- /dev/null +++ b/makedumpfile-printk-add-support-for-lockless-ringbuffer.patch @@ -0,0 +1,589 @@ +From c617ec63339222f3a44d73e36677a9acc8954ccd Mon Sep 17 00:00:00 2001 +From: John Ogness +Date: Thu, 19 Nov 2020 02:41:21 +0000 +Subject: [PATCH 1/2] [PATCH 1/2] printk: add support for lockless ringbuffer +Upstream: merged (expected 1.6.9) +Git-commit: c617ec63339222f3a44d73e36677a9acc8954ccd + +* Required for kernel 5.10 + +Linux 5.10 introduces a new lockless ringbuffer. The new ringbuffer +is structured completely different to the previous iterations. +Add support for retrieving the ringbuffer from debug information +and/or using vmcoreinfo. The new ringbuffer is detected based on +the availability of the "prb" symbol. + +Signed-off-by: John Ogness +Signed-off-by: Kazuhito Hagio +--- + Makefile | 2 +- + dwarf_info.c | 36 ++++++++- + makedumpfile.c | 103 +++++++++++++++++++++++- + makedumpfile.h | 58 ++++++++++++++ + printk.c | 207 +++++++++++++++++++++++++++++++++++++++++++++++++ + 5 files changed, 399 insertions(+), 7 deletions(-) + create mode 100644 printk.c + +diff --git a/Makefile b/Makefile +index e5ac71a83778..cb6bd42ce738 100644 +--- a/Makefile ++++ b/Makefile +@@ -45,7 +45,7 @@ CFLAGS_ARCH += -m32 + 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 ++SRC_PART = print_info.c dwarf_info.c elf_info.c erase_info.c sadump_info.c cache.c tools.c printk.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 + OBJ_ARCH=$(patsubst %.c,%.o,$(SRC_ARCH)) +diff --git a/dwarf_info.c b/dwarf_info.c +index e42a9f5857f3..543588ba369b 100644 +--- a/dwarf_info.c ++++ b/dwarf_info.c +@@ -614,6 +614,7 @@ search_structure(Dwarf_Die *die, int *found) + { + int tag; + const char *name; ++ Dwarf_Die die_type; + + /* + * If we get to here then we don't have any more +@@ -622,9 +623,31 @@ search_structure(Dwarf_Die *die, int *found) + do { + tag = dwarf_tag(die); + name = dwarf_diename(die); +- if ((tag != DW_TAG_structure_type) || (!name) +- || strcmp(name, dwarf_info.struct_name)) ++ if ((!name) || strcmp(name, dwarf_info.struct_name)) ++ continue; ++ ++ if (tag == DW_TAG_typedef) { ++ if (!get_die_type(die, &die_type)) { ++ ERRMSG("Can't get CU die of DW_AT_type.\n"); ++ break; ++ } ++ ++ /* Resolve typedefs of typedefs. */ ++ while ((tag = dwarf_tag(&die_type)) == DW_TAG_typedef) { ++ if (!get_die_type(&die_type, &die_type)) { ++ ERRMSG("Can't get CU die of DW_AT_type.\n"); ++ return; ++ } ++ } ++ ++ if (tag != DW_TAG_structure_type) ++ continue; ++ die = &die_type; ++ ++ } else if (tag != DW_TAG_structure_type) { + continue; ++ } ++ + /* + * Skip if DW_AT_byte_size is not included. + */ +@@ -740,6 +763,15 @@ search_typedef(Dwarf_Die *die, int *found) + ERRMSG("Can't get CU die of DW_AT_type.\n"); + break; + } ++ ++ /* Resolve typedefs of typedefs. */ ++ while ((tag = dwarf_tag(&die_type)) == DW_TAG_typedef) { ++ if (!get_die_type(&die_type, &die_type)) { ++ ERRMSG("Can't get CU die of DW_AT_type.\n"); ++ return; ++ } ++ } ++ + dwarf_info.struct_size = dwarf_bytesize(&die_type); + if (dwarf_info.struct_size <= 0) + continue; +diff --git a/makedumpfile.c b/makedumpfile.c +index cdde040e2133..061741f72a5c 100644 +--- a/makedumpfile.c ++++ b/makedumpfile.c +@@ -1555,6 +1555,7 @@ get_symbol_info(void) + SYMBOL_INIT(node_data, "node_data"); + SYMBOL_INIT(pgdat_list, "pgdat_list"); + SYMBOL_INIT(contig_page_data, "contig_page_data"); ++ SYMBOL_INIT(prb, "prb"); + SYMBOL_INIT(log_buf, "log_buf"); + SYMBOL_INIT(log_buf_len, "log_buf_len"); + SYMBOL_INIT(log_end, "log_end"); +@@ -1971,16 +1972,47 @@ get_structure_info(void) + OFFSET_INIT(elf64_phdr.p_memsz, "elf64_phdr", "p_memsz"); + + SIZE_INIT(printk_log, "printk_log"); +- if (SIZE(printk_log) != NOT_FOUND_STRUCTURE) { ++ SIZE_INIT(printk_ringbuffer, "printk_ringbuffer"); ++ if ((SIZE(printk_ringbuffer) != NOT_FOUND_STRUCTURE)) { ++ info->flag_use_printk_ringbuffer = TRUE; ++ info->flag_use_printk_log = FALSE; ++ ++ OFFSET_INIT(printk_ringbuffer.desc_ring, "printk_ringbuffer", "desc_ring"); ++ OFFSET_INIT(printk_ringbuffer.text_data_ring, "printk_ringbuffer", "text_data_ring"); ++ ++ OFFSET_INIT(prb_desc_ring.count_bits, "prb_desc_ring", "count_bits"); ++ OFFSET_INIT(prb_desc_ring.descs, "prb_desc_ring", "descs"); ++ OFFSET_INIT(prb_desc_ring.infos, "prb_desc_ring", "infos"); ++ OFFSET_INIT(prb_desc_ring.head_id, "prb_desc_ring", "head_id"); ++ OFFSET_INIT(prb_desc_ring.tail_id, "prb_desc_ring", "tail_id"); ++ ++ SIZE_INIT(prb_desc, "prb_desc"); ++ OFFSET_INIT(prb_desc.state_var, "prb_desc", "state_var"); ++ OFFSET_INIT(prb_desc.text_blk_lpos, "prb_desc", "text_blk_lpos"); ++ ++ OFFSET_INIT(prb_data_blk_lpos.begin, "prb_data_blk_lpos", "begin"); ++ OFFSET_INIT(prb_data_blk_lpos.next, "prb_data_blk_lpos", "next"); ++ ++ OFFSET_INIT(prb_data_ring.size_bits, "prb_data_ring", "size_bits"); ++ OFFSET_INIT(prb_data_ring.data, "prb_data_ring", "data"); ++ ++ SIZE_INIT(printk_info, "printk_info"); ++ OFFSET_INIT(printk_info.ts_nsec, "printk_info", "ts_nsec"); ++ OFFSET_INIT(printk_info.text_len, "printk_info", "text_len"); ++ ++ OFFSET_INIT(atomic_long_t.counter, "atomic_long_t", "counter"); ++ } else if (SIZE(printk_log) != NOT_FOUND_STRUCTURE) { + /* + * In kernel 3.11-rc4 the log structure name was renamed + * to "printk_log". + */ ++ info->flag_use_printk_ringbuffer = FALSE; + info->flag_use_printk_log = TRUE; + OFFSET_INIT(printk_log.ts_nsec, "printk_log", "ts_nsec"); + OFFSET_INIT(printk_log.len, "printk_log", "len"); + OFFSET_INIT(printk_log.text_len, "printk_log", "text_len"); + } else { ++ info->flag_use_printk_ringbuffer = FALSE; + info->flag_use_printk_log = FALSE; + SIZE_INIT(printk_log, "log"); + OFFSET_INIT(printk_log.ts_nsec, "log", "ts_nsec"); +@@ -2191,6 +2223,7 @@ write_vmcoreinfo_data(void) + WRITE_SYMBOL("node_data", node_data); + WRITE_SYMBOL("pgdat_list", pgdat_list); + WRITE_SYMBOL("contig_page_data", contig_page_data); ++ WRITE_SYMBOL("prb", prb); + WRITE_SYMBOL("log_buf", log_buf); + WRITE_SYMBOL("log_buf_len", log_buf_len); + WRITE_SYMBOL("log_end", log_end); +@@ -2222,7 +2255,11 @@ write_vmcoreinfo_data(void) + WRITE_STRUCTURE_SIZE("node_memblk_s", node_memblk_s); + WRITE_STRUCTURE_SIZE("nodemask_t", nodemask_t); + WRITE_STRUCTURE_SIZE("pageflags", pageflags); +- if (info->flag_use_printk_log) ++ if (info->flag_use_printk_ringbuffer) { ++ WRITE_STRUCTURE_SIZE("printk_ringbuffer", printk_ringbuffer); ++ WRITE_STRUCTURE_SIZE("prb_desc", prb_desc); ++ WRITE_STRUCTURE_SIZE("printk_info", printk_info); ++ } else if (info->flag_use_printk_log) + WRITE_STRUCTURE_SIZE("printk_log", printk_log); + else + WRITE_STRUCTURE_SIZE("log", printk_log); +@@ -2268,7 +2305,30 @@ write_vmcoreinfo_data(void) + WRITE_MEMBER_OFFSET("vm_struct.addr", vm_struct.addr); + WRITE_MEMBER_OFFSET("vmap_area.va_start", vmap_area.va_start); + WRITE_MEMBER_OFFSET("vmap_area.list", vmap_area.list); +- if (info->flag_use_printk_log) { ++ if (info->flag_use_printk_ringbuffer) { ++ WRITE_MEMBER_OFFSET("printk_ringbuffer.desc_ring", printk_ringbuffer.desc_ring); ++ WRITE_MEMBER_OFFSET("printk_ringbuffer.text_data_ring", printk_ringbuffer.text_data_ring); ++ ++ WRITE_MEMBER_OFFSET("prb_desc_ring.count_bits", prb_desc_ring.count_bits); ++ WRITE_MEMBER_OFFSET("prb_desc_ring.descs", prb_desc_ring.descs); ++ WRITE_MEMBER_OFFSET("prb_desc_ring.infos", prb_desc_ring.infos); ++ WRITE_MEMBER_OFFSET("prb_desc_ring.head_id", prb_desc_ring.head_id); ++ WRITE_MEMBER_OFFSET("prb_desc_ring.tail_id", prb_desc_ring.tail_id); ++ ++ WRITE_MEMBER_OFFSET("prb_desc.state_var", prb_desc.state_var); ++ WRITE_MEMBER_OFFSET("prb_desc.text_blk_lpos", prb_desc.text_blk_lpos); ++ ++ WRITE_MEMBER_OFFSET("prb_data_blk_lpos.begin", prb_data_blk_lpos.begin); ++ WRITE_MEMBER_OFFSET("prb_data_blk_lpos.next", prb_data_blk_lpos.next); ++ ++ WRITE_MEMBER_OFFSET("prb_data_ring.size_bits", prb_data_ring.size_bits); ++ WRITE_MEMBER_OFFSET("prb_data_ring.data", prb_data_ring.data); ++ ++ WRITE_MEMBER_OFFSET("printk_info.ts_nsec", printk_info.ts_nsec); ++ WRITE_MEMBER_OFFSET("printk_info.text_len", printk_info.text_len); ++ ++ WRITE_MEMBER_OFFSET("atomic_long_t.counter", atomic_long_t.counter); ++ } else if (info->flag_use_printk_log) { + WRITE_MEMBER_OFFSET("printk_log.ts_nsec", printk_log.ts_nsec); + WRITE_MEMBER_OFFSET("printk_log.len", printk_log.len); + WRITE_MEMBER_OFFSET("printk_log.text_len", printk_log.text_len); +@@ -2606,6 +2666,7 @@ read_vmcoreinfo(void) + READ_SYMBOL("node_data", node_data); + READ_SYMBOL("pgdat_list", pgdat_list); + READ_SYMBOL("contig_page_data", contig_page_data); ++ READ_SYMBOL("prb", prb); + READ_SYMBOL("log_buf", log_buf); + READ_SYMBOL("log_buf_len", log_buf_len); + READ_SYMBOL("log_end", log_end); +@@ -2684,12 +2745,43 @@ read_vmcoreinfo(void) + READ_MEMBER_OFFSET("cpu_spec.mmu_features", cpu_spec.mmu_features); + + READ_STRUCTURE_SIZE("printk_log", printk_log); +- if (SIZE(printk_log) != NOT_FOUND_STRUCTURE) { ++ READ_STRUCTURE_SIZE("printk_ringbuffer", printk_ringbuffer); ++ if (SIZE(printk_ringbuffer) != NOT_FOUND_STRUCTURE) { ++ info->flag_use_printk_ringbuffer = TRUE; ++ info->flag_use_printk_log = FALSE; ++ ++ READ_MEMBER_OFFSET("printk_ringbuffer.desc_ring", printk_ringbuffer.desc_ring); ++ READ_MEMBER_OFFSET("printk_ringbuffer.text_data_ring", printk_ringbuffer.text_data_ring); ++ ++ READ_MEMBER_OFFSET("prb_desc_ring.count_bits", prb_desc_ring.count_bits); ++ READ_MEMBER_OFFSET("prb_desc_ring.descs", prb_desc_ring.descs); ++ READ_MEMBER_OFFSET("prb_desc_ring.infos", prb_desc_ring.infos); ++ READ_MEMBER_OFFSET("prb_desc_ring.head_id", prb_desc_ring.head_id); ++ READ_MEMBER_OFFSET("prb_desc_ring.tail_id", prb_desc_ring.tail_id); ++ ++ READ_STRUCTURE_SIZE("prb_desc", prb_desc); ++ READ_MEMBER_OFFSET("prb_desc.state_var", prb_desc.state_var); ++ READ_MEMBER_OFFSET("prb_desc.text_blk_lpos", prb_desc.text_blk_lpos); ++ ++ READ_MEMBER_OFFSET("prb_data_blk_lpos.begin", prb_data_blk_lpos.begin); ++ READ_MEMBER_OFFSET("prb_data_blk_lpos.next", prb_data_blk_lpos.next); ++ ++ READ_MEMBER_OFFSET("prb_data_ring.size_bits", prb_data_ring.size_bits); ++ READ_MEMBER_OFFSET("prb_data_ring.data", prb_data_ring.data); ++ ++ READ_STRUCTURE_SIZE("printk_info", printk_info); ++ READ_MEMBER_OFFSET("printk_info.ts_nsec", printk_info.ts_nsec); ++ READ_MEMBER_OFFSET("printk_info.text_len", printk_info.text_len); ++ ++ READ_MEMBER_OFFSET("atomic_long_t.counter", atomic_long_t.counter); ++ } else if (SIZE(printk_log) != NOT_FOUND_STRUCTURE) { ++ info->flag_use_printk_ringbuffer = FALSE; + info->flag_use_printk_log = TRUE; + READ_MEMBER_OFFSET("printk_log.ts_nsec", printk_log.ts_nsec); + READ_MEMBER_OFFSET("printk_log.len", printk_log.len); + READ_MEMBER_OFFSET("printk_log.text_len", printk_log.text_len); + } else { ++ info->flag_use_printk_ringbuffer = FALSE; + info->flag_use_printk_log = FALSE; + READ_STRUCTURE_SIZE("log", printk_log); + READ_MEMBER_OFFSET("log.ts_nsec", printk_log.ts_nsec); +@@ -5286,6 +5378,9 @@ dump_dmesg() + if (!initial()) + return FALSE; + ++ if ((SYMBOL(prb) != NOT_FOUND_SYMBOL)) ++ return dump_lockless_dmesg(); ++ + if ((SYMBOL(log_buf) == NOT_FOUND_SYMBOL) + || (SYMBOL(log_buf_len) == NOT_FOUND_SYMBOL)) { + ERRMSG("Can't find some symbols for log_buf.\n"); +diff --git a/makedumpfile.h b/makedumpfile.h +index 698c0547c0f2..47f7e7999014 100644 +--- a/makedumpfile.h ++++ b/makedumpfile.h +@@ -1317,6 +1317,7 @@ struct DumpInfo { + int flag_partial_dmesg; /* dmesg dump only from the last cleared index*/ + int flag_mem_usage; /*show the page number of memory in different use*/ + int flag_use_printk_log; /* did we read printk_log symbol name? */ ++ int flag_use_printk_ringbuffer; /* using lockless printk ringbuffer? */ + int flag_nospace; /* the flag of "No space on device" error */ + int flag_vmemmap; /* kernel supports vmemmap address space */ + int flag_excludevm; /* -e - excluding unused vmemmap pages */ +@@ -1602,6 +1603,7 @@ struct symbol_table { + unsigned long long node_data; + unsigned long long pgdat_list; + unsigned long long contig_page_data; ++ unsigned long long prb; + unsigned long long log_buf; + unsigned long long log_buf_len; + unsigned long long log_end; +@@ -1689,6 +1691,13 @@ struct size_table { + long nodemask_t; + long printk_log; + ++ /* ++ * for lockless printk ringbuffer ++ */ ++ long printk_ringbuffer; ++ long prb_desc; ++ long printk_info; ++ + /* + * for Xen extraction + */ +@@ -1864,6 +1873,52 @@ struct offset_table { + long text_len; + } printk_log; + ++ /* ++ * for lockless printk ringbuffer ++ */ ++ struct printk_ringbuffer_s { ++ long desc_ring; ++ long text_data_ring; ++ long fail; ++ } printk_ringbuffer; ++ ++ struct prb_desc_ring_s { ++ long count_bits; ++ long descs; ++ long infos; ++ long head_id; ++ long tail_id; ++ } prb_desc_ring; ++ ++ struct prb_desc_s { ++ long state_var; ++ long text_blk_lpos; ++ } prb_desc; ++ ++ struct prb_data_blk_lpos_s { ++ long begin; ++ long next; ++ } prb_data_blk_lpos; ++ ++ struct printk_info_s { ++ long seq; ++ long ts_nsec; ++ long text_len; ++ long caller_id; ++ long dev_info; ++ } printk_info; ++ ++ struct prb_data_ring_s { ++ long size_bits; ++ long data; ++ long head_lpos; ++ long tail_lpos; ++ } prb_data_ring; ++ ++ struct atomic_long_t_s { ++ long counter; ++ } atomic_long_t; ++ + /* + * symbols on ppc64 arch + */ +@@ -2390,4 +2445,7 @@ int hexadecimal(char *s, int count); + int decimal(char *s, int count); + int file_exists(char *file); + ++int open_dump_file(void); ++int dump_lockless_dmesg(void); ++ + #endif /* MAKEDUMPFILE_H */ +diff --git a/printk.c b/printk.c +new file mode 100644 +index 000000000000..acffb6c7a898 +--- /dev/null ++++ b/printk.c +@@ -0,0 +1,207 @@ ++#include "makedumpfile.h" ++#include ++ ++#define DESC_SV_BITS (sizeof(unsigned long) * 8) ++#define DESC_COMMITTED_MASK (1UL << (DESC_SV_BITS - 1)) ++#define DESC_REUSE_MASK (1UL << (DESC_SV_BITS - 2)) ++#define DESC_FLAGS_MASK (DESC_COMMITTED_MASK | DESC_REUSE_MASK) ++#define DESC_ID_MASK (~DESC_FLAGS_MASK) ++ ++/* convenience struct for passing many values to helper functions */ ++struct prb_map { ++ char *prb; ++ ++ char *desc_ring; ++ unsigned long desc_ring_count; ++ char *descs; ++ char *infos; ++ ++ char *text_data_ring; ++ unsigned long text_data_ring_size; ++ char *text_data; ++}; ++ ++static void ++dump_record(struct prb_map *m, unsigned long id) ++{ ++ unsigned long long ts_nsec; ++ unsigned long state_var; ++ unsigned short text_len; ++ unsigned long begin; ++ unsigned long next; ++ char buf[BUFSIZE]; ++ ulonglong nanos; ++ int indent_len; ++ int buf_need; ++ char *bufp; ++ char *text; ++ char *desc; ++ char *inf; ++ ulong rem; ++ char *p; ++ int i; ++ ++ desc = m->descs + ((id % m->desc_ring_count) * SIZE(prb_desc)); ++ ++ /* skip non-committed record */ ++ state_var = ULONG(desc + OFFSET(prb_desc.state_var) + OFFSET(atomic_long_t.counter)); ++ if ((state_var & DESC_FLAGS_MASK) != DESC_COMMITTED_MASK) ++ return; ++ ++ begin = ULONG(desc + OFFSET(prb_desc.text_blk_lpos) + OFFSET(prb_data_blk_lpos.begin)) % ++ m->text_data_ring_size; ++ next = ULONG(desc + OFFSET(prb_desc.text_blk_lpos) + OFFSET(prb_data_blk_lpos.next)) % ++ m->text_data_ring_size; ++ ++ /* skip data-less text blocks */ ++ if (begin == next) ++ return; ++ ++ inf = m->infos + ((id % m->desc_ring_count) * SIZE(printk_info)); ++ ++ text_len = USHORT(inf + OFFSET(printk_info.text_len)); ++ ++ /* handle wrapping data block */ ++ if (begin > next) ++ begin = 0; ++ ++ /* skip over descriptor ID */ ++ begin += sizeof(unsigned long); ++ ++ /* handle truncated messages */ ++ if (next - begin < text_len) ++ text_len = next - begin; ++ ++ text = m->text_data + begin; ++ ++ ts_nsec = ULONGLONG(inf + OFFSET(printk_info.ts_nsec)); ++ nanos = (ulonglong)ts_nsec / (ulonglong)1000000000; ++ rem = (ulonglong)ts_nsec % (ulonglong)1000000000; ++ ++ bufp = buf; ++ bufp += sprintf(buf, "[%5lld.%06ld] ", nanos, rem/1000); ++ indent_len = strlen(buf); ++ ++ /* How much buffer space is needed in the worst case */ ++ buf_need = MAX(sizeof("\\xXX\n"), sizeof("\n") + indent_len); ++ ++ for (i = 0, p = text; i < text_len; i++, p++) { ++ if (bufp - buf >= sizeof(buf) - buf_need) { ++ if (write(info->fd_dumpfile, buf, bufp - buf) < 0) ++ return; ++ bufp = buf; ++ } ++ ++ if (*p == '\n') ++ bufp += sprintf(bufp, "\n%-*s", indent_len, ""); ++ else if (isprint(*p) || isspace(*p)) ++ *bufp++ = *p; ++ else ++ bufp += sprintf(bufp, "\\x%02x", *p); ++ } ++ ++ *bufp++ = '\n'; ++ ++ write(info->fd_dumpfile, buf, bufp - buf); ++} ++ ++int ++dump_lockless_dmesg(void) ++{ ++ unsigned long head_id; ++ unsigned long tail_id; ++ unsigned long kaddr; ++ unsigned long id; ++ struct prb_map m; ++ int ret = FALSE; ++ ++ /* setup printk_ringbuffer */ ++ if (!readmem(VADDR, SYMBOL(prb), &kaddr, sizeof(kaddr))) { ++ ERRMSG("Can't get the prb address.\n"); ++ return ret; ++ } ++ ++ m.prb = malloc(SIZE(printk_ringbuffer)); ++ if (!m.prb) { ++ ERRMSG("Can't allocate memory for prb.\n"); ++ return ret; ++ } ++ if (!readmem(VADDR, kaddr, m.prb, SIZE(printk_ringbuffer))) { ++ ERRMSG("Can't get prb.\n"); ++ goto out_prb; ++ } ++ ++ /* setup descriptor ring */ ++ m.desc_ring = m.prb + OFFSET(printk_ringbuffer.desc_ring); ++ m.desc_ring_count = 1 << UINT(m.desc_ring + OFFSET(prb_desc_ring.count_bits)); ++ ++ kaddr = ULONG(m.desc_ring + OFFSET(prb_desc_ring.descs)); ++ m.descs = malloc(SIZE(prb_desc) * m.desc_ring_count); ++ if (!m.descs) { ++ ERRMSG("Can't allocate memory for prb.desc_ring.descs.\n"); ++ goto out_prb; ++ } ++ if (!readmem(VADDR, kaddr, m.descs, ++ SIZE(prb_desc) * m.desc_ring_count)) { ++ ERRMSG("Can't get prb.desc_ring.descs.\n"); ++ goto out_descs; ++ } ++ ++ kaddr = ULONG(m.desc_ring + OFFSET(prb_desc_ring.infos)); ++ m.infos = malloc(SIZE(printk_info) * m.desc_ring_count); ++ if (!m.infos) { ++ ERRMSG("Can't allocate memory for prb.desc_ring.infos.\n"); ++ goto out_descs; ++ } ++ if (!readmem(VADDR, kaddr, m.infos, SIZE(printk_info) * m.desc_ring_count)) { ++ ERRMSG("Can't get prb.desc_ring.infos.\n"); ++ goto out_infos; ++ } ++ ++ /* setup text data ring */ ++ m.text_data_ring = m.prb + OFFSET(printk_ringbuffer.text_data_ring); ++ m.text_data_ring_size = 1 << UINT(m.text_data_ring + OFFSET(prb_data_ring.size_bits)); ++ ++ kaddr = ULONG(m.text_data_ring + OFFSET(prb_data_ring.data)); ++ m.text_data = malloc(m.text_data_ring_size); ++ if (!m.text_data) { ++ ERRMSG("Can't allocate memory for prb.text_data_ring.data.\n"); ++ goto out_infos; ++ } ++ if (!readmem(VADDR, kaddr, m.text_data, m.text_data_ring_size)) { ++ ERRMSG("Can't get prb.text_data_ring.\n"); ++ goto out_text_data; ++ } ++ ++ /* ready to go */ ++ ++ tail_id = ULONG(m.desc_ring + OFFSET(prb_desc_ring.tail_id) + ++ OFFSET(atomic_long_t.counter)); ++ head_id = ULONG(m.desc_ring + OFFSET(prb_desc_ring.head_id) + ++ OFFSET(atomic_long_t.counter)); ++ ++ if (!open_dump_file()) { ++ ERRMSG("Can't open output file.\n"); ++ goto out_text_data; ++ } ++ ++ for (id = tail_id; id != head_id; id = (id + 1) & DESC_ID_MASK) ++ dump_record(&m, id); ++ ++ /* dump head record */ ++ dump_record(&m, id); ++ ++ if (!close_files_for_creating_dumpfile()) ++ goto out_text_data; ++ ++ ret = TRUE; ++out_text_data: ++ free(m.text_data); ++out_infos: ++ free(m.infos); ++out_descs: ++ free(m.descs); ++out_prb: ++ free(m.prb); ++ return ret; ++} +-- +2.26.2 + diff --git a/makedumpfile-printk-use-committed-finalized-state-value.patch b/makedumpfile-printk-use-committed-finalized-state-value.patch new file mode 100644 index 0000000..b5e61b2 --- /dev/null +++ b/makedumpfile-printk-use-committed-finalized-state-value.patch @@ -0,0 +1,101 @@ +From 44b073b7ec467aee0d7de381d455b8ace1199184 Mon Sep 17 00:00:00 2001 +From: John Ogness +Date: Wed, 25 Nov 2020 10:10:31 +0106 +Subject: [PATCH 2/2] [PATCH 2/2] printk: use committed/finalized state values +Upstream: merged (expected 1.6.9) +Git-commit: 44b073b7ec467aee0d7de381d455b8ace1199184 + +* Required for kernel 5.10 + +The ringbuffer entries use 2 state values (committed and finalized) +rather than a single flag to represent being available for reading. +Copy the definitions and state lookup function directly from the +kernel source and use the new states. + +Signed-off-by: John Ogness +--- + printk.c | 48 +++++++++++++++++++++++++++++++++++++++++------- + 1 file changed, 41 insertions(+), 7 deletions(-) + +diff --git a/printk.c b/printk.c +index acffb6c7a898..2af8562201cc 100644 +--- a/printk.c ++++ b/printk.c +@@ -1,12 +1,6 @@ + #include "makedumpfile.h" + #include + +-#define DESC_SV_BITS (sizeof(unsigned long) * 8) +-#define DESC_COMMITTED_MASK (1UL << (DESC_SV_BITS - 1)) +-#define DESC_REUSE_MASK (1UL << (DESC_SV_BITS - 2)) +-#define DESC_FLAGS_MASK (DESC_COMMITTED_MASK | DESC_REUSE_MASK) +-#define DESC_ID_MASK (~DESC_FLAGS_MASK) +- + /* convenience struct for passing many values to helper functions */ + struct prb_map { + char *prb; +@@ -21,12 +15,51 @@ struct prb_map { + char *text_data; + }; + ++/* ++ * desc_state and DESC_* definitions taken from kernel source: ++ * ++ * kernel/printk/printk_ringbuffer.h ++ */ ++ ++/* The possible responses of a descriptor state-query. */ ++enum desc_state { ++ desc_miss = -1, /* ID mismatch (pseudo state) */ ++ desc_reserved = 0x0, /* reserved, in use by writer */ ++ desc_committed = 0x1, /* committed by writer, could get reopened */ ++ desc_finalized = 0x2, /* committed, no further modification allowed */ ++ desc_reusable = 0x3, /* free, not yet used by any writer */ ++}; ++ ++#define DESC_SV_BITS (sizeof(unsigned long) * 8) ++#define DESC_FLAGS_SHIFT (DESC_SV_BITS - 2) ++#define DESC_FLAGS_MASK (3UL << DESC_FLAGS_SHIFT) ++#define DESC_STATE(sv) (3UL & (sv >> DESC_FLAGS_SHIFT)) ++#define DESC_ID_MASK (~DESC_FLAGS_MASK) ++#define DESC_ID(sv) ((sv) & DESC_ID_MASK) ++ ++/* ++ * get_desc_state() taken from kernel source: ++ * ++ * kernel/printk/printk_ringbuffer.c ++ */ ++ ++/* Query the state of a descriptor. */ ++static enum desc_state get_desc_state(unsigned long id, ++ unsigned long state_val) ++{ ++ if (id != DESC_ID(state_val)) ++ return desc_miss; ++ ++ return DESC_STATE(state_val); ++} ++ + static void + dump_record(struct prb_map *m, unsigned long id) + { + unsigned long long ts_nsec; + unsigned long state_var; + unsigned short text_len; ++ enum desc_state state; + unsigned long begin; + unsigned long next; + char buf[BUFSIZE]; +@@ -45,7 +78,8 @@ dump_record(struct prb_map *m, unsigned long id) + + /* skip non-committed record */ + state_var = ULONG(desc + OFFSET(prb_desc.state_var) + OFFSET(atomic_long_t.counter)); +- if ((state_var & DESC_FLAGS_MASK) != DESC_COMMITTED_MASK) ++ state = get_desc_state(id, state_var); ++ if (state != desc_committed && state != desc_finalized) + return; + + begin = ULONG(desc + OFFSET(prb_desc.text_blk_lpos) + OFFSET(prb_data_blk_lpos.begin)) % +-- +2.26.2 + diff --git a/makedumpfile-sadump-Fix-failure-of-reading.patch b/makedumpfile-sadump-Fix-failure-of-reading.patch deleted file mode 100644 index 62cfdcd..0000000 --- a/makedumpfile-sadump-Fix-failure-of-reading.patch +++ /dev/null @@ -1,54 +0,0 @@ -From: "saito.kazuya@fujitsu.com" -Date: Thu, 21 May 2020 07:15:19 +0000 -Subject: sadump: Fix failure of reading __per_cpu_load memory -References: bsc#1168798 -Upstream: merged -Git-commit: c9e078531efaffbe6f780221d40bdac21a84855b - -Creating vmcore from sadump by makedumpfile fails with the following -error messages since kernel-4.19 with PTI (Page Table Isolation) -enabled: - - __vtop4_x86_64: Can't get a valid pte. - readmem: Can't convert a virtual address(ffffffffb2986000) to physical address. - readmem: type_addr: 0, addr:ffffffffb2986000, size:8 - per_cpu_init: Can't read __per_cpu_load memory. - -This is caused by the following patch: -https://github.com/torvalds/linux/commit/c40a56a7818cfe735fc93a69e1875f8bba834483 - -The above patch clears _PAGE_PRESENT bit of __per_cpu_load memory, so -__vtop4_x86_64 fails to convert the virtual address of the -__per_cpu_load. - -To fix this issue, this patch changes sanity check of per_cpu_ptr() -to use address of the __per_cpu_load instead of data of the memory. - -Signed-off-by: Kazuya Saito -Signed-off-by: Kiyotaka Nakamura ---- - sadump_info.c | 6 +++--- - 1 file changed, 3 insertions(+), 3 deletions(-) - -diff --git a/sadump_info.c b/sadump_info.c -index 46867ce..72a077b 100644 ---- a/sadump_info.c -+++ b/sadump_info.c -@@ -1732,11 +1732,11 @@ per_cpu_init(void) - return FALSE; - } - -- if (!readmem(VADDR, SYMBOL(__per_cpu_load), &si->__per_cpu_load, -- sizeof(unsigned long))) { -- ERRMSG("Can't read __per_cpu_load memory.\n"); -+ if (SYMBOL(__per_cpu_load) == NOT_FOUND_SYMBOL) { -+ ERRMSG("Can't find __per_cpu_load symbol.\n"); - return FALSE; - } -+ si->__per_cpu_load = SYMBOL(__per_cpu_load); - - DEBUG_MSG("sadump: __per_cpu_load: %#lx\n", si->__per_cpu_load); - DEBUG_MSG("sadump: __per_cpu_offset: LENGTH: %ld\n", --- -2.26.2 - diff --git a/makedumpfile.changes b/makedumpfile.changes index 5b517c4..38d6c20 100644 --- a/makedumpfile.changes +++ b/makedumpfile.changes @@ -1,3 +1,21 @@ +------------------------------------------------------------------- +Wed Mar 24 16:05:04 UTC 2021 - Petr Mladek + +- Update to version 1.6.8: + * Support newer kernels up to v5.9 + * arm64: Add support for ARMv8.2-LPA (52-bit PA support) + * Retrieve MAX_PHYSMEM_BITS from vmcoreinfo + * sadump, kaslr: fix failure of calculating kaslr_offset + * Introduce --check-params option + * cope with not-present mem section +- Drop upstreamed patches: + * makedumpfile-Fix-cd_header-offset-overflow-with-large-pfn.patch + * makedumpfile-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch + * makedumpfile-sadump-Fix-failure-of-reading.patch +- Allow to read kernel log from the lockless ringbuffer (bsc#1183965): + * makedumpfile-printk-add-support-for-lockless-ringbuffer.patch + * makedumpfile-printk-use-committed-finalized-state-value.patch + ------------------------------------------------------------------- Thu Jun 4 09:57:15 UTC 2020 - Petr Tesařík diff --git a/makedumpfile.spec b/makedumpfile.spec index aed6a5e..ad7a4c2 100644 --- a/makedumpfile.spec +++ b/makedumpfile.spec @@ -1,7 +1,7 @@ # # spec file for package makedumpfile # -# Copyright (c) 2020 SUSE LLC +# Copyright (c) 2021 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -32,7 +32,7 @@ # End of compatibility cruft Name: makedumpfile -Version: 1.6.7 +Version: 1.6.8 Release: 0 Summary: Partial kernel dump License: GPL-2.0-only @@ -43,9 +43,8 @@ Source99: %{name}-rpmlintrc Patch1: %{name}-override-libtinfo.patch Patch2: %{name}-ppc64-VA-range-SUSE.patch Patch3: %{name}-PN_XNUM.patch -Patch4: %{name}-arm64-Align-PMD_SECTION_MASK-with-PHYS_MASK.patch -Patch5: %{name}-Fix-cd_header-offset-overflow-with-large-pfn.patch -Patch6: %{name}-sadump-Fix-failure-of-reading.patch +Patch4: %{name}-printk-add-support-for-lockless-ringbuffer.patch +Patch5: %{name}-printk-use-committed-finalized-state-value.patch BuildRequires: libdw-devel BuildRequires: libelf-devel BuildRequires: libeppic-devel From 8145987b794bf75639a17f81abb64275a84ca1148a4a9cd85634e382e89467ee Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Tesa=C5=99=C3=ADk?= Date: Sun, 4 Apr 2021 13:14:15 +0000 Subject: [PATCH 2/3] - Update upstream project location (URL and Source). OBS-URL: https://build.opensuse.org/package/show/Kernel:kdump/makedumpfile?expand=0&rev=150 --- makedumpfile.changes | 5 +++++ makedumpfile.spec | 4 ++-- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/makedumpfile.changes b/makedumpfile.changes index 38d6c20..d7f13a8 100644 --- a/makedumpfile.changes +++ b/makedumpfile.changes @@ -1,3 +1,8 @@ +------------------------------------------------------------------- +Sun Apr 4 13:13:31 UTC 2021 - Petr Tesařík + +- Update upstream project location (URL and Source). + ------------------------------------------------------------------- Wed Mar 24 16:05:04 UTC 2021 - Petr Mladek diff --git a/makedumpfile.spec b/makedumpfile.spec index ad7a4c2..1f18a38 100644 --- a/makedumpfile.spec +++ b/makedumpfile.spec @@ -37,8 +37,8 @@ Release: 0 Summary: Partial kernel dump License: GPL-2.0-only Group: System/Kernel -URL: https://sourceforge.net/projects/makedumpfile/ -Source: https://sourceforge.net/projects/makedumpfile/files/makedumpfile/%{version}/%{name}-%{version}.tar.gz +URL: https://github.com/makedumpfile/makedumpfile +Source: https://github.com/makedumpfile/makedumpfile/releases/download/%{version}/%{name}-%{version}.tar.gz Source99: %{name}-rpmlintrc Patch1: %{name}-override-libtinfo.patch Patch2: %{name}-ppc64-VA-range-SUSE.patch From 29b838c5b99a8598c6214d200371e04174a25b99627835e6726ee82a9e47598f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Tesa=C5=99=C3=ADk?= Date: Wed, 7 Apr 2021 09:54:49 +0000 Subject: [PATCH 3/3] - Support kernel 5.11: * makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch: make use of 'uts_namespace.name' offset in VMCOREINFO. OBS-URL: https://build.opensuse.org/package/show/Kernel:kdump/makedumpfile?expand=0&rev=151 --- ...uts_namespace.name-offset-VMCOREINFO.patch | 96 +++++++++++++++++++ makedumpfile.changes | 7 ++ makedumpfile.spec | 1 + 3 files changed, 104 insertions(+) create mode 100644 makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch diff --git a/makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch b/makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch new file mode 100644 index 0000000..c92f42b --- /dev/null +++ b/makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch @@ -0,0 +1,96 @@ +From: Alexander Egorenkov +Date: Fri, 18 Sep 2020 13:55:56 +0200 +Subject: make use of 'uts_namespace.name' offset in VMCOREINFO +Upstream: merged +Git-commit: 54aec3878b3f91341e6bc735eda158cca5c54ec9 + +* Required for kernel 5.11 + +The offset of the field 'init_uts_ns.name' has changed since +kernel commit 9a56493f6942 ("uts: Use generic ns_common::count"). +Make use of the offset 'uts_namespace.name' if available in +VMCOREINFO. + +Signed-off-by: Alexander Egorenkov +Acked-by: Petr Tesarik +--- + makedumpfile.c | 17 +++++++++++++++-- + makedumpfile.h | 6 ++++++ + 2 files changed, 21 insertions(+), 2 deletions(-) + +--- a/makedumpfile.c ++++ b/makedumpfile.c +@@ -1159,7 +1159,10 @@ check_release(void) + if (SYMBOL(system_utsname) != NOT_FOUND_SYMBOL) { + utsname = SYMBOL(system_utsname); + } else if (SYMBOL(init_uts_ns) != NOT_FOUND_SYMBOL) { +- utsname = SYMBOL(init_uts_ns) + sizeof(int); ++ if (OFFSET(uts_namespace.name) != NOT_FOUND_STRUCTURE) ++ utsname = SYMBOL(init_uts_ns) + OFFSET(uts_namespace.name); ++ else ++ utsname = SYMBOL(init_uts_ns) + sizeof(int); + } else { + ERRMSG("Can't get the symbol of system_utsname.\n"); + return FALSE; +@@ -2040,6 +2043,11 @@ get_structure_info(void) + SIZE_INIT(cpu_spec, "cpu_spec"); + OFFSET_INIT(cpu_spec.mmu_features, "cpu_spec", "mmu_features"); + ++ /* ++ * Get offsets of the uts_namespace's members. ++ */ ++ OFFSET_INIT(uts_namespace.name, "uts_namespace", "name"); ++ + return TRUE; + } + +@@ -2109,7 +2117,10 @@ get_str_osrelease_from_vmlinux(void) + if (SYMBOL(system_utsname) != NOT_FOUND_SYMBOL) { + utsname = SYMBOL(system_utsname); + } else if (SYMBOL(init_uts_ns) != NOT_FOUND_SYMBOL) { +- utsname = SYMBOL(init_uts_ns) + sizeof(int); ++ if (OFFSET(uts_namespace.name) != NOT_FOUND_STRUCTURE) ++ utsname = SYMBOL(init_uts_ns) + OFFSET(uts_namespace.name); ++ else ++ utsname = SYMBOL(init_uts_ns) + sizeof(int); + } else { + ERRMSG("Can't get the symbol of system_utsname.\n"); + return FALSE; +@@ -2344,6 +2355,7 @@ write_vmcoreinfo_data(void) + WRITE_MEMBER_OFFSET("vmemmap_backing.list", vmemmap_backing.list); + WRITE_MEMBER_OFFSET("mmu_psize_def.shift", mmu_psize_def.shift); + WRITE_MEMBER_OFFSET("cpu_spec.mmu_features", cpu_spec.mmu_features); ++ WRITE_MEMBER_OFFSET("uts_namespace.name", uts_namespace.name); + + if (SYMBOL(node_data) != NOT_FOUND_SYMBOL) + WRITE_ARRAY_LENGTH("node_data", node_data); +@@ -2745,6 +2757,7 @@ read_vmcoreinfo(void) + READ_MEMBER_OFFSET("vmemmap_backing.list", vmemmap_backing.list); + READ_MEMBER_OFFSET("mmu_psize_def.shift", mmu_psize_def.shift); + READ_MEMBER_OFFSET("cpu_spec.mmu_features", cpu_spec.mmu_features); ++ READ_MEMBER_OFFSET("uts_namespace.name", uts_namespace.name); + + READ_STRUCTURE_SIZE("printk_log", printk_log); + READ_STRUCTURE_SIZE("printk_ringbuffer", printk_ringbuffer); +--- a/makedumpfile.h ++++ b/makedumpfile.h +@@ -1728,6 +1728,8 @@ struct size_table { + long cpu_spec; + + long pageflags; ++ ++ long uts_namespace; + }; + + struct offset_table { +@@ -1935,6 +1937,10 @@ struct offset_table { + struct cpu_spec_s { + long mmu_features; + } cpu_spec; ++ ++ struct uts_namespace_s { ++ long name; ++ } uts_namespace; + }; + + /* diff --git a/makedumpfile.changes b/makedumpfile.changes index d7f13a8..9609c47 100644 --- a/makedumpfile.changes +++ b/makedumpfile.changes @@ -1,3 +1,10 @@ +------------------------------------------------------------------- +Wed Apr 7 09:52:16 UTC 2021 - Petr Tesařík + +- Support kernel 5.11: + * makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch: + make use of 'uts_namespace.name' offset in VMCOREINFO. + ------------------------------------------------------------------- Sun Apr 4 13:13:31 UTC 2021 - Petr Tesařík diff --git a/makedumpfile.spec b/makedumpfile.spec index 1f18a38..706f400 100644 --- a/makedumpfile.spec +++ b/makedumpfile.spec @@ -45,6 +45,7 @@ Patch2: %{name}-ppc64-VA-range-SUSE.patch Patch3: %{name}-PN_XNUM.patch Patch4: %{name}-printk-add-support-for-lockless-ringbuffer.patch Patch5: %{name}-printk-use-committed-finalized-state-value.patch +Patch6: %{name}-use-uts_namespace.name-offset-VMCOREINFO.patch BuildRequires: libdw-devel BuildRequires: libelf-devel BuildRequires: libeppic-devel