[PATCH] kexec/arm64: Add support for ARMv8.2 (large space addressing) 52-bit VA extensions

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



This patch adds support for ARMv8.2 52-bit VA (large space addressing)
extension in kexec-tools.

With ARMv8.2-LVA architecture extension availability, arm64 hardware
which supports this extension can support upto 52-bit virtual
addresses. It is specially useful for having a 52-bit user-space virtual
address space while the kernel can still retain 48-bit/52-bit virtual
addressing.

Since at the moment we enable the support of this extension in the
kernel via a CONFIG flag (CONFIG_ARM64_VA_BITS_52), so there are
no clear mechanisms in user-space to determine this CONFIG
flag value and use it to determine the kernel-space VA address range
values.

'kexec-tools' can instead use 'TCR_EL1.T1SZ' value from vmcoreinfo
which indicates the size offset of the memory region addressed by
TTBR1_EL1 (and hence can be used for determining the
'vabits_actual' value).

Using the vmcoreinfo variable exported by kernel commit
 bbdbc11804ff ("arm64/crash_core: Export TCR_EL1.T1SZ in vmcoreinfo"),
the user-space can use the following computation for determining the
'vabits_actual' value:

   if (TCR_EL1.T1SZ is available in vmcoreinfo)
	vabits_actual = 64 - TCR_EL1.T1SZ;
   else {
        read_id_aa64mmfr2_el1();

        if (hardware supports 52-bit addressing)
	   vabits_actual = 52;
        else
	   vabits_actual = va_bits value calculated via _stext symbol;
   }

I have tested several combinations with both old and latest upstream
kernels with different VA values (39, 42, 48 and 52-bits) on at-least
3 different boards, which include:
1. CPUs which don't support ARMv8.2 features, e.g. qualcomm-amberwing,
   ampere-osprey.
2. Prototype models which support ARMv8.2 extensions (e.g. ARMv8 FVP
   simulation model).

This patch is in accordance with ARMv8 Architecture Reference Manual.

Cc: Simon Horman <horms@xxxxxxxxxxxx>
Cc: kexec@xxxxxxxxxxxxxxxxxxx

Signed-off-by: Bhupesh Sharma <bhsharma@xxxxxxxxxx>
---
 kexec/arch/arm64/Makefile          |   2 +
 kexec/arch/arm64/common-arm64.c    | 332 +++++++++++++++++++++++++++++
 kexec/arch/arm64/common-arm64.h    |   8 +
 kexec/arch/arm64/crashdump-arm64.c |  29 +--
 kexec/arch/arm64/kexec-arm64.c     | 120 +----------
 kexec/kexec.h                      |  10 +
 util_lib/elf_info.c                |  35 +++
 util_lib/include/elf_info.h        |   2 +
 8 files changed, 397 insertions(+), 141 deletions(-)
 create mode 100644 kexec/arch/arm64/common-arm64.c
 create mode 100644 kexec/arch/arm64/common-arm64.h

diff --git a/kexec/arch/arm64/Makefile b/kexec/arch/arm64/Makefile
index d27c8ee1b5e7..4ae21c3b02e6 100644
--- a/kexec/arch/arm64/Makefile
+++ b/kexec/arch/arm64/Makefile
@@ -11,6 +11,7 @@ arm64_MEM_REGIONS = kexec/mem_regions.c
 arm64_CPPFLAGS += -I $(srcdir)/kexec/
 
 arm64_KEXEC_SRCS += \
+	kexec/arch/arm64/common-arm64.c \
 	kexec/arch/arm64/crashdump-arm64.c \
 	kexec/arch/arm64/kexec-arm64.c \
 	kexec/arch/arm64/kexec-elf-arm64.c \
@@ -27,6 +28,7 @@ arm64_PHYS_TO_VIRT =
 
 dist += $(arm64_KEXEC_SRCS) \
 	kexec/arch/arm64/include/arch/options.h \
+	kexec/arch/arm64/common-arm64.h \
 	kexec/arch/arm64/crashdump-arm64.h \
 	kexec/arch/arm64/image-header.h \
 	kexec/arch/arm64/iomem.h \
