commit 9596b4388ea5ebbf7de79f0e377a497de1616654
Author: Bhupesh Sharma <bhsharma@redhat.com>
Date:   Thu Aug 6 13:17:26 2020 +0530

    crash/arm64: Revert to implementation used in crash-7.2.3-17.el8  [Support for CONFIG_ARM64_USER_VA_BITS_52 and CONFIG_ARM64_PA_BITS=52]
    
    Signed-off-by: Bhupesh Sharma <bhsharma@redhat.com>

diff --git a/arm64.c b/arm64.c
index 49e25733f094..dfcde6e11359 100644
--- a/arm64.c
+++ b/arm64.c
@@ -27,12 +27,9 @@
 static struct machine_specific arm64_machine_specific = { 0 };
 static int arm64_verify_symbol(const char *, ulong, char);
 static void arm64_parse_cmdline_args(void);
-static int arm64_search_for_kimage_voffset(ulong);
-static int verify_kimage_voffset(void);
 static void arm64_calc_kimage_voffset(void);
 static void arm64_calc_phys_offset(void);
 static void arm64_calc_virtual_memory_ranges(void);
-static void arm64_get_section_size_bits(void);
 static int arm64_kdump_phys_base(ulong *);
 static ulong arm64_processor_speed(void);
 static void arm64_init_kernel_pgd(void);
@@ -81,7 +78,7 @@ static int arm64_on_irq_stack(int, ulong);
 static void arm64_set_irq_stack(struct bt_info *);
 static void arm64_set_process_stack(struct bt_info *);
 static int arm64_get_kvaddr_ranges(struct vaddr_range *);
-static void arm64_get_crash_notes(void);
+static int arm64_get_crash_notes(void);
 static void arm64_calc_VA_BITS(void);
 static int arm64_is_uvaddr(ulong, struct task_context *);
 
@@ -147,12 +144,6 @@ arm64_init(int when)
 		if (kernel_symbol_exists("kimage_voffset"))
 			machdep->flags |= NEW_VMEMMAP;
 
-		if (!machdep->pagesize && 
-		    (string = pc->read_vmcoreinfo("PAGESIZE"))) {
-			machdep->pagesize = atoi(string);
-			free(string);
-		}
-
 		if (!machdep->pagesize) {
 			/*
 			 * Kerneldoc Documentation/arm64/booting.txt describes
@@ -179,16 +170,17 @@ arm64_init(int when)
 
 		}
 
-		/*
-		 * This code section will only be executed if the kernel is
-		 * earlier than Linux 4.4 (if there is no vmcoreinfo)
-		 */
 		if (!machdep->pagesize &&
 		    kernel_symbol_exists("swapper_pg_dir") &&
 		    kernel_symbol_exists("idmap_pg_dir")) {
-			value = symbol_value("swapper_pg_dir") -
-				symbol_value("idmap_pg_dir");
+			if (kernel_symbol_exists("tramp_pg_dir"))
+				value = symbol_value("tramp_pg_dir");
+			else if (kernel_symbol_exists("reserved_ttbr0"))
+				value = symbol_value("reserved_ttbr0");
+			else
+				value = symbol_value("swapper_pg_dir");
 
+			value -= symbol_value("idmap_pg_dir");
 			/*
 			 * idmap_pg_dir is 2 pages prior to 4.1,
 			 * and 3 pages thereafter.  Only 4K and 64K 
@@ -214,19 +206,12 @@ arm64_init(int when)
 
 		arm64_calc_VA_BITS();
 		ms = machdep->machspec;
-		if (ms->VA_BITS_ACTUAL) {
-			ms->page_offset = ARM64_PAGE_OFFSET_ACTUAL;
-			machdep->identity_map_base = ARM64_PAGE_OFFSET_ACTUAL;
-			machdep->kvbase = ARM64_PAGE_OFFSET_ACTUAL;
-			ms->userspace_top = ARM64_USERSPACE_TOP_ACTUAL;
-		} else {
-			ms->page_offset = ARM64_PAGE_OFFSET;
-			machdep->identity_map_base = ARM64_PAGE_OFFSET;
-			machdep->kvbase = ARM64_VA_START;
-			ms->userspace_top = ARM64_USERSPACE_TOP;
-		}
+		ms->page_offset = ARM64_PAGE_OFFSET;
+		machdep->identity_map_base = ARM64_PAGE_OFFSET;
+		machdep->kvbase = ARM64_VA_START;
 		machdep->is_kvaddr = generic_is_kvaddr;
 		machdep->kvtop = arm64_kvtop;
+		ms->userspace_top = ARM64_USERSPACE_TOP;
 		if (machdep->flags & NEW_VMEMMAP) {
 			struct syment *sp;
 
@@ -235,15 +220,11 @@ arm64_init(int when)
 			sp = kernel_symbol_search("_end");
 			ms->kimage_end = (sp ? sp->value : 0);
 
-			if (ms->VA_BITS_ACTUAL) {
-				ms->modules_vaddr = (st->_stext_vmlinux & TEXT_OFFSET_MASK) - ARM64_MODULES_VSIZE;
-				ms->modules_end = ms->modules_vaddr + ARM64_MODULES_VSIZE -1;
-			} else {
-				ms->modules_vaddr = ARM64_VA_START;
-				if (kernel_symbol_exists("kasan_init"))
-					ms->modules_vaddr += ARM64_KASAN_SHADOW_SIZE;
-				ms->modules_end = ms->modules_vaddr + ARM64_MODULES_VSIZE -1;
-			}
+			ms->modules_vaddr = ARM64_VA_START;
+			if (kernel_symbol_exists("kasan_init"))
+				ms->modules_vaddr += ARM64_KASAN_SHADOW_SIZE;
+			ms->modules_end = ms->modules_vaddr
+						+ ARM64_MODULES_VSIZE -1;
 
 			ms->vmalloc_start_addr = ms->modules_end + 1;
 
@@ -285,7 +266,7 @@ arm64_init(int when)
 		case 65536:
 			if (kernel_symbol_exists("idmap_ptrs_per_pgd") &&
 			    readmem(symbol_value("idmap_ptrs_per_pgd"), KVADDR,
-			    &value, sizeof(ulong), "idmap_ptrs_per_pgd", QUIET|RETURN_ON_ERROR))
+			    &value, sizeof(ulong), "idmap_ptrs_per_pgd", RETURN_ON_ERROR))
 				machdep->ptrs_per_pgd = value;
 		
 			if (machdep->machspec->VA_BITS > PGDIR_SHIFT_L3_64K) {
@@ -335,6 +316,10 @@ arm64_init(int when)
 
 		machdep->uvtop = arm64_uvtop;
 		machdep->is_uvaddr = arm64_is_uvaddr;
+		if (kernel_symbol_exists("vabits_user") && 
+		    readmem(symbol_value("vabits_user"), KVADDR,
+		    &value, sizeof(ulong), "vabits_user", RETURN_ON_ERROR))
+			machdep->machspec->vabits_user = value;
 		machdep->eframe_search = arm64_eframe_search;
 		machdep->back_trace = arm64_back_trace_cmd;
 		machdep->in_alternate_stack = arm64_in_alternate_stack;
@@ -375,8 +360,7 @@ arm64_init(int when)
 
 	case POST_GDB:
 		arm64_calc_virtual_memory_ranges();
-		arm64_get_section_size_bits();
-
+		machdep->section_size_bits = _SECTION_SIZE_BITS;
 		if (!machdep->max_physmem_bits) {
 			if ((string = pc->read_vmcoreinfo("NUMBER(MAX_PHYSMEM_BITS)"))) {
 				machdep->max_physmem_bits = atol(string);
@@ -388,24 +372,8 @@ arm64_init(int when)
 			else
 				machdep->max_physmem_bits = _MAX_PHYSMEM_BITS;
 		}
-
 		ms = machdep->machspec;
 
-		if (CRASHDEBUG(1)) {
-			if (ms->VA_BITS_ACTUAL) {
-				fprintf(fp, "CONFIG_ARM64_VA_BITS: %ld\n", ms->CONFIG_ARM64_VA_BITS);
-				fprintf(fp, "      VA_BITS_ACTUAL: %ld\n", ms->VA_BITS_ACTUAL);
-				fprintf(fp, "(calculated) VA_BITS: %ld\n", ms->VA_BITS);
-				fprintf(fp, " PAGE_OFFSET: %lx\n", ARM64_PAGE_OFFSET_ACTUAL);
-				fprintf(fp, "    VA_START: %lx\n", ms->VA_START);
-				fprintf(fp, "     modules: %lx - %lx\n", ms->modules_vaddr, ms->modules_end);
-				fprintf(fp, "     vmalloc: %lx - %lx\n", ms->vmalloc_start_addr, ms->vmalloc_end);
-				fprintf(fp, "kernel image: %lx - %lx\n", ms->kimage_text, ms->kimage_end);
-				fprintf(fp, "     vmemmap: %lx - %lx\n\n", ms->vmemmap_vaddr, ms->vmemmap_end);
-			}
-		}
-
-
 		if (THIS_KERNEL_VERSION >= LINUX(4,0,0)) {
 			ms->__SWP_TYPE_BITS = 6;
 			ms->__SWP_TYPE_SHIFT = 2;
@@ -465,8 +433,11 @@ arm64_init(int when)
 		 * of the crash. We need this information to extract correct
 		 * backtraces from the panic task.
 		 */
-		if (!LIVE()) 
-			arm64_get_crash_notes();
+		if (!LIVE() && !arm64_get_crash_notes())
+			error(WARNING, 
+			    "cannot retrieve registers for active task%s\n\n",
+				kt->cpus > 1 ? "s" : "");
+
 		break;
 
 	case LOG_ONLY:
@@ -648,15 +619,9 @@ arm64_dump_machdep_table(ulong arg)
 
 	fprintf(fp, "            machspec: %lx\n", (ulong)ms);
 	fprintf(fp, "               VA_BITS: %ld\n", ms->VA_BITS);
-	fprintf(fp, "  CONFIG_ARM64_VA_BITS: %ld\n", ms->CONFIG_ARM64_VA_BITS);
-	fprintf(fp, "              VA_START: ");
-	if (ms->VA_START)
-		fprintf(fp, "%lx\n", ms->VA_START);
-	else
-		fprintf(fp, "(unused)\n");
-	fprintf(fp, "        VA_BITS_ACTUAL: ");
-	if (ms->VA_BITS_ACTUAL)
-		fprintf(fp, "%ld\n", ms->VA_BITS_ACTUAL);
+	fprintf(fp, "           vabits_user: ");
+	if (ms->vabits_user)
+		fprintf(fp, "%ld\n", ms->vabits_user);
 	else
 		fprintf(fp, "(unused)\n");
 	fprintf(fp, "         userspace_top: %016lx\n", ms->userspace_top);
@@ -745,12 +710,12 @@ arm64_parse_machdep_arg_l(char *argstring, char *param, ulong *value)
 		int flags = RETURN_ON_ERROR | QUIET;
 		int err = 0;
 
-		if (STRNEQ(argstring, "max_physmem_bits")) {
-			*value = dtol(p, flags, &err);
-		} else if (megabytes) {
+		if (megabytes) {
 			*value = dtol(p, flags, &err);
 			if (!err)
 				*value = MEGABYTES(*value);
+		} else if (STRNEQ(argstring, "max_physmem_bits")) {
+			*value = dtol(p, flags, &err);
 		} else {
 			*value = htol(p, flags, &err);
 		}
@@ -824,60 +789,11 @@ arm64_parse_cmdline_args(void)
 	}
 }
 
-#define	MIN_KIMG_ALIGN	(0x00200000)	/* kimage load address must be aligned 2M */
-/*
- * Traverse the entire dumpfile to find/verify kimage_voffset.
- */
-static int
-arm64_search_for_kimage_voffset(ulong phys_base)
-{
-	ulong kimage_load_addr;
-	ulong phys_end;
-	struct machine_specific *ms = machdep->machspec;
-
-	if (!arm_kdump_phys_end(&phys_end))
-		return FALSE;
-
-	for (kimage_load_addr = phys_base;
-	    kimage_load_addr <= phys_end; kimage_load_addr += MIN_KIMG_ALIGN) {
-		ms->kimage_voffset = ms->vmalloc_start_addr - kimage_load_addr;
-
-		if ((kt->flags2 & KASLR) && (kt->flags & RELOC_SET))
-			ms->kimage_voffset += (kt->relocate * - 1);
-
-		if (verify_kimage_voffset()) {
-			if (CRASHDEBUG(1))
-				error(INFO, 
-				    "dumpfile searched for kimage_voffset: %lx\n\n", 
-					ms->kimage_voffset);
-			break;
-		}
-	}
-
-	if (kimage_load_addr > phys_end)
-		return FALSE;
-
-	return TRUE;
-}
-
-static int
-verify_kimage_voffset(void)
-{
-	ulong kimage_voffset;
-
-	if (!readmem(symbol_value("kimage_voffset"), KVADDR, &kimage_voffset,
-	    sizeof(kimage_voffset), "verify kimage_voffset", QUIET|RETURN_ON_ERROR))
-		return FALSE;
-
-	return (machdep->machspec->kimage_voffset == kimage_voffset);
-}
-
 static void
 arm64_calc_kimage_voffset(void)
 {
 	struct machine_specific *ms = machdep->machspec;
-	ulong phys_addr = 0;
-	int errflag;
+	ulong phys_addr;
 
 	if (ms->kimage_voffset) /* vmcoreinfo, ioctl, or --machdep override */
 		return;
@@ -885,6 +801,7 @@ arm64_calc_kimage_voffset(void)
 	if (ACTIVE()) {
 		char buf[BUFSIZE];
 		char *p1;
+		int errflag;
 		FILE *iomem;
 		ulong kimage_voffset, vaddr;
 
@@ -925,24 +842,9 @@ arm64_calc_kimage_voffset(void)
 		if (errflag)
 			return;
 
-	} else if (KDUMP_DUMPFILE()) {
-		errflag = 1;
-		if (arm_kdump_phys_base(&phys_addr)) {  /* Get start address of first memory block */
-			ms->kimage_voffset = ms->vmalloc_start_addr - phys_addr;
-			if ((kt->flags2 & KASLR) && (kt->flags & RELOC_SET))
-				ms->kimage_voffset += (kt->relocate * -1);
-	    		if (verify_kimage_voffset() || arm64_search_for_kimage_voffset(phys_addr))
-				errflag = 0;
-		}
-
-		if (errflag) {
-			error(WARNING,
-				"kimage_voffset cannot be determined from the dumpfile.\n");
-			error(CONT,
-				"Try using the command line option: --machdep kimage_voffset=<addr>\n");
-		}
-		return;
-	} else {
+	} else if (KDUMP_DUMPFILE())
+		arm_kdump_phys_base(&phys_addr);  /* Get start address of first memory block */
+	else {
 		error(WARNING,
 			"kimage_voffset cannot be determined from the dumpfile.\n");
 		error(CONT,
@@ -981,16 +883,10 @@ arm64_calc_phys_offset(void)
 		physaddr_t paddr;
 		ulong vaddr;
 		struct syment *sp;
-		char *string;
 
 		if ((machdep->flags & NEW_VMEMMAP) &&
 		    ms->kimage_voffset && (sp = kernel_symbol_search("memstart_addr"))) {
 			if (pc->flags & PROC_KCORE) {
-				if ((string = pc->read_vmcoreinfo("NUMBER(PHYS_OFFSET)"))) {
-					ms->phys_offset = htol(string, QUIET, NULL);
-					free(string);
-					return;
-				}
 				vaddr = symbol_value_from_proc_kallsyms("memstart_addr");
 				if (vaddr == BADVAL)
 					vaddr = sp->value;
@@ -1053,31 +949,6 @@ arm64_calc_phys_offset(void)
 		fprintf(fp, "using %lx as phys_offset\n", ms->phys_offset);
 }
 
-/*
- *  Determine SECTION_SIZE_BITS either by reading VMCOREINFO or the kernel
- *  config, otherwise use the 64-bit ARM default definiton.
- */
-static void
-arm64_get_section_size_bits(void)
-{
-	int ret;
-	char *string;
-
-	machdep->section_size_bits = _SECTION_SIZE_BITS;
-
-	if ((string = pc->read_vmcoreinfo("NUMBER(SECTION_SIZE_BITS)"))) {
-		machdep->section_size_bits = atol(string);
-		free(string);
-	} else if (kt->ikconfig_flags & IKCONFIG_AVAIL) {
-		if ((ret = get_kernel_config("CONFIG_MEMORY_HOTPLUG", NULL)) == IKCONFIG_Y) {
-			if ((ret = get_kernel_config("CONFIG_HOTPLUG_SIZE_BITS", &string)) == IKCONFIG_STR)
-				machdep->section_size_bits = atol(string);
-		} 
-	}
-
-	if (CRASHDEBUG(1))
-		fprintf(fp, "SECTION_SIZE_BITS: %ld\n", machdep->section_size_bits);
-}
 
 /*
  *  Determine PHYS_OFFSET either by reading VMCOREINFO or the kernel
@@ -1133,12 +1004,6 @@ ulong
 arm64_VTOP(ulong addr)
 {
 	if (machdep->flags & NEW_VMEMMAP) {
-		if (machdep->machspec->VA_START &&
-		    (addr >= machdep->machspec->kimage_text) &&
-		    (addr <= machdep->machspec->kimage_end)) {
-			return addr - machdep->machspec->kimage_voffset;
-		}
-
 		if (addr >= machdep->machspec->page_offset)
 			return machdep->machspec->phys_offset
 				+ (addr - machdep->machspec->page_offset);
@@ -1215,11 +1080,6 @@ arm64_uvtop(struct task_context *tc, ulong uvaddr, physaddr_t *paddr, int verbos
 	}
 }
 
-#define PTE_ADDR_LOW   ((((1UL) << (48 - machdep->pageshift)) - 1) << machdep->pageshift)
-#define PTE_ADDR_HIGH  ((0xfUL) << 12)
-#define PTE_TO_PHYS(pteval)  (machdep->max_physmem_bits == 52 ? \
-	(((pteval & PTE_ADDR_LOW) | ((pteval & PTE_ADDR_HIGH) << 36))) : (pteval & PTE_ADDR_LOW))
-
 #define PMD_TYPE_MASK   3
 #define PMD_TYPE_SECT   1
 #define PMD_TYPE_TABLE  2
@@ -1312,7 +1172,7 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
 	 * #define __PAGETABLE_PUD_FOLDED
 	 */
 
-	pmd_base = (ulong *)PTOV(PTE_TO_PHYS(pgd_val));
+	pmd_base = (ulong *)PTOV(pgd_val & PHYS_MASK & (s32)machdep->pagemask);
 	FILL_PMD(pmd_base, KVADDR, PTRS_PER_PMD_L3_64K * sizeof(ulong));
 	pmd_ptr = pmd_base + (((vaddr) >> PMD_SHIFT_L3_64K) & (PTRS_PER_PMD_L3_64K - 1));
         pmd_val = ULONG(machdep->pmd + PAGEOFFSET(pmd_ptr));
@@ -1322,7 +1182,7 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
 		goto no_page;
 
 	if ((pmd_val & PMD_TYPE_MASK) == PMD_TYPE_SECT) {
-		ulong sectionbase = PTE_TO_PHYS(pmd_val) & SECTION_PAGE_MASK_512MB;
+		ulong sectionbase = (pmd_val & SECTION_PAGE_MASK_512MB) & PHYS_MASK;
 		if (verbose) {
 			fprintf(fp, "  PAGE: %lx  (512MB)\n\n", sectionbase);
 			arm64_translate_pte(pmd_val, 0, 0);
@@ -1331,7 +1191,7 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
 		return TRUE;
 	}
 
-	pte_base = (ulong *)PTOV(PTE_TO_PHYS(pmd_val));
+	pte_base = (ulong *)PTOV(pmd_val & PHYS_MASK & (s32)machdep->pagemask);
 	FILL_PTBL(pte_base, KVADDR, PTRS_PER_PTE_L3_64K * sizeof(ulong));
 	pte_ptr = pte_base + (((vaddr) >> machdep->pageshift) & (PTRS_PER_PTE_L3_64K - 1));
         pte_val = ULONG(machdep->ptbl + PAGEOFFSET(pte_ptr));
@@ -1341,7 +1201,7 @@ arm64_vtop_3level_64k(ulong pgd, ulong vaddr, physaddr_t *paddr, int verbose)
 		goto no_page;
 
 	if (pte_val & PTE_VALID) {
-		*paddr = PTE_TO_PHYS(pte_val) + PAGEOFFSET(vaddr);
+		*paddr = (PAGEBASE(pte_val) & PHYS_MASK) + PAGEOFFSET(vaddr);
 		if (verbose) {
 			fprintf(fp, "  PAGE: %lx\n\n", PAGEBASE(*paddr));
 			arm64_translate_pte(pte_val, 0, 0);
@@ -1644,11 +1504,10 @@ arm64_stackframe_init(void)
 		machdep->machspec->kern_eframe_offset = SIZE(pt_regs);
 	}
 
-	if ((sp1 = kernel_symbol_search("__exception_text_start")) &&
-	    (sp2 = kernel_symbol_search("__exception_text_end"))) {
-		machdep->machspec->__exception_text_start = sp1->value;
-		machdep->machspec->__exception_text_end = sp2->value;
-	}
+	machdep->machspec->__exception_text_start = 
+		symbol_value("__exception_text_start");
+	machdep->machspec->__exception_text_end = 
+		symbol_value("__exception_text_end");
 	if ((sp1 = kernel_symbol_search("__irqentry_text_start")) &&
 	    (sp2 = kernel_symbol_search("__irqentry_text_end"))) {
 		machdep->machspec->__irqentry_text_start = sp1->value; 
@@ -1857,38 +1716,20 @@ arm64_eframe_search(struct bt_info *bt)
 	return count;
 }
 
-static char *arm64_exception_functions[] = {
-        "do_undefinstr",
-        "do_sysinstr",
-        "do_debug_exception",
-        "do_mem_abort",
-        "do_el0_irq_bp_hardening",
-        "do_sp_pc_abort",
-        NULL
-};
-
 static int
 arm64_in_exception_text(ulong ptr)
 {
 	struct machine_specific *ms = machdep->machspec;
-	char *name, **func;
+
+	if ((ptr >= ms->__exception_text_start) &&
+	    (ptr < ms->__exception_text_end))
+		return TRUE;
 
 	if (ms->__irqentry_text_start && ms->__irqentry_text_end &&
 	    ((ptr >= ms->__irqentry_text_start) && 
 	    (ptr < ms->__irqentry_text_end)))
 		return TRUE;
 
-	if (ms->__exception_text_start && ms->__exception_text_end) {
-		if ((ptr >= ms->__exception_text_start) &&
-		    (ptr < ms->__exception_text_end))
-			return TRUE;
-	} else if ((name = closest_symbol(ptr))) {  /* Linux 5.5 and later */
-		for (func = &arm64_exception_functions[0]; *func; func++) {
-			if (STREQ(name, *func))
-				return TRUE;
-		}
-	}
-
 	return FALSE;
 }
 
@@ -3297,7 +3138,7 @@ arm64_translate_pte(ulong pte, void *physaddr, ulonglong unused)
         char *arglist[MAXARGS];
 	int page_present;
 
-	paddr = PTE_TO_PHYS(pte);
+	paddr = pte & PHYS_MASK & (s32)machdep->pagemask;
        	page_present = pte & (PTE_VALID | machdep->machspec->PTE_PROT_NONE);
 
         if (physaddr) {
@@ -3563,8 +3404,8 @@ arm64_display_machine_stats(void)
 	fprintf(fp, "                 HZ: %d\n", machdep->hz);
 	fprintf(fp, "          PAGE SIZE: %d\n", PAGESIZE());
 	fprintf(fp, "KERNEL VIRTUAL BASE: %lx\n", machdep->machspec->page_offset);
-	fprintf(fp, "KERNEL MODULES BASE: %lx\n", machdep->machspec->modules_vaddr);
 	fprintf(fp, "KERNEL VMALLOC BASE: %lx\n", machdep->machspec->vmalloc_start_addr);
+	fprintf(fp, "KERNEL MODULES BASE: %lx\n", machdep->machspec->modules_vaddr);
         fprintf(fp, "KERNEL VMEMMAP BASE: %lx\n", machdep->machspec->vmemmap_vaddr);
 	fprintf(fp, "  KERNEL STACK SIZE: %ld\n", STACKSIZE());
 	if (machdep->machspec->irq_stack_size) {
@@ -3594,7 +3435,7 @@ arm64_get_smp_cpus(void)
 /*
  * Retrieve task registers for the time of the crash.
  */
-static void
+static int
 arm64_get_crash_notes(void)
 {
 	struct machine_specific *ms = machdep->machspec;
@@ -3603,10 +3444,10 @@ arm64_get_crash_notes(void)
 	ulong offset;
 	char *buf, *p;
 	ulong *notes_ptrs;
-	ulong i, found;
+	ulong i;
 
 	if (!symbol_exists("crash_notes"))
-		return;
+		return FALSE;
 
 	crash_notes = symbol_value("crash_notes");
 
@@ -3618,9 +3459,9 @@ arm64_get_crash_notes(void)
 	 */
 	if (!readmem(crash_notes, KVADDR, &notes_ptrs[kt->cpus-1], 
 	    sizeof(notes_ptrs[kt->cpus-1]), "crash_notes", RETURN_ON_ERROR)) {
-		error(WARNING, "cannot read \"crash_notes\"\n");
+		error(WARNING, "cannot read crash_notes\n");
 		FREEBUF(notes_ptrs);
-		return;
+		return FALSE;
 	}
 
 	if (symbol_exists("__per_cpu_offset")) {
@@ -3636,11 +3477,12 @@ arm64_get_crash_notes(void)
 	if (!(ms->panic_task_regs = calloc((size_t)kt->cpus, sizeof(struct arm64_pt_regs))))
 		error(FATAL, "cannot calloc panic_task_regs space\n");
 	
-	for  (i = found = 0; i < kt->cpus; i++) {
+	for  (i = 0; i < kt->cpus; i++) {
+
 		if (!readmem(notes_ptrs[i], KVADDR, buf, SIZE(note_buf), 
 		    "note_buf_t", RETURN_ON_ERROR)) {
-			error(WARNING, "cpu %d: cannot read NT_PRSTATUS note\n", i);
-			continue;
+			error(WARNING, "failed to read note_buf_t\n");
+			goto fail;
 		}
 
 		/*
@@ -3670,24 +3512,19 @@ arm64_get_crash_notes(void)
 				    note->n_descsz == notesz)
 					BCOPY((char *)note, buf, notesz);
 			} else {
-				error(WARNING, "cpu %d: cannot find NT_PRSTATUS note\n", i);
+				error(WARNING,
+					"cannot find NT_PRSTATUS note for cpu: %d\n", i);
 				continue;
 			}
 		}
 
-		/*
-		 * Check the sanity of NT_PRSTATUS note only for each online cpu.
-		 * If this cpu has invalid note, continue to find the crash notes
-		 * for other online cpus.
-		 */
 		if (note->n_type != NT_PRSTATUS) {
-			error(WARNING, "cpu %d: invalid NT_PRSTATUS note (n_type != NT_PRSTATUS)\n", i);
-			continue;
+			error(WARNING, "invalid note (n_type != NT_PRSTATUS)\n");
+			goto fail;
 		}
-
-		if (!STRNEQ(p, "CORE")) {
-			error(WARNING, "cpu %d: invalid NT_PRSTATUS note (name != \"CORE\")\n", i);
-			continue;
+		if (p[0] != 'C' || p[1] != 'O' || p[2] != 'R' || p[3] != 'E') {
+			error(WARNING, "invalid note (name != \"CORE\"\n");
+			goto fail;
 		}
 
 		/*
@@ -3700,17 +3537,18 @@ arm64_get_crash_notes(void)
 
 		BCOPY(p + OFFSET(elf_prstatus_pr_reg), &ms->panic_task_regs[i],
 		      sizeof(struct arm64_pt_regs));
-
-		found++;
 	}
 
 	FREEBUF(buf);
 	FREEBUF(notes_ptrs);
+	return TRUE;
 
-	if (!found) {
-		free(ms->panic_task_regs);
-		ms->panic_task_regs = NULL;
-	}
+fail:
+	FREEBUF(buf);
+	FREEBUF(notes_ptrs);
+	free(ms->panic_task_regs);
+	ms->panic_task_regs = NULL;
+	return FALSE;
 }
 
 static void
@@ -3834,9 +3672,6 @@ arm64_IS_VMALLOC_ADDR(ulong vaddr)
 	    (vaddr <= machdep->machspec->kimage_end))
 		return FALSE;
 
-	if (ms->VA_START && (vaddr >= ms->VA_START))
-		return TRUE;
-
         return ((vaddr >= ms->vmalloc_start_addr && vaddr <= ms->vmalloc_end) ||
                 ((machdep->flags & VMEMMAP) &&
                  (vaddr >= ms->vmemmap_vaddr && vaddr <= ms->vmemmap_end)) ||
@@ -3848,54 +3683,9 @@ arm64_calc_VA_BITS(void)
 {
 	int bitval;
 	struct syment *sp;
-	ulong vabits_actual, value;
+	ulong value;
 	char *string;
 
-	if ((string = pc->read_vmcoreinfo("NUMBER(VA_BITS)"))) {
-		value = atol(string);
-		free(string);
-		machdep->machspec->CONFIG_ARM64_VA_BITS = value;
-	}
-
-	if (kernel_symbol_exists("vabits_actual")) {
-		if (pc->flags & PROC_KCORE) {
-			vabits_actual = symbol_value_from_proc_kallsyms("vabits_actual");
-			if ((vabits_actual != BADVAL) && (READMEM(pc->mfd, &value, sizeof(ulong),
-		    	    vabits_actual, KCORE_USE_VADDR) > 0)) {
-				if (CRASHDEBUG(1))
-					fprintf(fp, 
-					    "/proc/kcore: vabits_actual: %ld\n", value);
-				machdep->machspec->VA_BITS_ACTUAL = value;
-				machdep->machspec->VA_BITS = value;
-				machdep->machspec->VA_START = _VA_START(machdep->machspec->VA_BITS_ACTUAL);
-			} else
-				error(FATAL, "/proc/kcore: cannot read vabits_actual\n");
-		} else if (ACTIVE())
-			error(FATAL, "cannot determine VA_BITS_ACTUAL: please use /proc/kcore\n");
-		else {
-			if ((string = pc->read_vmcoreinfo("NUMBER(TCR_EL1_T1SZ)"))) {
-				/* See ARMv8 ARM for the description of
-				 * TCR_EL1.T1SZ and how it can be used
-				 * to calculate the vabits_actual
-				 * supported by underlying kernel.
-				 *
-				 * Basically:
-				 * vabits_actual = 64 - T1SZ;
-				 */
-				value = 64 - strtoll(string, NULL, 0);
-				if (CRASHDEBUG(1))
-					fprintf(fp,  "vmcoreinfo : vabits_actual: %ld\n", value);
-				free(string);
-				machdep->machspec->VA_BITS_ACTUAL = value;
-				machdep->machspec->VA_BITS = value;
-				machdep->machspec->VA_START = _VA_START(machdep->machspec->VA_BITS_ACTUAL);
-			} else
-				error(FATAL, "cannot determine VA_BITS_ACTUAL\n");
-		}
-
-		return;
-	}
-
 	if (!(sp = symbol_search("swapper_pg_dir")) &&
 	    !(sp = symbol_search("idmap_pg_dir")) &&
 	    !(sp = symbol_search("_text")) &&
@@ -3924,12 +3714,14 @@ arm64_calc_VA_BITS(void)
 	/*
 	 *  Verify against dumpfiles that export VA_BITS in vmcoreinfo
 	 */
-        if (machdep->machspec->CONFIG_ARM64_VA_BITS &&
-	    (machdep->machspec->VA_BITS != machdep->machspec->CONFIG_ARM64_VA_BITS)) {
-		error(WARNING, "VA_BITS: calculated: %ld  vmcoreinfo: %ld\n",
-			machdep->machspec->VA_BITS, machdep->machspec->CONFIG_ARM64_VA_BITS);
-		machdep->machspec->VA_BITS = machdep->machspec->CONFIG_ARM64_VA_BITS;
-	}
+        if ((string = pc->read_vmcoreinfo("NUMBER(VA_BITS)"))) {
+                value = atol(string);
+                free(string);
+		if (machdep->machspec->VA_BITS != value)
+			error(WARNING, "VA_BITS: calculated: %ld  vmcoreinfo: %ld\n",
+				machdep->machspec->VA_BITS, value);
+        }
+
 
 	if (CRASHDEBUG(1))
 		fprintf(fp, "VA_BITS: %ld\n", machdep->machspec->VA_BITS);
@@ -3947,15 +3739,6 @@ arm64_calc_VA_BITS(void)
  *
  *  Since VMEMMAP_SIZE is dependent upon the size of a struct page,
  *  the two ranges cannot be determined until POST_GDB.
- *
- *  Since 52-bit VA was introduced:
- *
- *  #define STRUCT_PAGE_MAX_SHIFT   6
- *  #define VMEMMAP_SIZE (UL(1) << (VA_BITS - PAGE_SHIFT - 1 + STRUCT_PAGE_MAX_SHIFT))
- *  #define VMEMMAP_START           (-VMEMMAP_SIZE)
- *  #define VMALLOC_START           (MODULES_END)
- *  #define VMALLOC_END             (- PUD_SIZE - VMEMMAP_SIZE - SZ_64K)
- *  #define vmemmap                 ((struct page *)VMEMMAP_START - (memstart_addr >> PAGE_SHIFT))
  */
 
 #define ALIGN(x, a) __ALIGN_KERNEL((x), (a))
@@ -3967,18 +3750,10 @@ static void
 arm64_calc_virtual_memory_ranges(void)
 {
 	struct machine_specific *ms = machdep->machspec;
-	ulong value, vmemmap_start, vmemmap_end, vmemmap_size, vmalloc_end;
-	char *string;
+	ulong vmemmap_start, vmemmap_end, vmemmap_size;
+	ulong vmalloc_end;
 	ulong PUD_SIZE = UNINITIALIZED;
 
-	if (!machdep->machspec->CONFIG_ARM64_VA_BITS) {
-		if ((string = pc->read_vmcoreinfo("NUMBER(VA_BITS)"))) {
-			value = atol(string);
-			free(string);
-			machdep->machspec->CONFIG_ARM64_VA_BITS = value;
-		}
-	}
-
 	if (THIS_KERNEL_VERSION < LINUX(3,17,0))  /* use original hardwired values */
 		return;
 
@@ -3997,19 +3772,8 @@ arm64_calc_virtual_memory_ranges(void)
 		break;
         }
 
-#define STRUCT_PAGE_MAX_SHIFT   6
-
-	if (ms->VA_BITS_ACTUAL) {
-		vmemmap_size = (1UL) << (ms->CONFIG_ARM64_VA_BITS - machdep->pageshift - 1 + STRUCT_PAGE_MAX_SHIFT);
-		vmalloc_end = (- PUD_SIZE - vmemmap_size - KILOBYTES(64));
-		vmemmap_start = (-vmemmap_size);
-		ms->vmalloc_end = vmalloc_end - 1;
-		ms->vmemmap_vaddr = vmemmap_start;
-		ms->vmemmap_end = -1;
-		return;
-	}
-
 	if (machdep->flags & NEW_VMEMMAP)
+#define STRUCT_PAGE_MAX_SHIFT   6
 		vmemmap_size = 1UL << (ms->VA_BITS - machdep->pageshift - 1
 						+ STRUCT_PAGE_MAX_SHIFT);
 	else
@@ -4033,7 +3797,7 @@ arm64_calc_virtual_memory_ranges(void)
 static int
 arm64_is_uvaddr(ulong addr, struct task_context *tc)
 {
-        return (addr < machdep->machspec->userspace_top);
+        return (addr < ARM64_USERSPACE_TOP);
 }
 
 
diff --git a/defs.h b/defs.h
index ac24a5d730d5..d0b021f61c67 100644
--- a/defs.h
+++ b/defs.h
@@ -3148,17 +3148,9 @@ typedef signed int s32;
  */
 #define ARM64_VA_START       ((0xffffffffffffffffUL) \
 					<< machdep->machspec->VA_BITS)
-#define _VA_START(va)        ((0xffffffffffffffffUL) - \
-                             ((1UL) << ((va) - 1)) + 1)
-#define TEXT_OFFSET_MASK     (~((MEGABYTES(2UL))-1))
-
 #define ARM64_PAGE_OFFSET    ((0xffffffffffffffffUL) \
 					<< (machdep->machspec->VA_BITS - 1))
-#define ARM64_PAGE_OFFSET_ACTUAL ((0xffffffffffffffffUL) \
-					- ((1UL) << machdep->machspec->VA_BITS_ACTUAL) + 1)
-
 #define ARM64_USERSPACE_TOP  ((1UL) << machdep->machspec->VA_BITS)
-#define ARM64_USERSPACE_TOP_ACTUAL  ((1UL) << machdep->machspec->VA_BITS_ACTUAL)
 
 /* only used for v4.6 or later */
 #define ARM64_MODULES_VSIZE     MEGABYTES(128)
@@ -3261,9 +3253,7 @@ struct machine_specific {
 	ulong kern_eframe_offset;
 	ulong machine_kexec_start;
 	ulong machine_kexec_end;
-	ulong VA_BITS_ACTUAL;
-	ulong CONFIG_ARM64_VA_BITS;
-	ulong VA_START;
+	ulong vabits_user;
 };
 
 struct arm64_stackframe {
diff --git a/netdump.c b/netdump.c
index 0054d6ab35b4..31ab6fae5ccd 100644
--- a/netdump.c
+++ b/netdump.c
@@ -1228,19 +1228,7 @@ netdump_memory_dump(FILE *fp)
 		if (machine_type("X86_64"))
 			netdump_print("%lx (relocate)\n", nd->arch_data1);
 		else if (machine_type("ARM64"))
-			netdump_print("%lx (kimage_voffset)\n", nd->arch_data1);
-	} else
-		netdump_print("(unused)\n");
-	netdump_print("             arch_data2: ");
-	if (nd->arch_data2) {
-		if (machine_type("ARM64"))
-			netdump_print("%016lx\n"
-			    "                         CONFIG_ARM64_VA_BITS: %ld\n"
-			    "                         VA_BITS_ACTUAL: %lld\n", 
-				nd->arch_data2, nd->arch_data2 & 0xffffffff,
-				((ulonglong)nd->arch_data2 >> 32));
-		else
-			netdump_print("%016lx (?)\n", nd->arch_data2);
+			netdump_print("%lx (kimage_voffset)\n", nd->arch_data);
 	} else
 		netdump_print("(unused)\n");
 	netdump_print("           switch_stack: %lx\n", nd->switch_stack);
@@ -1865,8 +1853,7 @@ vmcoreinfo_read_string(const char *key)
 	int i, j, end;
 	size_t value_length;
 	size_t key_length = strlen(key);
-	char *vmcoreinfo;
-	uint size_vmcoreinfo;
+	char *vmcoreinfo = (char *)nd->vmcoreinfo;
 	char *value = NULL;
 
 	/*
@@ -1875,49 +1862,25 @@ vmcoreinfo_read_string(const char *key)
 	 *  the NT_TASKSTRUCT note.
 	 */
 	if ((pc->flags2 & SNAP)) {
-		if (STREQ(key, "NUMBER(kimage_voffset)") && nd->arch_data1) {
+		if (STREQ(key, "NUMBER(kimage_voffset)") && nd->arch_data) {
 			value = calloc(VADDR_PRLEN+1, sizeof(char));
-			sprintf(value, "%lx", nd->arch_data1);
-			if (nd->arch_data2 == 0)
-				pc->read_vmcoreinfo = no_vmcoreinfo;
-			return value;
-		}
-		if (STREQ(key, "NUMBER(VA_BITS)") && nd->arch_data2) {
-			value = calloc(VADDR_PRLEN+1, sizeof(char));
-			sprintf(value, "%ld", nd->arch_data2 & 0xffffffff);
-			return value;
-		}
-		if (STREQ(key, "NUMBER(TCR_EL1_T1SZ)") && nd->arch_data2) {
-			value = calloc(VADDR_PRLEN+1, sizeof(char));
-			sprintf(value, "%lld", ((ulonglong)nd->arch_data2 >> 32) & 0xffffffff);
+			sprintf(value, "%lx", nd->arch_data);
 			pc->read_vmcoreinfo = no_vmcoreinfo;
 			return value;
 		}
-		if (STREQ(key, "relocate") && nd->arch_data1) {
+		if (STREQ(key, "relocate") && nd->arch_data) {
 			value = calloc(VADDR_PRLEN+1, sizeof(char));
-			sprintf(value, "%lx", nd->arch_data1);
+			sprintf(value, "%lx", nd->arch_data);
 			pc->read_vmcoreinfo = no_vmcoreinfo;
 			return value;
 		}
-		return NULL;
-	}
-
-	if (nd->vmcoreinfo) {
-		vmcoreinfo = (char *)nd->vmcoreinfo;
-		size_vmcoreinfo = nd->size_vmcoreinfo;
-	} else if (ACTIVE() && pkd->vmcoreinfo) {
-		vmcoreinfo = (char *)pkd->vmcoreinfo;
-		size_vmcoreinfo = pkd->size_vmcoreinfo;
-	} else {
-		vmcoreinfo = NULL;
-		size_vmcoreinfo = 0;
 	}
 
-	if (!vmcoreinfo)
+	if (!nd->vmcoreinfo)
 		return NULL;
 
 	/* the '+ 1' is the equal sign */
-	for (i = 0; i < (int)(size_vmcoreinfo - key_length + 1); i++) {
+	for (i = 0; i < (nd->size_vmcoreinfo - key_length + 1); i++) {
 		/*
 		 * We must also check if we're at the beginning of VMCOREINFO
 		 * or the separating newline is there, and of course if we 
@@ -1931,7 +1894,7 @@ vmcoreinfo_read_string(const char *key)
 
 			/* Found -- search for the next newline. */
 			for (j = i + key_length + 1; 
-			     j < size_vmcoreinfo; j++) {
+			     j < nd->size_vmcoreinfo; j++) {
 				if (vmcoreinfo[j] == '\n') {
 					end = j;
 					break;
@@ -1944,7 +1907,7 @@ vmcoreinfo_read_string(const char *key)
 			 */
 			if (end == -1) {
 				/* Point after the end. */
-				end = size_vmcoreinfo + 1;
+				end = nd->size_vmcoreinfo + 1;
 			}
 
 			value_length = end - (1+ i + key_length);