pool/makedumpfile
SHA256
2
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Accepting request 905563 from home:susnux:branches:Kernel:kdump

Browse Source 
Update to 1.6.9

(the SPEC fill provides the SLE11 compatibility part (TINFO) so make the %prep section also SLE11 compatible)

OBS-URL: https://build.opensuse.org/request/show/905563
OBS-URL: https://build.opensuse.org/package/show/Kernel:kdump/makedumpfile?expand=0&rev=156
This commit is contained in:
Petr Tesařík 2021-07-21 07:43:06 +00:00 committed by Git OBS Bridge
parent e9d9941e74
commit d363e92c0d
12 changed files with 35 additions and 1299 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
makedumpfile-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch
View File

@ -1,147 +0,0 @@
From: Kazuhito Hagio <k-hagio-ab@nec.com>
Date: Fri, 29 Jan 2021 11:40:23 +0900
Subject: [PATCH 1/3] [PATCH 1/3] Use vmcoreinfo note in /proc/kcore for
--mem-usage option
Upstream: merged
Git-commit: d8b701796f0491f2ac4b06c7a5b795c29399efab
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-ab@nec.com>
---
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 ba0003a..768eda4 100644
--- a/makedumpfile.c
+++ b/makedumpfile.c
@@ -11445,6 +11445,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");
@@ -11456,9 +11457,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;
@@ -11466,11 +11480,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;
--
2.30.2

3
makedumpfile-1.6.8.tar.gz
View File

@ -1,3 +0,0 @@
version https://git-lfs.github.com/spec/v1
oid sha256:85d79b7090e9a8ce0d426795d3bc1de2858def7e12954d9bc6ae03de160b694c
size 195709

3
makedumpfile-1.6.9.tar.gz Normal file
View File

@ -0,0 +1,3 @@
version https://git-lfs.github.com/spec/v1
oid sha256:393ea8f22393c059ad21de9b1c3f45d9d0d8dbeb0ccb1417815b835d03f7c350
size 200869

102
makedumpfile-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch
View File

@ -1,102 +0,0 @@
From: Kazuhito Hagio <k-hagio-ab@nec.com>
Date: Fri, 29 Jan 2021 11:40:24 +0900
Subject: [PATCH 2/3] [PATCH 2/3] arm64: Make use of NUMBER(VA_BITS) in
vmcoreinfo
Upstream: merged
Git-commit: 67d0e1d68f28c567a704fd6b9b8fd696ad3df183
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 <bhsharma@redhat.com>
Signed-off-by: Kazuhito Hagio <k-hagio-ab@nec.com>
---
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;
}
--
2.30.2

246
makedumpfile-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch
View File

@ -1,246 +0,0 @@
From: Kazuhito Hagio <k-hagio-ab@nec.com>
Date: Fri, 29 Jan 2021 11:40:25 +0900
Subject: [PATCH 3/3] [PATCH 3/3] arm64: support flipped VA and 52-bit kernel
VA
Upstream: merged
Git-commit: a0216b678a95f099a16172cc4a67ad5aa6a89583
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 <bhsharma@redhat.com>
Signed-off-by: Kazuhito Hagio <k-hagio-ab@nec.com>
Reviewed-by: Pingfan Liu <piliu@redhat.com>
---
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 768eda4..fcd766b 100644
--- a/makedumpfile.c
+++ b/makedumpfile.c
@@ -2397,6 +2397,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
@@ -2836,6 +2837,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 0ed6417..97a5554 100644
--- a/makedumpfile.h
+++ b/makedumpfile.h
@@ -2049,6 +2049,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
--
2.30.2

2
makedumpfile-override-libtinfo.patch
View File

@ -18,7 +18,7 @@ Signed-off-by: Petr Tesarik <ptesarik@suse.com>
+TINFOLIB = -ltinfo
+
LIBS := -lpthread $(LIBS)
LIBS := $(LIBS) -lpthread
try-run = $(shell set -e; \
@@ -101,7 +103,7 @@ makedumpfile: $(SRC_BASE) $(OBJ_PART) $(

589
makedumpfile-printk-add-support-for-lockless-ringbuffer.patch
View File

@ -1,589 +0,0 @@
From c617ec63339222f3a44d73e36677a9acc8954ccd Mon Sep 17 00:00:00 2001
From: John Ogness <john.ogness@linutronix.de>
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 <john.ogness@linutronix.de>
Signed-off-by: Kazuhito Hagio <k-hagio-ab@nec.com>
---
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 <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;
+}
--
2.26.2

101
makedumpfile-printk-use-committed-finalized-state-value.patch
View File

@ -1,101 +0,0 @@
From 44b073b7ec467aee0d7de381d455b8ace1199184 Mon Sep 17 00:00:00 2001
From: John Ogness <john.ogness@linutronix.de>
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 <john.ogness@linutronix.de>
---
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 <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)) %
--
2.26.2

2
makedumpfile-rpmlintrc
View File

@ -1 +1 @@
addFilter("devel-file-in-non-devel-package .*/usr/share/makedumpfile-1\.6\.3/eppic_scripts/.*\.c")
addFilter("devel-file-in-non-devel-package .*/usr/share/makedumpfile-\d+\.\d+\.\d+/eppic_scripts/.*\.c")

96
makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch
View File

@ -1,96 +0,0 @@
From: Alexander Egorenkov <egorenar@linux.ibm.com>
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 <egorenar@linux.ibm.com>
Acked-by: Petr Tesarik <ptesarik@suse.com>
---
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;
};
/*

21
makedumpfile.changes
View File

@ -1,3 +1,24 @@
-------------------------------------------------------------------
Sat Jul 10 13:15:50 UTC 2021 - Ferdinand Thiessen <rpm@fthiessen.de>
- Update to 1.6.9
* Add initial mips64 support
* Support newer kernels up to v5.12
* x86_64: fix a use-after-free bug in -e option
* arm64: support flipped VA and 52-bit kernel VA
* Add shorthand --show-stats option to show report stats
* Add --dry-run option to prevent writing the dumpfile
* printk: add support for lockless ringbuffer
- Fix rpmlintrc to not be version agnostic
- Refresh makedumpfile-override-libtinfo.patch
- Drop upstream merged
* makedumpfile-printk-add-support-for-lockless-ringbuffer.patch
* makedumpfile-printk-use-committed-finalized-state-value.patch
* makedumpfile-use-uts_namespace.name-offset-VMCOREINFO.patch
* makedumpfile-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch
* makedumpfile-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch
* makedumpfile-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch
-------------------------------------------------------------------
Mon Apr 19 10:35:31 UTC 2021 - Petr Tesařík <ptesarik@suse.com>

22
makedumpfile.spec
View File

@ -25,14 +25,14 @@
%endif
# Compatibility cruft
# there is no separate -ltinfo until openSUSE 13.1
# there is no separate -ltinfo until openSUSE 13.1 / SLE 12
%if 0%{?suse_version} < 1310 && 0%{?sles_version} < 12
%define ncurses_make_opts TINFOLIB=-lncurses
%endif
# End of compatibility cruft
Name: makedumpfile
Version: 1.6.8
Version: 1.6.9
Release: 0
Summary: Partial kernel dump
License: GPL-2.0-only
@ -40,15 +40,9 @@ Group: System/Kernel
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
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
Patch7: %{name}-1-3-Use-vmcoreinfo-note-in-proc-kcore-for-mem-.patch
Patch8: %{name}-2-3-arm64-Make-use-of-NUMBER-VA_BITS-in-vmcore.patch
Patch9: %{name}-3-3-arm64-support-flipped-VA-and-52-bit-kernel.patch
Patch0: %{name}-override-libtinfo.patch
Patch1: %{name}-ppc64-VA-range-SUSE.patch
Patch2: %{name}-PN_XNUM.patch
BuildRequires: libdw-devel
BuildRequires: libelf-devel
BuildRequires: libeppic-devel
@ -75,7 +69,9 @@ via gdb or crash utility.
%prep
%setup -q
%autopatch -p1
%patch0 -p1
%patch1 -p1
%patch2 -p1
%build
export CFLAGS="%{optflags} -fcommon"
@ -97,7 +93,7 @@ install -d -m 0755 %{buildroot}%{_datadir}/%{name}-%{version}/eppic_scripts
install -m 0644 -t %{buildroot}%{_datadir}/%{name}-%{version}/eppic_scripts/ eppic_scripts/*
# Compatibility cruft
# there is no %license prior to SLE12
# there is no %%license prior to SLE12
%if %{undefined _defaultlicensedir}
%define license %doc
%else