diff --git a/kexec/arch/arm64/common-arm64.c b/kexec/arch/arm64/common-arm64.c
new file mode 100644
index 000000000000..65942e8914e3
--- /dev/null
+++ b/kexec/arch/arm64/common-arm64.c
@@ -0,0 +1,332 @@
+/*
+ * ARM64 common parts for kexec and crash.
+ */
+
+#define _GNU_SOURCE
+
+#include <assert.h>
+#include <errno.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <libfdt.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <elf_info.h>
+
+#include <unistd.h>
+#include <syscall.h>
+#include <errno.h>
+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+
+#include "kexec.h"
+#include "kexec-arm64.h"
+#include "common-arm64.h"
+
+#define PAGE_OFFSET_36 ((0xffffffffffffffffUL) << 36)
+#define PAGE_OFFSET_39 ((0xffffffffffffffffUL) << 39)
+#define PAGE_OFFSET_42 ((0xffffffffffffffffUL) << 42)
+#define PAGE_OFFSET_47 ((0xffffffffffffffffUL) << 47)
+#define PAGE_OFFSET_48 ((0xffffffffffffffffUL) << 48)
+
+#define SZ_64K			65536
+
+/* ID_AA64MMFR2_EL1 related helpers: */
+#define ID_AA64MMFR2_LVA_SHIFT	16
+#define ID_AA64MMFR2_LVA_MASK	(0xf << ID_AA64MMFR2_LVA_SHIFT)
+
+/* CPU feature ID registers */
+#define get_cpu_ftr(id) ({							\
+		unsigned long __val;						\
+		asm volatile("mrs %0, " __stringify(id) : "=r" (__val));	\
+		__val;								\
+})
+
+/* Machine specific details. */
+static int va_bits;
+
+/* Global flag which indicates that we have tried reading
+ * TCR_EL1_T1SZ from 'kcore' already.
+ */
+static bool try_read_tcr_el1_t1sz_from_kcore = false;
+
+/**
+ * get_va_bits - Helper for getting VA_BITS
+ */
+
+static int get_va_bits(void)
+{
+	unsigned long long stext_sym_addr = get_kernel_sym("_stext");
+
+	if (stext_sym_addr == 0) {
+		fprintf(stderr, "Can't get the symbol of _stext.\n");
+		return -1;
+	}
+
+	/* 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).
+	 *
+	 * So, we need to read an architecture system register for a
+	 * accurate value of the virtual addressing supported by
+	 * the underlying kernel.
+	 */
+	if ((stext_sym_addr & PAGE_OFFSET_48) == PAGE_OFFSET_48) {
+		va_bits = 48;
+	} else if ((stext_sym_addr & PAGE_OFFSET_47) == PAGE_OFFSET_47) {
+		va_bits = 47;
+	} else if ((stext_sym_addr & PAGE_OFFSET_42) == PAGE_OFFSET_42) {
+		va_bits = 42;
+	} else if ((stext_sym_addr & PAGE_OFFSET_39) == PAGE_OFFSET_39) {
+		va_bits = 39;
+	} else if ((stext_sym_addr & PAGE_OFFSET_36) == PAGE_OFFSET_36) {
+		va_bits = 36;
+	} else {
+		fprintf(stderr,
+			"Cannot find a proper _stext for calculating VA_BITS\n");
+		return -1;
+	}
+
+	dbgprintf("va_bits : %d\n", va_bits);
+
+	return 0;
+}
+
+/** Note that its important to note that the
+ * ID_AA64MMFR2_EL1 architecture register can be read
+ * only when we give an .arch hint to the gcc/binutils,
+ * so we use the gcc construct '__attribute__ ((target ("arch=armv8.2-a")))'
+ * here which is an .arch directive (see AArch64-Target-selection-directives
+ * documentation from ARM for details). This is required only for
+ * this function to make sure it compiles well with gcc/binutils.
+ */
+
+__attribute__ ((target ("arch=armv8.2-a")))
+static unsigned long read_id_aa64mmfr2_el1(void)
+{
+	return get_cpu_ftr(ID_AA64MMFR2_EL1);
+}
+
+static int get_vabits_actual_from_id_aa64mmfr2_el1(void)
+{
+	int l_vabits_actual;
+	unsigned long val;
+
+	/* Check if ID_AA64MMFR2_EL1 CPU-ID register indicates
+	 * ARMv8.2/LVA support:
+	 * VARange, bits [19:16]
+	 *   From ARMv8.2:
+	 *   Indicates support for a larger virtual address.
+	 *   Defined values are:
+	 *     0b0000 VMSAv8-64 supports 48-bit VAs.
+	 *     0b0001 VMSAv8-64 supports 52-bit VAs when using the 64KB
+	 *            page size. The other translation granules support
+	 *            48-bit VAs.
+	 *
+	 * See ARMv8 ARM for more details.
+	 */
+	if (!(getauxval(AT_HWCAP) & HWCAP_CPUID)) {
+		fprintf(stderr, "arm64 CPUID registers unavailable.\n");
+		return EFAILED;
+	}
+
+	val = read_id_aa64mmfr2_el1();
+	val = (val & ID_AA64MMFR2_LVA_MASK) > ID_AA64MMFR2_LVA_SHIFT;
+
+	if ((val == 0x1) && (getpagesize() == SZ_64K))
+		l_vabits_actual = 52;
+	else
+		l_vabits_actual = 48;
+
+	return l_vabits_actual;
+}
+
+/**
+ * get_vabits_actual - Helper for getting vabits_actual
+ */
+
+static void get_vabits_actual(int *vabits_actual)
+{
+	int l_vabits_actual;
+
+	/* Try to read ID_AA64MMFR2_EL1 CPU-ID register,
+	 * to calculate the vabits_actual.
+	 */
+	l_vabits_actual = get_vabits_actual_from_id_aa64mmfr2_el1();
+	if ((l_vabits_actual == EFAILED) || (l_vabits_actual != 52)) {
+		/* If we cannot read ID_AA64MMFR2_EL1 arch
+		 * register or if this register does not indicate
+		 * support for a larger virtual address, our last
+		 * option is to use the VA_BITS to calculate the
+		 * PAGE_OFFSET value, i.e. vabits_actual = VA_BITS.
+		 */
+		l_vabits_actual = va_bits;
+		dbgprintf("vabits_actual : %d (approximation via va_bits)\n",
+				l_vabits_actual);
+	} else
+		dbgprintf("vabits_actual : %d (via id_aa64mmfr2_el1)\n",
+				l_vabits_actual);
+
+	*vabits_actual = l_vabits_actual;
+}
+
+/**
+ * get_tcr_el1_t1sz_from_vmcoreinfo_pt_note - Helper for getting TCR_EL1_T1SZ
+ * from VMCOREINFO note inside 'kcore'.
+ */
+
+int get_tcr_el1_t1sz_from_vmcoreinfo_pt_note(unsigned long *tcr_t1sz)
+{
+	int fd, ret = 0;
+
+	if ((fd = open("/proc/kcore", O_RDONLY)) < 0) {
+		fprintf(stderr, "Can't open (%s).\n", "/proc/kcore");
+		return EFAILED;
+	}
+
+	ret = read_tcr_el1_t1sz_elf_kcore(fd, tcr_t1sz);
+
+	close(fd);
+	return ret;
+}
+
+/**
+ * get_page_offset_helper - Helper for getting PAGE_OFFSET
+ */
+
+static int get_page_offset_helper(unsigned long *page_offset)
+{
+	int ret;
+	int vabits_actual = INT_MAX;
+	unsigned long tcr_t1sz = UINT64_MAX;
+
+	if (!try_read_tcr_el1_t1sz_from_kcore) {
+		/* Since kernel version 5.5.0, 'kcore' contains
+		 * a new PT_NOTE which carries the VMCOREINFO
+		 * information.
+		 * If the same is available, one should prefer the
+		 * same to retrieve 'TCR_EL1_T1SZ' value exported by
+		 * the kernel as this is now the standard interface
+		 * exposed by kernel for sharing machine specific
+		 * details with the userland.
+		 */
+		ret = get_tcr_el1_t1sz_from_vmcoreinfo_pt_note(&tcr_t1sz);
+		if (!ret) {
+			if (tcr_t1sz != UINT64_MAX) {
+				vabits_actual = 64 - tcr_t1sz;
+				dbgprintf("vabits_actual : %d (via vmcore)\n",
+						vabits_actual);
+			}
+		}
+
+		try_read_tcr_el1_t1sz_from_kcore = true;
+	}
+
+	if (vabits_actual == INT_MAX) {
+		/* If we are running on a older kernel,
+		 * try to retrieve the 'vabits_actual' value
+		 * via other means.
+		 */
+		ret = get_va_bits();
+		if (ret < 0)
+			return ret;
+
+		get_vabits_actual(&vabits_actual);
+	}
+
+	/* If 'vabits_actual' is still uninitialized,
+	 * bail out.
+	 */
+	if (vabits_actual == INT_MAX)
+		return EFAILED;
+
+	/* See arch/arm64/include/asm/memory.h for more details of
+	 * the PAGE_OFFSET calculation.
+	 */
+	if (kernel_version() < KERNEL_VERSION(5, 4, 0))
+		*page_offset = ((0xffffffffffffffffUL) -
+				((1UL) << (vabits_actual - 1)) + 1);
+	else
+		*page_offset = (-(1UL << vabits_actual));
+
+	dbgprintf("page_offset : %lx (via vabits_actual)\n", *page_offset);
+
+	return 0;
+}
+
+/**
+ * get_page_offset - Helper for getting PAGE_OFFSET
+ */
+
+int get_page_offset(unsigned long *page_offset)
+{
+	return get_page_offset_helper(page_offset);
+}
+
+/**
+ * get_phys_offset_from_vmcoreinfo_pt_note - Helper for getting PHYS_OFFSET
+ * from VMCOREINFO note inside 'kcore'.
+ */
+
+int get_phys_offset_from_vmcoreinfo_pt_note(unsigned long *phys_offset)
+{
+	int fd, ret = 0;
+
+	if ((fd = open("/proc/kcore", O_RDONLY)) < 0) {
+		fprintf(stderr, "Can't open (%s).\n", "/proc/kcore");
+		return EFAILED;
+	}
+
+	ret = read_phys_offset_elf_kcore(fd, phys_offset);
+
+	close(fd);
+	return ret;
+}
+
+/**
+ * get_phys_base_from_pt_load - Helper for getting PHYS_OFFSET
+ * from PT_LOADs inside 'kcore'.
+ */
+
+int get_phys_base_from_pt_load(unsigned long *phys_offset)
+{
+	int i, fd, ret;
+	unsigned long page_offset;
+	unsigned long long phys_start;
+	unsigned long long virt_start;
+
+	ret = get_page_offset(&page_offset);
+	if (ret < 0)
+		return ret;
+
+	if ((fd = open("/proc/kcore", O_RDONLY)) < 0) {
+		fprintf(stderr, "Can't open (%s).\n", "/proc/kcore");
+		return EFAILED;
+	}
+
+	read_elf(fd);
+
+	/* Note that the following loop starts with i = 1.
+	 * This is required to make sure that the following logic
+	 * works both for old and newer kernels (with flipped
+	 * VA space, i.e. >= 5.4.0)
+	 */
+	for (i = 1; get_pt_load(i,
+		    &phys_start, NULL, &virt_start, NULL);
+	 	    i++) {
+		if (virt_start != NOT_KV_ADDR
+				&& virt_start >= page_offset
+				&& phys_start != NOT_PADDR)
+			*phys_offset = phys_start -
+				(virt_start & ~page_offset);
+	}
+
+	close(fd);
+	return 0;
+}
+
diff --git a/kexec/arch/arm64/common-arm64.h b/kexec/arch/arm64/common-arm64.h
new file mode 100644
index 000000000000..ab430712a7cb
--- /dev/null
+++ b/kexec/arch/arm64/common-arm64.h
@@ -0,0 +1,8 @@
+#if !defined(COMMON_ARM64_H)
+#define COMMON_ARM64_H
+
+int get_page_offset(unsigned long *page_offset);
+int get_phys_offset_from_vmcoreinfo_pt_note(unsigned long *phys_offset);
+int get_phys_base_from_pt_load(unsigned long *phys_offset);
+
+#endif
diff --git a/kexec/arch/arm64/crashdump-arm64.c b/kexec/arch/arm64/crashdump-arm64.c
index 38d1a0f3000d..ae5c44852782 100644
--- a/kexec/arch/arm64/crashdump-arm64.c
+++ b/kexec/arch/arm64/crashdump-arm64.c
@@ -16,6 +16,7 @@
 #include <linux/elf.h>
 
 #include "kexec.h"
+#include "common-arm64.h"
 #include "crashdump.h"
 #include "crashdump-arm64.h"
 #include "iomem.h"
@@ -46,27 +47,6 @@ static struct crash_elf_info elf_info = {
 	.machine	= EM_AARCH64,
 };
 
-/*
- * Note: The returned value is correct only if !CONFIG_RANDOMIZE_BASE.
- */
-static uint64_t get_kernel_page_offset(void)
-{
-	int i;
-
-	if (elf_info.kern_vaddr_start == UINT64_MAX)
-		return UINT64_MAX;
-
-	/* Current max virtual memory range is 48-bits. */
-	for (i = 48; i > 0; i--)
-		if (!(elf_info.kern_vaddr_start & (1UL << i)))
-			break;
-
-	if (i <= 0)
-		return UINT64_MAX;
-	else
-		return UINT64_MAX << i;
-}
-
 /*
  * iomem_range_callback() - callback called for each iomem region
  * @data: not used
@@ -169,6 +149,7 @@ int load_crashdump_segments(struct kexec_info *info)
 {
 	unsigned long elfcorehdr;
 	unsigned long bufsz;
+	unsigned long page_offset;
 	void *buf;
 	int err;
 
@@ -182,7 +163,11 @@ int load_crashdump_segments(struct kexec_info *info)
 	if (err)
 		return EFAILED;
 
-	elf_info.page_offset = get_kernel_page_offset();
+	err = get_page_offset(&page_offset);
+	if (err)
+		return EFAILED;
+
+	elf_info.page_offset = page_offset;
 	dbgprintf("%s: page_offset:   %016llx\n", __func__,
 			elf_info.page_offset);
 
diff --git a/kexec/arch/arm64/kexec-arm64.c b/kexec/arch/arm64/kexec-arm64.c
index 45ebc54a9b6f..fbbe1946f8d7 100644
--- a/kexec/arch/arm64/kexec-arm64.c
+++ b/kexec/arch/arm64/kexec-arm64.c
@@ -25,6 +25,7 @@
 
 #include "kexec.h"
 #include "kexec-arm64.h"
+#include "common-arm64.h"
 #include "crashdump.h"
 #include "crashdump-arm64.h"
 #include "dt-ops.h"
@@ -42,21 +43,11 @@
 #define PROP_ELFCOREHDR "linux,elfcorehdr"
 #define PROP_USABLE_MEM_RANGE "linux,usable-memory-range"
 
-#define PAGE_OFFSET_36 ((0xffffffffffffffffUL) << 36)
-#define PAGE_OFFSET_39 ((0xffffffffffffffffUL) << 39)
-#define PAGE_OFFSET_42 ((0xffffffffffffffffUL) << 42)
-#define PAGE_OFFSET_47 ((0xffffffffffffffffUL) << 47)
-#define PAGE_OFFSET_48 ((0xffffffffffffffffUL) << 48)
-
 /* Global flag which indicates that we have tried reading
  * PHYS_OFFSET from 'kcore' already.
  */
 static bool try_read_phys_offset_from_kcore = false;
 
-/* Machine specific details. */
-static int va_bits;
-static unsigned long page_offset;
-
 /* Global varables the core kexec routines expect. */
 
 unsigned char reuse_initrd;
@@ -799,115 +790,6 @@ static inline void set_phys_offset(uint64_t v, char *set_method)
 	}
 }
 
-/**
- * get_va_bits - Helper for getting VA_BITS
- */
-
-static int get_va_bits(void)
-{
-	unsigned long long stext_sym_addr = get_kernel_sym("_stext");
-
-	if (stext_sym_addr == 0) {
-		fprintf(stderr, "Can't get the symbol of _stext.\n");
-		return -1;
-	}
-
-	/* Derive va_bits as per arch/arm64/Kconfig */
-	if ((stext_sym_addr & PAGE_OFFSET_36) == PAGE_OFFSET_36) {
-		va_bits = 36;
-	} else if ((stext_sym_addr & PAGE_OFFSET_39) == PAGE_OFFSET_39) {
-		va_bits = 39;
-	} else if ((stext_sym_addr & PAGE_OFFSET_42) == PAGE_OFFSET_42) {
-		va_bits = 42;
-	} else if ((stext_sym_addr & PAGE_OFFSET_47) == PAGE_OFFSET_47) {
-		va_bits = 47;
-	} else if ((stext_sym_addr & PAGE_OFFSET_48) == PAGE_OFFSET_48) {
-		va_bits = 48;
-	} else {
-		fprintf(stderr,
-			"Cannot find a proper _stext for calculating VA_BITS\n");
-		return -1;
-	}
-
-	dbgprintf("va_bits : %d\n", va_bits);
-
-	return 0;
-}
-
-/**
- * get_page_offset - Helper for getting PAGE_OFFSET
- */
-
-static int get_page_offset(void)
-{
-	int ret;
-
-	ret = get_va_bits();
-	if (ret < 0)
-		return ret;
-
-	page_offset = (0xffffffffffffffffUL) << (va_bits - 1);
-	dbgprintf("page_offset : %lx\n", page_offset);
-
-	return 0;
-}
-
-/**
- * get_phys_offset_from_vmcoreinfo_pt_note - Helper for getting PHYS_OFFSET
- * from VMCOREINFO note inside 'kcore'.
- */
-
-static int get_phys_offset_from_vmcoreinfo_pt_note(unsigned long *phys_offset)
-{
-	int fd, ret = 0;
-
-	if ((fd = open("/proc/kcore", O_RDONLY)) < 0) {
-		fprintf(stderr, "Can't open (%s).\n", "/proc/kcore");
-		return EFAILED;
-	}
-
-	ret = read_phys_offset_elf_kcore(fd, phys_offset);
-
-	close(fd);
-	return ret;
-}
-
-/**
- * get_phys_base_from_pt_load - Helper for getting PHYS_OFFSET
- * from PT_LOADs inside 'kcore'.
- */
-
-int get_phys_base_from_pt_load(unsigned long *phys_offset)
-{
-	int i, fd, ret;
-	unsigned long long phys_start;
-	unsigned long long virt_start;
-
-	ret = get_page_offset();
-	if (ret < 0)
-		return ret;
-
-	if ((fd = open("/proc/kcore", O_RDONLY)) < 0) {
-		fprintf(stderr, "Can't open (%s).\n", "/proc/kcore");
-		return EFAILED;
-	}
-
-	read_elf(fd);
-
-	for (i = 0; get_pt_load(i,
-		    &phys_start, NULL, &virt_start, NULL);
-	 	    i++) {
-		if (virt_start != NOT_KV_ADDR
-				&& virt_start >= page_offset
-				&& phys_start != NOT_PADDR)
-			*phys_offset = phys_start -
-				(virt_start & ~page_offset);
-	}
-
-	close(fd);
-	return 0;
-}
-
 static bool to_be_excluded(char *str)
 {
 	if (!strncmp(str, SYSTEM_RAM, strlen(SYSTEM_RAM)) ||
diff --git a/kexec/kexec.h b/kexec/kexec.h
index f0f347d5e9e0..e1d0264b4dc9 100644
--- a/kexec/kexec.h
+++ b/kexec/kexec.h
@@ -122,6 +122,16 @@ do { \
 		fprintf(stderr, __VA_ARGS__); \
 } while(0)
 
+/* Indirect stringification.  Doing two levels allows the parameter to be a
+ * macro itself.  For example, compile with -DFOO=bar, __stringify(FOO)
+ * converts to "bar".
+ *
+ * Copied from linux source: 'include/linux/stringify.h'
+ */
+
+#define __stringify_1(x...)	#x
+#define __stringify(x...)	__stringify_1(x)
+
 struct kexec_segment {
 	const void *buf;
 	size_t bufsz;
diff --git a/util_lib/elf_info.c b/util_lib/elf_info.c
index 7803a948a60e..1ab62a31aa16 100644
--- a/util_lib/elf_info.c
+++ b/util_lib/elf_info.c
@@ -45,6 +45,7 @@ static uint16_t log_offset_len = UINT16_MAX;
 static uint16_t log_offset_text_len = UINT16_MAX;
 
 static uint64_t phys_offset = UINT64_MAX;
+static uint64_t tcr_el1_t1sz = UINT64_MAX;
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 #define ELFDATANATIVE ELFDATA2LSB
@@ -411,6 +412,20 @@ void scan_vmcoreinfo(char *start, size_t size)
 			}
 		}
 
+		/* Check for TCR_EL1_T1SZ */
+		str = "NUMBER(TCR_EL1_T1SZ)=";
+		if (memcmp(str, pos, strlen(str)) == 0) {
+			tcr_el1_t1sz = strtoul(pos + strlen(str), &endp,
+							10);
+			if (strlen(endp) != 0)
+				tcr_el1_t1sz = strtoul(pos + strlen(str), &endp, 16);
+			if ((tcr_el1_t1sz == LONG_MAX) || strlen(endp) != 0) {
+				fprintf(stderr, "Invalid data %s\n",
+					pos);
+				break;
+			}
+		}
+
 		if (last_line)
 			break;
 	}
