Package: release.debian.org Severity: normal User: release.debian....@packages.debian.org Usertags: unblock
Please unblock package makedumpfile [ Reason ] Adds necessary fixes for supporting current kernels. [ Impact ] makedumpfile will be unable to extract the dmesg from the 5.10 kernel, and does not support 5.4 and newer kernels on arm64. [ Tests ] Forcing a crash dump in an x86 VM and verifying that the dmesg file is produced and the crash utility is able to analyze the dump. [ Risks ] The biggest risk I can think of is that we may have broken support with some earlier kernel version. But things do work with the kernel version we're currently planning to release. [ Checklist ] [x] all changes are documented in the d/changelog [x] I reviewed all changes and I approve them [x] attach debdiff against the package in testing [ Other info ] N/A unblock makedumpfile/1:1.6.8-4
diff -Nru makedumpfile-1.6.8/debian/changelog makedumpfile-1.6.8/debian/changelog --- makedumpfile-1.6.8/debian/changelog 2021-01-18 07:50:02.000000000 -0700 +++ makedumpfile-1.6.8/debian/changelog 2021-04-07 16:32:38.000000000 -0600 @@ -1,3 +1,13 @@ +makedumpfile (1:1.6.8-4) unstable; urgency=medium + + [ Ioanna Alifieraki ] + * Fix failure of dmesg.<timestamp> creation on 5.10+ kernels. + (Closes: #985896) (LP: #1921403). + * Fix makedumpfile failure on arm64 with 5.4 kernels. + (Closes: #986594) (LP: #1879214) + + -- dann frazier <da...@debian.org> Wed, 07 Apr 2021 16:32:38 -0600 + makedumpfile (1:1.6.8-3) unstable; urgency=medium * Drop kdump-tools, which has been split into its own source package. diff -Nru makedumpfile-1.6.8/debian/patches/0002-PATCH-1-2-printk-add-support-for-lockless-ringbuffer.patch makedumpfile-1.6.8/debian/patches/0002-PATCH-1-2-printk-add-support-for-lockless-ringbuffer.patch --- makedumpfile-1.6.8/debian/patches/0002-PATCH-1-2-printk-add-support-for-lockless-ringbuffer.patch 1969-12-31 17:00:00.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/0002-PATCH-1-2-printk-add-support-for-lockless-ringbuffer.patch 2021-04-07 16:32:38.000000000 -0600 @@ -0,0 +1,587 @@ +From: John Ogness <john.ogn...@linutronix.de> +Date: Thu, 19 Nov 2020 02:41:21 +0000 +Subject: [PATCH 1/2] printk: add support for lockless ringbuffer + +* 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 <john.ogn...@linutronix.de> +Signed-off-by: Kazuhito Hagio <k-hagio...@nec.com> + +Origin: upstream, https://github.com/makedumpfile/makedumpfile/commit/c617ec63339222f3a44d73e36677a9acc8954ccd +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=985896 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1921403 +--- + 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 b12bbb0..6f4d0e0 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 e42a9f5..543588b 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 cdde040..061741f 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 698c054..47f7e79 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 0000000..acffb6c +--- /dev/null ++++ b/printk.c +@@ -0,0 +1,207 @@ ++#include "makedumpfile.h" ++#include <ctype.h> ++ ++#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; ++} diff -Nru makedumpfile-1.6.8/debian/patches/0003-PATCH-2-2-printk-use-committed-finalized-state-value.patch makedumpfile-1.6.8/debian/patches/0003-PATCH-2-2-printk-use-committed-finalized-state-value.patch --- makedumpfile-1.6.8/debian/patches/0003-PATCH-2-2-printk-use-committed-finalized-state-value.patch 1969-12-31 17:00:00.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/0003-PATCH-2-2-printk-use-committed-finalized-state-value.patch 2021-04-07 16:32:38.000000000 -0600 @@ -0,0 +1,99 @@ +From: John Ogness <john.ogn...@linutronix.de> +Date: Wed, 25 Nov 2020 10:10:31 +0106 +Subject: [PATCH 2/2] printk: use committed/finalized state values + +* 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 <john.ogn...@linutronix.de> + +Origin: upstream, https://github.com/makedumpfile/makedumpfile/commit/44b073b7ec467aee0d7de381d455b8ace1199184 +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=985896 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1921403 +--- + printk.c | 48 +++++++++++++++++++++++++++++++++++++++++------- + 1 file changed, 41 insertions(+), 7 deletions(-) + +diff --git a/printk.c b/printk.c +index acffb6c..2af8562 100644 +--- a/printk.c ++++ b/printk.c +@@ -1,12 +1,6 @@ + #include "makedumpfile.h" + #include <ctype.h> + +-#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)) % diff -Nru makedumpfile-1.6.8/debian/patches/0004-PATCH-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch makedumpfile-1.6.8/debian/patches/0004-PATCH-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch --- makedumpfile-1.6.8/debian/patches/0004-PATCH-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch 1969-12-31 17:00:00.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/0004-PATCH-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch 2021-04-07 16:32:38.000000000 -0600 @@ -0,0 +1,146 @@ +From: Kazuhito Hagio <k-hagio...@nec.com> +Date: Fri, 29 Jan 2021 11:40:23 +0900 +Subject: [PATCH 1/3] Use vmcoreinfo note in /proc/kcore for --mem-usage + option + +kernel commit 23c85094fe18 added vmcoreinfo note to /proc/kcore. +Use the vmcoreinfo note to get necessary information, especially +page_offset and phys_base on arm64, for the --mem-usage option. + +Signed-off-by: Kazuhito Hagio <k-hagio...@nec.com> + +Origin: upstream, https://github.com/makedumpfile/makedumpfile/commit/d8b701796f0491f2ac4b06c7a5b795c29399efab +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=986594 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1879214 +--- + elf_info.c | 49 ------------------------------------------------- + elf_info.h | 1 - + makedumpfile.c | 26 +++++++++++++++++++++----- + 3 files changed, 21 insertions(+), 55 deletions(-) + +diff --git a/elf_info.c b/elf_info.c +index a6624b5..e8affb7 100644 +--- a/elf_info.c ++++ b/elf_info.c +@@ -698,55 +698,6 @@ get_elf32_ehdr(int fd, char *filename, Elf32_Ehdr *ehdr) + return TRUE; + } + +-int +-get_elf_loads(int fd, char *filename) +-{ +- int i, j, phnum, elf_format; +- Elf64_Phdr phdr; +- +- /* +- * Check ELF64 or ELF32. +- */ +- elf_format = check_elf_format(fd, filename, &phnum, &num_pt_loads); +- if (elf_format == ELF64) +- flags_memory |= MEMORY_ELF64; +- else if (elf_format != ELF32) +- return FALSE; +- +- if (!num_pt_loads) { +- ERRMSG("Can't get the number of PT_LOAD.\n"); +- return FALSE; +- } +- +- /* +- * The below file information will be used as /proc/vmcore. +- */ +- fd_memory = fd; +- name_memory = filename; +- +- pt_loads = calloc(sizeof(struct pt_load_segment), num_pt_loads); +- if (pt_loads == NULL) { +- ERRMSG("Can't allocate memory for the PT_LOAD. %s\n", +- strerror(errno)); +- return FALSE; +- } +- for (i = 0, j = 0; i < phnum; i++) { +- if (!get_phdr_memory(i, &phdr)) +- return FALSE; +- +- if (phdr.p_type != PT_LOAD) +- continue; +- +- if (j >= num_pt_loads) +- return FALSE; +- if (!dump_Elf_load(&phdr, j)) +- return FALSE; +- j++; +- } +- +- return TRUE; +-} +- + static int exclude_segment(struct pt_load_segment **pt_loads, + unsigned int *num_pt_loads, uint64_t start, uint64_t end) + { +diff --git a/elf_info.h b/elf_info.h +index d9b5d05..d5416b3 100644 +--- a/elf_info.h ++++ b/elf_info.h +@@ -44,7 +44,6 @@ int get_elf64_ehdr(int fd, char *filename, Elf64_Ehdr *ehdr); + int get_elf32_ehdr(int fd, char *filename, Elf32_Ehdr *ehdr); + int get_elf_info(int fd, char *filename); + void free_elf_info(void); +-int get_elf_loads(int fd, char *filename); + int set_kcore_vmcoreinfo(uint64_t vmcoreinfo_addr, uint64_t vmcoreinfo_len); + int get_kcore_dump_loads(void); + +diff --git a/makedumpfile.c b/makedumpfile.c +index 061741f..949b7e4 100644 +--- a/makedumpfile.c ++++ b/makedumpfile.c +@@ -11413,6 +11413,7 @@ int show_mem_usage(void) + { + uint64_t vmcoreinfo_addr, vmcoreinfo_len; + struct cycle cycle = {0}; ++ int vmcoreinfo = FALSE; + + if (!is_crashkernel_mem_reserved()) { + ERRMSG("No memory is reserved for crashkernel!\n"); +@@ -11424,9 +11425,22 @@ int show_mem_usage(void) + if (!open_files_for_creating_dumpfile()) + return FALSE; + +- if (!get_elf_loads(info->fd_memory, info->name_memory)) ++ if (!get_elf_info(info->fd_memory, info->name_memory)) + return FALSE; + ++ /* ++ * /proc/kcore on Linux 4.19 and later kernels have vmcoreinfo note in ++ * NOTE segment. See commit 23c85094fe18. ++ */ ++ if (has_vmcoreinfo()) { ++ off_t offset; ++ unsigned long size; ++ ++ get_vmcoreinfo(&offset, &size); ++ vmcoreinfo = read_vmcoreinfo_from_vmcore(offset, size, FALSE); ++ DEBUG_MSG("Read vmcoreinfo from NOTE segment: %d\n", vmcoreinfo); ++ } ++ + if (!get_page_offset()) + return FALSE; + +@@ -11434,11 +11448,13 @@ int show_mem_usage(void) + if (!get_phys_base()) + return FALSE; + +- if (!get_sys_kernel_vmcoreinfo(&vmcoreinfo_addr, &vmcoreinfo_len)) +- return FALSE; ++ if (!vmcoreinfo) { ++ if (!get_sys_kernel_vmcoreinfo(&vmcoreinfo_addr, &vmcoreinfo_len)) ++ return FALSE; + +- if (!set_kcore_vmcoreinfo(vmcoreinfo_addr, vmcoreinfo_len)) +- return FALSE; ++ if (!set_kcore_vmcoreinfo(vmcoreinfo_addr, vmcoreinfo_len)) ++ return FALSE; ++ } + + if (!initial()) + return FALSE; diff -Nru makedumpfile-1.6.8/debian/patches/0005-PATCH-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch makedumpfile-1.6.8/debian/patches/0005-PATCH-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch --- makedumpfile-1.6.8/debian/patches/0005-PATCH-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch 1969-12-31 17:00:00.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/0005-PATCH-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch 2021-04-07 16:32:38.000000000 -0600 @@ -0,0 +1,100 @@ +From: Kazuhito Hagio <k-hagio...@nec.com> +Date: Fri, 29 Jan 2021 11:40:24 +0900 +Subject: [PATCH 2/3] arm64: Make use of NUMBER(VA_BITS) in vmcoreinfo + +Make use of the NUMBER(VA_BITS) in vmcoreinfo, which was added by +kernel commit 20a166243328 (Linux 4.12 and later kernels), as the +current way of guessing VA_BITS does not work on Linux 5.4 and +later kernels. + +Signed-off-by: Bhupesh Sharma <bhsha...@redhat.com> +Signed-off-by: Kazuhito Hagio <k-hagio...@nec.com> + +Origin: upstream, https://github.com/makedumpfile/makedumpfile/commit/67d0e1d68f28c567a704fd6b9b8fd696ad3df183 +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=986594 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1879214 +--- + arch/arm64.c | 63 ++++++++++++++++++++++++++++++++++++++++-------------------- + 1 file changed, 42 insertions(+), 21 deletions(-) + +diff --git a/arch/arm64.c b/arch/arm64.c +index 3d7b416..2916b4f 100644 +--- a/arch/arm64.c ++++ b/arch/arm64.c +@@ -345,6 +345,43 @@ get_stext_symbol(void) + return(found ? kallsym : FALSE); + } + ++static int ++get_va_bits_from_stext_arm64(void) ++{ ++ ulong _stext; ++ ++ _stext = get_stext_symbol(); ++ if (!_stext) { ++ ERRMSG("Can't get the symbol of _stext.\n"); ++ return FALSE; ++ } ++ ++ /* ++ * Derive va_bits as per arch/arm64/Kconfig. Note that this is a ++ * best case approximation at the moment, as there can be ++ * inconsistencies in this calculation (for e.g., for 52-bit ++ * kernel VA case, the 48th bit is set in * the _stext symbol). ++ */ ++ if ((_stext & PAGE_OFFSET_48) == PAGE_OFFSET_48) { ++ va_bits = 48; ++ } else if ((_stext & PAGE_OFFSET_47) == PAGE_OFFSET_47) { ++ va_bits = 47; ++ } else if ((_stext & PAGE_OFFSET_42) == PAGE_OFFSET_42) { ++ va_bits = 42; ++ } else if ((_stext & PAGE_OFFSET_39) == PAGE_OFFSET_39) { ++ va_bits = 39; ++ } else if ((_stext & PAGE_OFFSET_36) == PAGE_OFFSET_36) { ++ va_bits = 36; ++ } else { ++ ERRMSG("Cannot find a proper _stext for calculating VA_BITS\n"); ++ return FALSE; ++ } ++ ++ DEBUG_MSG("va_bits : %d (guess from _stext)\n", va_bits); ++ ++ return TRUE; ++} ++ + int + get_machdep_info_arm64(void) + { +@@ -398,27 +435,11 @@ get_xen_info_arm64(void) + int + get_versiondep_info_arm64(void) + { +- ulong _stext; +- +- _stext = get_stext_symbol(); +- if (!_stext) { +- ERRMSG("Can't get the symbol of _stext.\n"); +- return FALSE; +- } +- +- /* Derive va_bits as per arch/arm64/Kconfig */ +- if ((_stext & PAGE_OFFSET_36) == PAGE_OFFSET_36) { +- va_bits = 36; +- } else if ((_stext & PAGE_OFFSET_39) == PAGE_OFFSET_39) { +- va_bits = 39; +- } else if ((_stext & PAGE_OFFSET_42) == PAGE_OFFSET_42) { +- va_bits = 42; +- } else if ((_stext & PAGE_OFFSET_47) == PAGE_OFFSET_47) { +- va_bits = 47; +- } else if ((_stext & PAGE_OFFSET_48) == PAGE_OFFSET_48) { +- va_bits = 48; +- } else { +- ERRMSG("Cannot find a proper _stext for calculating VA_BITS\n"); ++ if (NUMBER(VA_BITS) != NOT_FOUND_NUMBER) { ++ va_bits = NUMBER(VA_BITS); ++ DEBUG_MSG("va_bits : %d (vmcoreinfo)\n", va_bits); ++ } else if (get_va_bits_from_stext_arm64() == FALSE) { ++ ERRMSG("Can't determine va_bits.\n"); + return FALSE; + } + diff -Nru makedumpfile-1.6.8/debian/patches/0006-PATCH-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch makedumpfile-1.6.8/debian/patches/0006-PATCH-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch --- makedumpfile-1.6.8/debian/patches/0006-PATCH-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch 1969-12-31 17:00:00.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/0006-PATCH-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch 2021-04-07 16:32:38.000000000 -0600 @@ -0,0 +1,244 @@ +From: Kazuhito Hagio <k-hagio...@nec.com> +Date: Fri, 29 Jan 2021 11:40:25 +0900 +Subject: [PATCH 3/3] arm64: support flipped VA and 52-bit kernel VA + +Linux 5.4 and later kernels for arm64 changed the kernel VA space +arrangement and introduced 52-bit kernel VAs by merging branch +commit b333b0ba2346. Support 5.9+ kernels with vmcoreinfo entries +and 5.4+ kernels with best guessing. + +However, the following conditions are not supported for now due to +no necessary information provided from kernel: +(1) 5.4 <= kernels <= 5.8 and + - if PA_BITS=52 && VA_BITS!=52 + - with -x option if vabits_actual=52 +(2) kernels < 5.4 with CONFIG_ARM64_USER_VA_BITS_52=y + +(1) should be supported with kernel commit bbdbc11804ff and +1d50e5d0c5052 adding necessary information to vmcoreinfo. + +Signed-off-by: Bhupesh Sharma <bhsha...@redhat.com> +Signed-off-by: Kazuhito Hagio <k-hagio...@nec.com> +Reviewed-by: Pingfan Liu <pi...@redhat.com> + +Origin: upstream, https://github.com/makedumpfile/makedumpfile/commit/a0216b678a95f099a16172cc4a67ad5aa6a89583 +Bug-Debian: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=986594 +Bug-Ubuntu: https://bugs.launchpad.net/bugs/1879214 +--- + arch/arm64.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++++--------- + makedumpfile.c | 2 ++ + makedumpfile.h | 1 + + 3 files changed, 88 insertions(+), 15 deletions(-) + +diff --git a/arch/arm64.c b/arch/arm64.c +index 2916b4f..1072178 100644 +--- a/arch/arm64.c ++++ b/arch/arm64.c +@@ -47,6 +47,8 @@ typedef struct { + static int lpa_52_bit_support_available; + static int pgtable_level; + static int va_bits; ++static int vabits_actual; ++static int flipped_va; + static unsigned long kimage_voffset; + + #define SZ_4K 4096 +@@ -58,7 +60,6 @@ static unsigned long kimage_voffset; + #define PAGE_OFFSET_42 ((0xffffffffffffffffUL) << 42) + #define PAGE_OFFSET_47 ((0xffffffffffffffffUL) << 47) + #define PAGE_OFFSET_48 ((0xffffffffffffffffUL) << 48) +-#define PAGE_OFFSET_52 ((0xffffffffffffffffUL) << 52) + + #define pgd_val(x) ((x).pgd) + #define pud_val(x) (pgd_val((x).pgd)) +@@ -218,12 +219,20 @@ pmd_page_paddr(pmd_t pmd) + #define pte_index(vaddr) (((vaddr) >> PAGESHIFT()) & (PTRS_PER_PTE - 1)) + #define pte_offset(dir, vaddr) (pmd_page_paddr((*dir)) + pte_index(vaddr) * sizeof(pte_t)) + ++/* ++ * The linear kernel range starts at the bottom of the virtual address ++ * space. Testing the top bit for the start of the region is a ++ * sufficient check and avoids having to worry about the tag. ++ */ ++#define is_linear_addr(addr) (flipped_va ? \ ++ (!((unsigned long)(addr) & (1UL << (vabits_actual - 1)))) : \ ++ (!!((unsigned long)(addr) & (1UL << (vabits_actual - 1))))) ++ + static unsigned long long + __pa(unsigned long vaddr) + { +- if (kimage_voffset == NOT_FOUND_NUMBER || +- (vaddr >= PAGE_OFFSET)) +- return (vaddr - PAGE_OFFSET + info->phys_base); ++ if (kimage_voffset == NOT_FOUND_NUMBER || is_linear_addr(vaddr)) ++ return ((vaddr & ~PAGE_OFFSET) + info->phys_base); + else + return (vaddr - kimage_voffset); + } +@@ -253,6 +262,7 @@ static int calculate_plat_config(void) + (PAGESIZE() == SZ_64K && va_bits == 42)) { + pgtable_level = 2; + } else if ((PAGESIZE() == SZ_64K && va_bits == 48) || ++ (PAGESIZE() == SZ_64K && va_bits == 52) || + (PAGESIZE() == SZ_4K && va_bits == 39) || + (PAGESIZE() == SZ_16K && va_bits == 47)) { + pgtable_level = 3; +@@ -263,6 +273,7 @@ static int calculate_plat_config(void) + PAGESIZE(), va_bits); + return FALSE; + } ++ DEBUG_MSG("pgtable_level: %d\n", pgtable_level); + + return TRUE; + } +@@ -270,6 +281,9 @@ static int calculate_plat_config(void) + unsigned long + get_kvbase_arm64(void) + { ++ if (flipped_va) ++ return PAGE_OFFSET; ++ + return (0xffffffffffffffffUL << va_bits); + } + +@@ -382,22 +396,54 @@ get_va_bits_from_stext_arm64(void) + return TRUE; + } + ++static void ++get_page_offset_arm64(void) ++{ ++ ulong page_end; ++ int vabits_min; ++ ++ /* ++ * See arch/arm64/include/asm/memory.h for more details of ++ * the PAGE_OFFSET calculation. ++ */ ++ vabits_min = (va_bits > 48) ? 48 : va_bits; ++ page_end = -(1UL << (vabits_min - 1)); ++ ++ if (SYMBOL(_stext) > page_end) { ++ flipped_va = TRUE; ++ info->page_offset = -(1UL << vabits_actual); ++ } else { ++ flipped_va = FALSE; ++ info->page_offset = -(1UL << (vabits_actual - 1)); ++ } ++ ++ DEBUG_MSG("page_offset : %lx (from page_end check)\n", ++ info->page_offset); ++} ++ + int + get_machdep_info_arm64(void) + { ++ /* Check if va_bits is still not initialized. If still 0, call ++ * get_versiondep_info() to initialize the same. ++ */ ++ if (!va_bits) ++ get_versiondep_info_arm64(); ++ + /* Determine if the PA address range is 52-bits: ARMv8.2-LPA */ + if (NUMBER(MAX_PHYSMEM_BITS) != NOT_FOUND_NUMBER) { + info->max_physmem_bits = NUMBER(MAX_PHYSMEM_BITS); ++ DEBUG_MSG("max_physmem_bits : %ld (vmcoreinfo)\n", info->max_physmem_bits); + if (info->max_physmem_bits == 52) + lpa_52_bit_support_available = 1; +- } else +- info->max_physmem_bits = 48; ++ } else { ++ if (va_bits == 52) ++ info->max_physmem_bits = 52; /* just guess */ ++ else ++ info->max_physmem_bits = 48; + +- /* Check if va_bits is still not initialized. If still 0, call +- * get_versiondep_info() to initialize the same. +- */ +- if (!va_bits) +- get_versiondep_info_arm64(); ++ DEBUG_MSG("max_physmem_bits : %ld (guess)\n", info->max_physmem_bits); ++ } + + if (!calculate_plat_config()) { + ERRMSG("Can't determine platform config values\n"); +@@ -408,7 +454,6 @@ get_machdep_info_arm64(void) + info->section_size_bits = SECTIONS_SIZE_BITS; + + DEBUG_MSG("kimage_voffset : %lx\n", kimage_voffset); +- DEBUG_MSG("max_physmem_bits : %ld\n", info->max_physmem_bits); + DEBUG_MSG("section_size_bits: %ld\n", info->section_size_bits); + + return TRUE; +@@ -443,10 +488,35 @@ get_versiondep_info_arm64(void) + return FALSE; + } + +- info->page_offset = (0xffffffffffffffffUL) << (va_bits - 1); ++ /* ++ * See TCR_EL1, Translation Control Register (EL1) register ++ * description in the ARMv8 Architecture Reference Manual. ++ * Basically, we can use the TCR_EL1.T1SZ value to determine ++ * the virtual addressing range supported in the kernel-space ++ * (i.e. vabits_actual) since Linux 5.9. ++ */ ++ if (NUMBER(TCR_EL1_T1SZ) != NOT_FOUND_NUMBER) { ++ vabits_actual = 64 - NUMBER(TCR_EL1_T1SZ); ++ DEBUG_MSG("vabits_actual : %d (vmcoreinfo)\n", vabits_actual); ++ } else if ((va_bits == 52) && (SYMBOL(mem_section) != NOT_FOUND_SYMBOL)) { ++ /* ++ * Linux 5.4 through 5.10 have the following linear space: ++ * 48-bit: 0xffff000000000000 - 0xffff7fffffffffff ++ * 52-bit: 0xfff0000000000000 - 0xfff7ffffffffffff ++ * and SYMBOL(mem_section) should be in linear space if ++ * the kernel is configured with COMFIG_SPARSEMEM_EXTREME=y. ++ */ ++ if (SYMBOL(mem_section) & (1UL << (va_bits - 1))) ++ vabits_actual = 48; ++ else ++ vabits_actual = 52; ++ DEBUG_MSG("vabits_actual : %d (guess from mem_section)\n", vabits_actual); ++ } else { ++ vabits_actual = va_bits; ++ DEBUG_MSG("vabits_actual : %d (same as va_bits)\n", vabits_actual); ++ } + +- DEBUG_MSG("va_bits : %d\n", va_bits); +- DEBUG_MSG("page_offset : %lx\n", info->page_offset); ++ get_page_offset_arm64(); + + return TRUE; + } +diff --git a/makedumpfile.c b/makedumpfile.c +index 949b7e4..aaaea38 100644 +--- a/makedumpfile.c ++++ b/makedumpfile.c +@@ -2383,6 +2383,7 @@ write_vmcoreinfo_data(void) + WRITE_NUMBER("HUGETLB_PAGE_DTOR", HUGETLB_PAGE_DTOR); + #ifdef __aarch64__ + WRITE_NUMBER("VA_BITS", VA_BITS); ++ /* WRITE_NUMBER("TCR_EL1_T1SZ", TCR_EL1_T1SZ); should not exists */ + WRITE_NUMBER_UNSIGNED("PHYS_OFFSET", PHYS_OFFSET); + WRITE_NUMBER_UNSIGNED("kimage_voffset", kimage_voffset); + #endif +@@ -2821,6 +2822,7 @@ read_vmcoreinfo(void) + READ_NUMBER("KERNEL_IMAGE_SIZE", KERNEL_IMAGE_SIZE); + #ifdef __aarch64__ + READ_NUMBER("VA_BITS", VA_BITS); ++ READ_NUMBER("TCR_EL1_T1SZ", TCR_EL1_T1SZ); + READ_NUMBER_UNSIGNED("PHYS_OFFSET", PHYS_OFFSET); + READ_NUMBER_UNSIGNED("kimage_voffset", kimage_voffset); + #endif +diff --git a/makedumpfile.h b/makedumpfile.h +index 47f7e79..0fe3645 100644 +--- a/makedumpfile.h ++++ b/makedumpfile.h +@@ -1993,6 +1993,7 @@ struct number_table { + long KERNEL_IMAGE_SIZE; + #ifdef __aarch64__ + long VA_BITS; ++ long TCR_EL1_T1SZ; + unsigned long PHYS_OFFSET; + unsigned long kimage_voffset; + #endif diff -Nru makedumpfile-1.6.8/debian/patches/series makedumpfile-1.6.8/debian/patches/series --- makedumpfile-1.6.8/debian/patches/series 2021-01-18 07:50:02.000000000 -0700 +++ makedumpfile-1.6.8/debian/patches/series 2021-04-07 16:32:38.000000000 -0600 @@ -1 +1,6 @@ 0002-adapt-makefile-to-debian.patch +0002-PATCH-1-2-printk-add-support-for-lockless-ringbuffer.patch +0003-PATCH-2-2-printk-use-committed-finalized-state-value.patch +0004-PATCH-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch +0005-PATCH-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch +0006-PATCH-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch