commit 8e7b1dc344e7abbbb07283008fcb8a83576bb3bd Author: CentOS Sources Date: Fri Aug 7 18:28:29 2020 +0000 import crash-7.2.8-6.el8 # Conflicts: # SPECS/crash.spec diff --git a/SOURCES/github_9596b4388ea5.patch b/SOURCES/github_9596b4388ea5.patch new file mode 100644 index 0000000..9607aa2 --- /dev/null +++ b/SOURCES/github_9596b4388ea5.patch @@ -0,0 +1,909 @@ +commit 9596b4388ea5ebbf7de79f0e377a497de1616654 +Author: Bhupesh Sharma +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 + +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=\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, ¬es_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); diff --git a/SPECS/crash.spec b/SPECS/crash.spec new file mode 100644 index 0000000..d2138c1 --- /dev/null +++ b/SPECS/crash.spec @@ -0,0 +1,637 @@ +# +# crash core analysis suite +# +Summary: Kernel analysis utility for live systems, netdump, diskdump, kdump, LKCD or mcore dumpfiles +Name: crash +Version: 7.2.8 +Release: 6%{?dist} +License: GPLv3 +Group: Development/Debuggers +Source0: https://github.com/crash-utility/crash/archive/crash-%{version}.tar.gz +Source1: http://ftp.gnu.org/gnu/gdb/gdb-7.6.tar.gz +URL: https://crash-utility.github.io +ExclusiveOS: Linux +ExclusiveArch: %{ix86} ia64 x86_64 ppc ppc64 s390 s390x %{arm} aarch64 ppc64le +Buildroot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot-%(%{__id_u} -n) +BuildRequires: ncurses-devel zlib-devel lzo-devel bison snappy-devel +Requires: binutils +Provides: bundled(gdb) = 7.6 +Patch0: lzo_snappy.patch +Patch1: rhel8_build.patch +Patch2: github_b80b16549e24.patch +Patch3: github_0f29a8ac6b73.patch +Patch4: github_1c45cea02df7.patch +Patch5: github_9596b4388ea5.patch + +%description +The core analysis suite is a self-contained tool that can be used to +investigate either live systems, kernel core dumps created from the +netdump, diskdump and kdump packages from Red Hat Linux, the mcore kernel patch +offered by Mission Critical Linux, or the LKCD kernel patch. + +%package devel +Requires: %{name} = %{version}, zlib-devel lzo-devel snappy-devel +Summary: kernel crash analysis utility for live systems, netdump, diskdump, kdump, LKCD or mcore dumpfiles +Group: Development/Debuggers + +%description devel +The core analysis suite is a self-contained tool that can be used to +investigate either live systems, kernel core dumps created from the +netdump, diskdump and kdump packages from Red Hat Linux, the mcore kernel patch +offered by Mission Critical Linux, or the LKCD kernel patch. + +%prep +%setup -n %{name}-%{version} -q +%patch0 -p1 -b lzo_snappy.patch +%patch1 -p1 -b rhel8_build.patch +%patch2 -p1 -b github_b80b16549e24.patch +%patch3 -p1 -b github_0f29a8ac6b73.patch +%patch4 -p1 -b github_1c45cea02df7.patch +%patch5 -p1 -b github_9596b4388ea5.patch + +%build +cp %{SOURCE1} . +#make RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" +make RPMPKG="%{version}-%{release}" CFLAGS="%{optflags}" LDFLAGS="%{build_ldflags}" + +%install +rm -rf %{buildroot} +mkdir -p %{buildroot}%{_bindir} +make DESTDIR=%{buildroot} install +mkdir -p %{buildroot}%{_mandir}/man8 +cp -p crash.8 %{buildroot}%{_mandir}/man8/crash.8 +mkdir -p %{buildroot}%{_includedir}/crash +chmod 0644 defs.h +cp -p defs.h %{buildroot}%{_includedir}/crash + +%clean +rm -rf %{buildroot} + +%files +%defattr(-,root,root,-) +%{_bindir}/crash +%{_mandir}/man8/crash.8* +%doc README COPYING3 + +%files devel +%defattr(-,root,root,-) +%{_includedir}/* + +%changelog +* Fri Aug 7 2020 Bhupesh Sharma - 7.2.8-6 +- aarch64: Revert to reading CONFIG_ARM64_USER_VA_BITS_52 and CONFIG_ARM64_PA_BITS=52 for 52-bit VA/PA space. + Resolves: rhbz#1861086 + +* Mon Jul 27 2020 Bhupesh Sharma - 7.2.8-5 +- aarch64: Support reading extended 52-bit address space via crash-utility + Resolves: rhbz#1861086 + +* Fri Jul 10 2020 Bhupesh Sharma - 7.2.8-4 +- Replace people.redhat.com references with github equivalents. + Resolves: rhbz#1851745 + +* Mon Jun 22 2020 Bhupesh Sharma - 7.2.8-3 +- Fix for reading compressed kdump dumpfiles from systems with physical memory + Resolves: rhbz#1819606 + +* Mon Jun 8 2020 Bhupesh Sharma - 7.2.8-2 +- Remove wget from BuildRequires section + Resolves: rhbz#1838322 + +* Fri Jun 5 2020 Bhupesh Sharma - 7.2.8-1 +- Rebase to latest upstream release 7.2.8 + Resolves: rhbz#1838322 + +* Mon Feb 3 2020 Dave Anderson - 7.2.7-3 +- Rebase to github commit 6c1c8ac6 + Resolves: rhbz#1738619 +- Fix "log -a" option + Resolves: rhbz#1785537 +- Fix for ELF kdump vmcores form s390x KASLR kernels + Resolves: rhbz#1786996 + +* Mon Nov 11 2019 Dave Anderson - 7.2.7-2 +- Rebase to latest upstream sources + Resolves: rhbz#1738619 +- Support for KASLR on s390x + Resolves: rhbz# 1753172 + +* Mon Jun 10 2019 Dave Anderson - 7.2.6-2 +- Fix "p" command regression + Resolves: rhbz#1718417 +- Fix arm64 debug kernel read error message during initialization + Resolves: rhbz#1718736 + +* Mon May 6 2019 Dave Anderson - 7.2.6-1 +- Rebase to latest upstream sources + Resolves: rhbz#1686560 +- Utilize the VMCOREINFO PT_NOTE in /proc/kcore header + Resolves: rhbz#1627528 +- Support extraction of CONFIG_PROC_VMCORE_DEVICE_DUMP data from dumpfile header + Resolves: rhbz#1702535 + +* Thu Feb 14 2019 Dave Anderson - 7.2.3-18 +- Fix "files -c" and "files -p" options + Resolves: rhbz#1673285 + +* Mon Feb 11 2019 Dave Anderson - 7.2.3-17 +- Support for CONFIG_ARM64_USER_VA_BITS_52 and CONFIG_ARM64_PA_BITS=52 + Resolves: rhbz#1670099 + +* Tue Jan 8 2019 Dave Anderson - 7.2.3-16 +- Resurrect "dev -p" option. +- Fix "dev -[dD]" options to account for request_queue.in_flight[] removal. + Resolves: rhbz#1662039 +- Command line input fixes + Resolves: rhbz#1664061 + +* Thu Dec 13 2018 Dave Anderson - 7.2.3-15 +- Increase ppc64 MAX_PHYSMEM_BITS to match 4.18.0-35.el8 kernel backport + Resolves: rhbz#1658628 + +* Thu Nov 29 2018 Dave Anderson - 7.2.3-14 +- Fix for ARM64 "ps -s" memory allocation failure + Resolves: rhbz#1654582 + +* Thu Oct 25 2018 Dave Anderson - 7.2.3-13 +- Change "bt" warnings when exception RIP is legitimate mapped address + Resolves: rhbz#1642221 + +* Mon Oct 15 2018 Dave Anderson - 7.2.3-12 +- Address covscan issues + Resolves: rhbz#1602466 +- Fix for x86_64 5-level pagetable vmalloc range expansion + Resolves: rhbz#1637125 + +* Wed Oct 4 2018 Dave Anderson - 7.2.3-11 +- Fix ppc64 backtrace issues + Resolves: rhbz#1633525 + +* Wed Sep 19 2018 Dave Anderson - 7.2.3-10 +- Address annocheck build issues + Resolves: rhbz#1624101 + +* Thu Aug 9 2018 Dave Anderson - 7.2.3-9 +- Fix for live system (/proc/kcore) access when KALSR is in effect + Resolves: rhbz#1611916 + +* Mon Jul 16 2018 Dave Anderson - 7.2.3-8 +- Rebase to github commits 9b494b70_to_eb823b79 + Resolves: rhbz#1563495 + +* Fri Jun 22 2018 Dave Anderson - 7.2.3-7 +- Rebase to github commits 28fa7bd0 to 02efd083 + Resolves: rhbz#1590751 + Resolves: rhbz#1592746 + +* Tue Jun 12 2018 Dave Anderson - 7.2.3-6 +- github commit 1926150e: fix ppc64/ppc6le stacksize calculation + +* Fri Jun 8 2018 Dave Anderson - 7.2.3-5 +- Remove /dev/mem readmem error message and /proc/kcore switch messages + Resolves: rhbz#1585944 + +* Fri Jun 1 2018 Dave Anderson - 7.2.3-4 +- Rebase to latest upstream sources + +* Tue Nov 21 2017 Dave Anderson - 7.2.0-2 +- Rebase to github commits da9bd35a to e2efacdd + Resolves: rhbz#1497316 + +* Wed Nov 1 2017 Dave Anderson - 7.2.0-1 +- Rebase to upstream version 7.2.0 +- Rebase to github commits da9bd35a_to_e2efacdd.patch + Resolves: rhbz#1497316 +- ppc64le: fix for "WARNING: cannot access vmalloc'd module memory" + Resolves: rhbz#1485391 +- Support for analyzing an SADUMP crash dump if KASLR is enabled + Resolves: rhbz#1504467 + +* Wed May 3 2017 Dave Anderson - 7.1.9-2 +- Rebase to github commits 87179026 to ad3b8476 + Resolves: rhbz#1393534 +- Prohibit native gdb disassemble command when KASLR + Resolves: rhbz#1445649 + +* Mon Apr 24 2017 Dave Anderson - 7.1.9-1 +- Rebase to upstream version 7.1.9 + Resolves: rhbz#1393534 +- Fix gdb "set scope" option for KASLR kernels. + Resolves: rhbz#1440725 +- Fix for the determination of the x86_64 "phys_base" value when it is + not passed in the VMCOREINFO data of ELF vmcores + Resolves: rhbz#1439170 + +* Wed Mar 8 2017 Dave Anderson - 7.1.8-2 +- mod [-sS] command may erroneously reassign module symbol addresses + Resolves: rhbz#1430091 + +* Fri Feb 24 2017 Dave Anderson - 7.1.8-1 +- Rebase to upstream version 7.1.8 + Resolves: rhbz#1393534 +- POWER9 - Power ISA 3.0 related support for crash utility + Resolves: rhbz#1368711 +- crash package update - ppc64/ppc64le + Resolves: rhbz#1384944 +- exception RIP: unknown or invalid address + Resolves: rhbz#1350457 +- Crash does not always parse correctly the modules symbol tables + Resolves: rhbz#1360415 +- ARM64: crash live system from: WARNING: cannot read linux_banner string + Resolves: rhbz#1392007 +- kmem: invalid structure member offset: page_count + Resolves: rhbz#1392011 +- Kernel address space randomization [KASLR] support + Resolves: rhbz#1392658 +- invalid structure size: tnt + Resolves: rhbz#1420653 + +* Wed Sep 14 2016 Dave Anderson - 7.1.5-2 +- Fix for kernel module symbol gathering when the ordering of module + symbol name strings does not match the order of the kernel_symbol + structures. +- Resolves: rhbz#1375130 + +* Thu Apr 28 2016 Dave Anderson - 7.1.5-1 +- Rebase to upstream version 7.1.5 + Resolves: rhbz#1292566 +- Decode clflushopt instruction + Resolves: rhbz#1262479 +- Support AArch64 QEMU generated dumps + Resolves: rhbz#1299873 +- crash: zero-size memory allocation (aarch64) + Resolves: rhbz#1312738 + +* Tue Apr 5 2016 Dave Anderson - 7.1.2-4 +- crash: fails to read excluded pages by default on sadump-related format + Resolves: rhbz#1304260 + +* Mon Nov 23 2015 Dave Anderson - 7.1.2-3 +- crash fails to read or wrongly reads some parts of memory in sadump vmcore format + Resolves: rhbz#1282997 + +* Tue Aug 4 2015 Dave Anderson - 7.1.2-2 +- Fix "kmem -s
", "bt -F[F]", and "rd -S[S]" options in kernels + configured with CONFIG_SLUB having multiple-page slabs. + Resolves: rhbz#1244003 +- Fix for SIGSEGV generated by "bt -[f|F]" in ARM64 kernels. + Resolves: rhbz#1248859 + +* Mon Jul 13 2015 Dave Anderson - 7.1.2-1 +- Rebase to upstream version 7.1.2 + Resolves: rhbz#1207696 +- Fix several ppc64 backtrace issues + Resolves: rhbz#1235447 + +* Fri Jun 05 2015 Dave Anderson - 7.1.1-2 +- ARM64 backtrace enhancements + Resolves: rhbz#1227508 + +* Thu May 28 2015 Dave Anderson - 7.1.1-1 +- Rebase to upstream version 7.1.1 + Resolves: rhbz#1207696 +- Display s390x vector registers from a kernel dump. + Resolves: rhbz#1182161 +- Fix date displayed on initial system banner and by the "sys" command on ARM64. + Resolves: rhbz#1223044 +- Fix ARM64 page size calculation on 4.1 and later kernels. + Resolves: rhbz#1222645 + +* Tue Apr 21 2015 Dave Anderson - 7.0.9-6 +- Calculate ARM64 virtual memory layout based upon struct page size + Resolves: rhbz#1204941 + +* Tue Apr 7 2015 Dave Anderson - 7.0.9-5 +- Support new sadump format that can represent more than 16 TB physical memory space + Resolves: rhbz#1182383 + +* Mon Jan 26 2015 Dave Anderson - 7.0.9-4 + Fix ppc64 "bt" command for active tasks in compressed kdumps. + Resolves: rhbz#1184401 + +* Mon Jan 12 2015 Dave Anderson - 7.0.9-3 + Fix "bt" command mislabeling errors. + Resolves: rhbz#1179476 + +* Mon Dec 08 2014 Dave Anderson - 7.0.9-2 +- Use registers from QEMU-generated ELF and compressed kdump headers + for active task backtraces. +- Resolves: rhbz#1169555 + +* Fri Nov 14 2014 Dave Anderson - 7.0.9-1 +- Rebase to upstream version 7.0.9. +- Resolves: rhbz#1110513 + +* Tue Sep 23 2014 Dave Anderson - 7.0.8-2 +- Fix ps performance patch regression on live systems. +- Resolves: rhbz#1134177 +- Minor build-related fixes for ppc64le. +- Resolves: rhbz#1123991 + +* Fri Sep 12 2014 Dave Anderson - 7.0.8-1 +- Rebase to upstream version 7.0.8. +- Resolves: rhbz#1110513 +- Fix to calculate the physical base address of dumpfiles created + by a "virsh dump" of an OVMF guest. +- Resolves: rhbz#1080698 +- Support for aarch64 architecture. +- Resolves: rhbz#1110551 +- Fix to prevent crash from spinning endlessly on a corrupted/truncated + dumpfile whose bitmap data is not wholly contained within the file. +- Resolves: rhbz#1114088 +- Support for ppc64le architecture. +- Resolves: rhbz#1123991 + +* Tue Jan 28 2014 Daniel Mach - 7.0.2-6 +- Mass rebuild 2014-01-24 + +* Fri Jan 24 2014 Dave Anderson - 7.0.2-5 +- Fix for a missing kernel-mode exception frame dump by the x86_64 + "bt" command if a page fault was generated by a bogus RIP. +- Resolves: rhbz#1057353 +- Fix for the x86_64 "bt" command to prevent an unwarranted message + indicating "WARNING: possibly bogus exception frame" generated + from a blocked kernel thread that was in the process of exec'ing + a user process via the call_usermodehelper() facility. +- Resolves: rhbz#1057357 + +* Fri Jan 10 2014 Dave Anderson - 7.0.2-4 +- Fixes for "kmem -S" command for CONFIG_SLUB. +- Resolves: rhbz#1045591 +- Increase S390X NR_CPUS +- Resolves: rhbz#1051156 + +* Fri Dec 27 2013 Daniel Mach - 7.0.2-3 +- Mass rebuild 2013-12-27 + +* Tue Oct 29 2013 Dave Anderson - 7.0.2-2 +- Compressed kdump 46-bit physical memory support + Resolves: rhbz#1015250 +- Fix incorrect backtrace for dumps taken with "virsh dump --memory-only" + Resolves: rhbz#1020469 +- Fix cpu number display on systems with more than 254 cpus + Resolves: rhbz#1020536 + +* Wed Sep 04 2013 Dave Anderson - 7.0.2-1 +- Update to latest upstream release +- Fix for ppc64 embedded gdb NULL pointer translation sigsegv +- Fix for bt -F failure + +* Fri Jul 26 2013 Dave Anderson - 7.0.1-4 +- Add lzo-devel and snappy-devel to crash-devel Requires line + +* Tue Jul 23 2013 Dave Anderson - 7.0.1-3 +- Build with snappy compression support + +* Tue Jul 9 2013 Dave Anderson - 7.0.1-2 +- Fix for ppc64 Linux 3.10 vmalloc/user-space virtual address translation + +* Tue Jun 18 2013 Dave Anderson - 7.0.1-1 +- Update to latest upstream release +- Build with LZO support + +* Tue Apr 9 2013 Dave Anderson - 6.1.6-1 +- Update to latest upstream release + +* Tue Feb 19 2013 Dave Anderson - 6.1.4-1 +- Update to latest upstream release + +* Wed Feb 13 2013 Fedora Release Engineering - 6.1.2-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_19_Mass_Rebuild + +* Wed Jan 9 2013 Dave Anderson - 6.1.2-1 +- Update to latest upstream release + +* Tue Nov 27 2012 Dave Anderson - 6.1.1-1 +- Update to latest upstream release + +* Mon Sep 1 2012 Dave Anderson - 6.1.0-1 +- Add ppc to ExclusiveArch list +- Update to latest upstream release + +* Tue Aug 21 2012 Dave Anderson - 6.0.9-1 +- Update to latest upstream release + +* Wed Jul 18 2012 Fedora Release Engineering - 6.0.8-2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Mon Jul 1 2012 Dave Anderson - 6.0.8-1 +- Update to latest upstream release. +- Replace usage of "struct siginfo" with "siginfo_t". + +* Mon Apr 30 2012 Dave Anderson - 6.0.6-1 +- Update to latest upstream release + +* Mon Mar 26 2012 Dave Anderson - 6.0.5-1 +- Update to latest upstream release + +* Wed Jan 4 2012 Dave Anderson - 6.0.2-1 +- Update to latest upstream release + +* Wed Oct 26 2011 Dave Anderson - 6.0.0-1 +- Update to latest upstream release + +* Tue Sep 20 2011 Dave Anderson - 5.1.8-1 +- Update to latest upstream release +- Additional fixes for gcc-4.6 -Werror compile failures for ARM architecture. + +* Thu Sep 1 2011 Dave Anderson - 5.1.7-2 +- Fixes for gcc-4.6 -Werror compile failures for ARM architecture. + +* Wed Aug 17 2011 Dave Anderson - 5.1.7-1 +- Update to latest upstream release +- Fixes for gcc-4.6 -Werror compile failures for ppc64/ppc. + +* Tue May 31 2011 Peter Robinson - 5.1.5-1 +- Update to latest upstream release +- Add ARM to the Exclusive arch + +* Wed Feb 25 2011 Dave Anderson - 5.1.2-2 +- Fixes for gcc-4.6 -Werror compile failures in gdb module. + +* Wed Feb 23 2011 Dave Anderson - 5.1.2-1 +- Upstream version. + +* Tue Feb 08 2011 Fedora Release Engineering - 5.0.6-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Tue Jul 20 2010 Dave Anderson - 5.0.6-2 +- Bump version. + +* Tue Jul 20 2010 Dave Anderson - 5.0.6-1 +- Update to upstream version. + +* Fri Sep 11 2009 Dave Anderson - 4.0.9-2 + Bump version. + +* Fri Sep 11 2009 Dave Anderson - 4.0.9-1 +- Update to upstream release, which allows the removal of the + Revision tag workaround, the crash-4.0-8.11-dwarf3.patch and + the crash-4.0-8.11-optflags.patch + +* Sun Aug 05 2009 Lubomir Rintel - 4.0.8.11-2 +- Fix reading of dwarf 3 DW_AT_data_member_location +- Use proper compiler flags + +* Wed Aug 05 2009 Lubomir Rintel - 4.0.8.11-1 +- Update to later upstream release +- Fix abuse of Revision tag + +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild +* Fri Jul 24 2009 Fedora Release Engineering - 4.0-9.7.2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Tue Feb 24 2009 Fedora Release Engineering - 4.0-8.7.2 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_11_Mass_Rebuild + +* Thu Feb 19 2009 Dave Anderson - 4.0-7.7.2 +- Replace exclusive arch i386 with ix86. + +* Thu Feb 19 2009 Dave Anderson - 4.0-7.7.1 +- Updates to this file per crash merge review +- Update to upstream version 4.0-7.7. Full changelog viewable in: + http://people.redhat.com/anderson/crash.changelog.html + +* Tue Jul 15 2008 Tom "spot" Callaway 4.0-7 +- fix license tag + +* Tue Apr 29 2008 Dave Anderson - 4.0-6.3 +- Added crash-devel subpackage +- Updated crash.patch to match upstream version 4.0-6.3 + +* Wed Feb 20 2008 Dave Anderson - 4.0-6.0.5 +- Second attempt at addressing the GCC 4.3 build, which failed due + to additional ptrace.h includes in the lkcd vmdump header files. + +* Wed Feb 20 2008 Dave Anderson - 4.0-6.0.4 +- First attempt at addressing the GCC 4.3 build, which failed on x86_64 + because ptrace-abi.h (included by ptrace.h) uses the "u32" typedef, + which relies on , and include/asm-x86_64/types.h + does not not typedef u32 as done in include/asm-x86/types.h. + +* Mon Feb 18 2008 Fedora Release Engineering - 4.0-6.0.3 +- Autorebuild for GCC 4.3 + +* Wed Jan 23 2008 Dave Anderson - 4.0-5.0.3 +- Updated crash.patch to match upstream version 4.0-5.0. + +* Wed Aug 29 2007 Dave Anderson - 4.0-4.6.2 +- Updated crash.patch to match upstream version 4.0-4.6. + +* Wed Sep 13 2006 Dave Anderson - 4.0-3.3 +- Updated crash.patch to match upstream version 4.0-3.3. +- Support for x86_64 relocatable kernels. BZ #204557 + +* Mon Aug 7 2006 Dave Anderson - 4.0-3.1 +- Updated crash.patch to match upstream version 4.0-3.1. +- Added kdump reference to description. +- Added s390 and s390x to ExclusiveArch list. BZ #199125 +- Removed LKCD v1 pt_regs references for s390/s390x build. +- Removed LKCD v2_v3 pt_regs references for for s390/s390x build. + +* Fri Jul 14 2006 Jesse Keating - 4.0-3 +- rebuild + +* Mon May 15 2006 Dave Anderson - 4.0-2.26.4 +- Updated crash.patch such that is not #include'd + by s390_dump.c; IBM did not make the file s390[s] only; BZ #192719 + +* Mon May 15 2006 Dave Anderson - 4.0-2.26.3 +- Updated crash.patch such that is not #include'd + by vas_crash.h; only ia64 build complained; BZ #191719 + +* Mon May 15 2006 Dave Anderson - 4.0-2.26.2 +- Updated crash.patch such that is not #include'd + by lkcd_x86_trace.c; also for BZ #191719 + +* Mon May 15 2006 Dave Anderson - 4.0-2.26.1 +- Updated crash.patch to bring it up to 4.0-2.26, which should + address BZ #191719 - "crash fails to build in mock" + +* Tue Feb 07 2006 Jesse Keating - 4.0-2.18.1 +- rebuilt for new gcc4.1 snapshot and glibc changes + +* Wed Jan 04 2006 Dave Anderson 4.0-2.18 +- Updated source package to crash-4.0.tar.gz, and crash.patch + to bring it up to 4.0-2.18. + +* Fri Dec 09 2005 Jesse Keating +- rebuilt + +* Thu Mar 03 2005 Dave Anderson 3.10-13 +- Compiler error- and warning-related fixes for gcc 4 build. +- Update to enhance x86 and x86_64 gdb disassembly output so as to + symbolically display call targets from kernel module text without + requiring module debuginfo data. +- Fix hole where an ia64 vmcore could be mistakenly accepted as a + usable dumpfile on an x86_64 machine, leading eventually to a + non-related error message. +* Wed Mar 02 2005 Dave Anderson 3.10-12 +- rebuild (gcc 4) +* Thu Feb 10 2005 Dave Anderson 3.10-9 +- Updated source package to crash-3.10.tar.gz, containing + IBM's final ppc64 processor support for RHEL4 +- Fixes potential "bt -a" hang on dumpfile where netdump IPI interrupted + an x86 process while executing the instructions just after it had entered + the kernel for a syscall, but before calling the handler. BZ #139437 +- Update to handle backtraces in dumpfiles generated on IA64 with the + INIT switch (functionality intro'd in RHEL3-U5 kernel). BZ #139429 +- Fix for handling ia64 and x86_64 machines booted with maxcpus=1 on + an SMP kernel. BZ #139435 +- Update to handle backtraces in dumpfiles generated on x86_64 from the + NMI exception stack (functionality intro'd in RHEL3-U5 kernel). +- "kmem -[sS]" beefed up to more accurately verify slab cache chains + and report errors found. +- Fix for ia64 INIT switch-generated backtrace handling when + init_handler_platform() is inlined into ia64_init_handler(); + properly handles both RHEL3 and RHEL4 kernel patches. + BZ #138350 +- Update to enhance ia64 gdb disassembly output so as to + symbolically display call targets from kernel module + text without requiring module debuginfo data. + +* Wed Jul 14 2004 Dave Anderson 3.8-5 +- bump release for fc3 + +* Tue Jul 13 2004 Dave Anderson 3.8-4 +- Fix for gcc 3.4.x/gdb issue where vmlinux was mistakenly presumed non-debug + +* Fri Jun 25 2004 Dave Anderson 3.8-3 +- remove (harmless) error message during ia64 diskdump invocation when + an SMP system gets booted with maxcpus=1 +- several 2.6 kernel specific updates + +* Thu Jun 17 2004 Dave Anderson 3.8-2 +- updated source package to crash-3.8.tar.gz +- diskdump support +- x86_64 processor support + +* Mon Sep 22 2003 Dave Anderson 3.7-5 +- make bt recovery code start fix-up only upon reaching first faulting frame + +* Fri Sep 19 2003 Dave Anderson 3.7-4 +- fix "bt -e" and bt recovery code to recognize new __KERNEL_CS and DS + +* Wed Sep 10 2003 Dave Anderson 3.7-3 +- patch to recognize per-cpu GDT changes that redefine __KERNEL_CS and DS + +* Wed Sep 10 2003 Dave Anderson 3.7-2 +- patches for netdump active_set determination and slab info gathering + +* Wed Aug 20 2003 Dave Anderson 3.7-1 +- updated source package to crash-3.7.tar.gz + +* Wed Jul 23 2003 Dave Anderson 3.6-1 +- removed Packager, Distribution, and Vendor tags +- updated source package to crash-3.6.tar.gz + +* Fri Jul 18 2003 Jay Fenlason 3.5-2 +- remove ppc from arch list, since it doesn't work with ppc64 kernels +- remove alpha from the arch list since we don't build it any more + +* Fri Jul 18 2003 Matt Wilson 3.5-1 +- use %%defattr(-,root,root) + +* Tue Jul 15 2003 Jay Fenlason +- Updated spec file as first step in turning this into a real RPM for taroon. +- Wrote man page.