@@ -817,3 +832,23 @@ int read_phys_offset_elf_kcore(int fd, unsigned long *phys_off)
 
 	return 2;
 }
+
+int read_tcr_el1_t1sz_elf_kcore(int fd, unsigned long *tcr_t1sz)
+{
+	int ret;
+
+	*tcr_t1sz = UINT64_MAX;
+
+	ret = read_elf(fd);
+	if (!ret) {
+		/* If we have a valid 'tcr_el1_t1sz' by now,
+		 * return it to the caller now.
+		 */
+		if (tcr_el1_t1sz != UINT64_MAX) {
+			*tcr_t1sz = tcr_el1_t1sz;
+			return ret;
+		}
+	}
+
+	return 2;
+}
diff --git a/util_lib/include/elf_info.h b/util_lib/include/elf_info.h
index 4bc9279ba603..3aa24f64c7fb 100644
--- a/util_lib/include/elf_info.h
+++ b/util_lib/include/elf_info.h
@@ -29,6 +29,8 @@ int get_pt_load(int idx,
 	unsigned long long *virt_start,
 	unsigned long long *virt_end);
 int read_phys_offset_elf_kcore(int fd, unsigned long *phys_off);
+int read_tcr_el1_t1sz_elf_kcore(int fd, unsigned long *tcr_t1sz);
+
 int read_elf(int fd);
 void dump_dmesg(int fd, void (*handler)(char*, unsigned int));
 
-- 
2.26.2


_______________________________________________
kexec mailing list
kexec@xxxxxxxxxxxxxxxxxxx
http://lists.infradead.org/mailman/listinfo/kexec



[Index of Archives]     [LM Sensors]     [Linux Sound]     [ALSA Users]     [ALSA Devel]     [Linux Audio Users]     [Linux Media]     [Kernel]     [Gimp]     [Yosemite News]     [Linux Media]

  Powered by Linux