This patch introduces new function x86_64_kvtop_pagetable() to translate virtual address to physical address. Unlike x86_64_kvtop(), x86_64_kvtop_pagetable() simply converts given virtual address to physical address using pagetable. To solve kaslr problem of virsh dump and sadump, kaslr offset and phys_base need to be calculated before symbol data is loaded. This calculation needs translation of kernel virtual address to physical address. Current kvtop() implementation tries to use x86_64_VTOP for translation at first, but this does not work for this purpose because x86_64_VTOP uses phys_base. So x86_64_kvtop_pagetable() is needed which does not use phys_base. Signed-off-by: Takao Indoh <indou.takao(a)jp.fujitsu.com&gt; --- defs.h | 1 + x86_64.c | 26 +++++++++++++++++++++++++- 2 files changed, 26 insertions(+), 1 deletion(-) diff --git a/defs.h b/defs.h index fd97ffe..cddca93 100644 --- a/defs.h +++ b/defs.h @@ -5622,6 +5622,7 @@ void x86_64_display_idt_table(void); #define display_idt_table() x86_64_display_idt_table() long x86_64_exception_frame(ulong, ulong, char *, struct bt_info *, FILE *); #define EFRAME_INIT (0) +int x86_64_kvtop_pagetable(ulong, physaddr_t *, int); struct x86_64_pt_regs_offsets { long r15; diff --git a/x86_64.c b/x86_64.c index 44d0c98..fc48425 100644 --- a/x86_64.c +++ b/x86_64.c @@ -119,6 +119,7 @@ static int x86_64_verify_paddr(uint64_t); static void GART_init(void); static void x86_64_exception_stacks_init(void); static int in_START_KERNEL_map(ulong); +static int __x86_64_kvtop(struct task_context *, ulong, physaddr_t *, int, int); struct machine_specific x86_64_machine_specific = { 0 }; @@ -1964,6 +1965,17 @@ no_upage: return FALSE; } +int +x86_64_kvtop_pagetable(ulong kvaddr, physaddr_t *paddr, int verbose) +{ + return __x86_64_kvtop(NULL, kvaddr, paddr, verbose, 1); +} + +static int +x86_64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose) +{ + return __x86_64_kvtop(tc, kvaddr, paddr, verbose, 0); +} /* * Translates a kernel virtual address to its physical address. cmd_vtop() @@ -1971,7 +1983,7 @@ no_upage: * other callers quietly accept the translation. */ static int -x86_64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose) +__x86_64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbose, int use_pagetable) { ulong *pml4; ulong *pgd; @@ -1985,6 +1997,16 @@ x86_64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbo ulong pte; physaddr_t physpage; + if (use_pagetable) { + FILL_PML4(); + pml4 = ((ulong *)machdep->machspec->pml4) + pml4_index(kvaddr); + if (verbose) { + fprintf(fp, "PML4 DIRECTORY: %lx\n", vt->kernel_pgd[0]); + fprintf(fp, "PAGE DIRECTORY: %lx\n", *pml4); + } + goto start_vtop_with_pagetable; + } + if (!IS_KVADDR(kvaddr)) return FALSE; @@ -2031,6 +2053,8 @@ x86_64_kvtop(struct task_context *tc, ulong kvaddr, physaddr_t *paddr, int verbo fprintf(fp, "PAGE DIRECTORY: %lx\n", *pml4); } } + +start_vtop_with_pagetable: if (!(*pml4) & _PAGE_PRESENT) goto no_kpage; pgd_paddr = (*pml4) & PHYSICAL_PAGE_MASK; -- 2.9.5

This patch fix a problem that crash cannot open a dumpfile which is captured by "virsh dump --memory-only" in KASLR enabled kernel. When KASLR feature is enabled, a kernel is placed on the memory randomly and therefore crash cannot open a dumpfile captured by "virsh dump --memory-only" because addresses of kernel symbols in System.map or vmlinux are different from actual addresses. To solve this problem, we need to calculate kaslr offset(the difference between original symbol address and actual address) and phys_base, and adjust symbol table of crash. In the case of dumpfile of kdump, these information is included in the header, but dumpfile of virsh dump does not have such a information. This patch calculate kaslr offset and phys_base to solve this problem. Please see the comment in the calc_kaslr_offset() for the detail idea. The basic idea is getting register (IDTR and CR3) from dump header, and calculate kaslr_offset/phys_base using them. Note that this patch works only for x86_64 arch and works only for "virsh dump --memory-only". Signed-off-by: Takao Indoh <indou.takao(a)jp.fujitsu.com&gt; --- defs.h | 7 + netdump.c | 502 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ netdump.h | 1 + symbols.c | 36 +++++ x86_64.c | 9 ++ 5 files changed, 555 insertions(+) diff --git a/defs.h b/defs.h index cddca93..558ab7b 100644 --- a/defs.h +++ b/defs.h @@ -2585,6 +2585,9 @@ struct symbol_table_data { ulong first_section_start; ulong last_section_end; ulong _stext_vmlinux; + ulong divide_error_vmlinux; + ulong idt_table_vmlinux; + ulong saved_command_line_vmlinux; struct downsized downsized; }; @@ -6125,6 +6128,8 @@ int get_netdump_arch(void); int exist_regs_in_elf_notes(struct task_context *); void *get_regs_from_elf_notes(struct task_context *); void map_cpus_to_prstatus(void); +int kdump_phys_base(ulong *); +int kdump_set_phys_base(ulong); int arm_kdump_phys_base(ulong *); int is_proc_kcore(char *, ulong); int proc_kcore_init(FILE *); @@ -6138,6 +6143,8 @@ void display_ELF_note(int, int, void *, FILE *); void *netdump_get_prstatus_percpu(int); #define PRSTATUS_NOTE (1) #define QEMU_NOTE (2) +int vmcore_kaslr_check(void); +int calc_kaslr_offset(ulong *kaslr_offset, ulong *phys_base); /* * ramdump.c diff --git a/netdump.c b/netdump.c index 0772e02..b03ba13 100644 --- a/netdump.c +++ b/netdump.c @@ -4694,3 +4694,505 @@ error(INFO, "%s: backup region is used: %llx\n", typename, backup_offset + total error: error(WARNING, "failed to init kexec backup region\n"); } + +int +vmcore_kaslr_check(void) +{ + if (!VMCORE_VALID() || !(pc->flags2 & QEMU_MEM_DUMP_ELF)) + return FALSE; + + /* If vmcore has QEMU note, need to calculate kaslr offset */ + if (nd->num_qemu_notes) + return TRUE; + else + return FALSE; +} + +QEMUCPUState * +get_qemucpustate(int cpu) +{ + if (cpu >= nd->num_qemu_notes) { + if (CRASHDEBUG(1)) + error(INFO, + "Invalid index for QEMU Note: %d (>= %d)\n", + cpu, nd->num_qemu_notes); + return NULL; + } + + if (!nd->elf64 || (nd->elf64->e_machine != EM_X86_64)) { + if (CRASHDEBUG(1)) + error(INFO, "Only x86_64 64bit is supported.\n"); + return NULL; + } + + return (QEMUCPUState *)nd->nt_qemu_percpu[cpu]; +} + +int kdump_phys_base(ulong *phys_base) +{ + if (!vmcore_kaslr_check()) + return FALSE; + + if (nd->phys_base) { + *phys_base = nd->phys_base; + return TRUE; + } + + return FALSE; +} + +int kdump_set_phys_base(ulong phys_base) +{ + if (!vmcore_kaslr_check()) + return FALSE; + + nd->phys_base = phys_base; + + return TRUE; +} + +/* + * Get address of vector0 interrupt handler (Devide Error) form Interrupt + * Descriptor Table. + */ +static ulong +get_vec0_addr(ulong idtr) +{ + ulong buf[16]; + ulong *ip, i1, i2, addr; + + readmem(idtr, PHYSADDR, buf, sizeof(buf), "idt_table", FAULT_ON_ERROR); + ip = (ulong *)buf; + + i1 = *ip; + i2 = *(ip+1); + + i2 <<= 32; + addr = i2 & 0xffffffff00000000; + addr |= (i1 & 0xffff); + i1 >>= 32; + addr |= (i1 & 0xffff0000); + + return addr; +} + +ulong +static qemu_get_idtr(void) +{ + QEMUCPUState *cpustat; + + cpustat = get_qemucpustate(0); + return cpustat->idt.base; +} + +ulong +static qemu_get_cr3(void) +{ + QEMUCPUState *cpustat; + + cpustat = get_qemucpustate(0); + return cpustat->cr[3]; +} + +/* + * Parse a string of [size[KMG]@]offset[KMG] + * Import from Linux kernel(lib/cmdline.c) + */ +static ulong memparse(char *ptr, char **retptr) +{ + char *endptr; + + unsigned long long ret = strtoull(ptr, &endptr, 0); + + switch (*endptr) { + case 'E': + case 'e': + ret <<= 10; + case 'P': + case 'p': + ret <<= 10; + case 'T': + case 't': + ret <<= 10; + case 'G': + case 'g': + ret <<= 10; + case 'M': + case 'm': + ret <<= 10; + case 'K': + case 'k': + ret <<= 10; + endptr++; + default: + break; + } + + if (retptr) + *retptr = endptr; + + return ret; +} + +/* + * Find "elfcorehdr=" in the boot parameter of kernel and return the address + * of elfcorehdr. + */ +static ulong +get_elfcorehdr(ulong cr3, ulong kaslr_offset) +{ + char cmdline[BUFSIZE], *ptr; + ulong cmdline_vaddr; + ulong cmdline_paddr; + ulong buf_vaddr, buf_paddr; + int i; + char elfcorehdr_val[16], *end; + ulong elfcorehdr_addr = 0, elfcorehdr_size = 0; + int verbose = CRASHDEBUG(1)? 1: 0; + + cmdline_vaddr = st->saved_command_line_vmlinux + kaslr_offset; + if (!x86_64_kvtop_pagetable(cmdline_vaddr, &cmdline_paddr, verbose)) + return 0; + + if (CRASHDEBUG(1)) { + fprintf(fp, "cmdline vaddr=%lx\n", cmdline_vaddr); + fprintf(fp, "cmdline paddr=%lx\n", cmdline_paddr); + } + + if (!readmem(cmdline_paddr, PHYSADDR, &buf_vaddr, sizeof(ulong), + "saved_command_line", FAULT_ON_ERROR)) + return 0; + + if (!x86_64_kvtop_pagetable(buf_vaddr, &buf_paddr, verbose)) + return 0; + + if (CRASHDEBUG(1)) { + fprintf(fp, "cmdline buffer vaddr=%lx\n", buf_vaddr); + fprintf(fp, "cmdline buffer paddr=%lx\n", buf_paddr); + } + + memset(cmdline, 0, BUFSIZE); + if (!readmem(buf_paddr, PHYSADDR, cmdline, BUFSIZE, + "saved_command_line", FAULT_ON_ERROR)) + return 0; + + ptr = strstr(cmdline, "elfcorehdr="); + if (!ptr) + return 0; + + ptr += strlen("elfcorehdr="); + memset(elfcorehdr_val, 0, sizeof(elfcorehdr_val)); + sscanf(ptr, "%s", elfcorehdr_val); + + if (CRASHDEBUG(1)) { + fprintf(fp, "2nd kernel detected\n", buf_vaddr); + fprintf(fp, "elfcorehdr=%s\n", elfcorehdr_val); + } + + /* elfcorehdr=[size[KMG]@]offset[KMG] */ + elfcorehdr_addr = memparse(elfcorehdr_val, &end); + if (*end == '@') { + elfcorehdr_size = elfcorehdr_addr; + elfcorehdr_addr = memparse(end + 1, &end); + } + + if (CRASHDEBUG(1)) { + fprintf(fp, "elfcorehdr_addr=%lx\n", elfcorehdr_addr); + fprintf(fp, "elfcorehdr_size=%lx\n", elfcorehdr_size); + } + + return elfcorehdr_addr; +} + + /* + * Get vmcoreinfo from elfcorehdr. + * Some codes are imported from Linux kernel(fs/proc/vmcore.c) + */ +static int +get_vmcoreinfo(ulong elfcorehdr, ulong *addr, int *len) +{ + unsigned char e_ident[EI_NIDENT]; + Elf64_Ehdr ehdr; + Elf64_Phdr phdr; + Elf64_Nhdr nhdr; + ulong ptr; + ulong nhdr_offset = 0; + int i; + + if (!readmem(elfcorehdr, PHYSADDR, e_ident, EI_NIDENT, + "EI_NIDENT", FAULT_ON_ERROR)) + return FALSE; + + if (e_ident[EI_CLASS] != ELFCLASS64) { + error(INFO, "Only ELFCLASS64 is supportd\n"); + return FALSE; + } + + if (!readmem(elfcorehdr, PHYSADDR, &ehdr, sizeof(ehdr), + "Elf64_Ehdr", FAULT_ON_ERROR)) + return FALSE; + + /* Sanity Check */ + if (memcmp(ehdr.e_ident, ELFMAG, SELFMAG) != 0 || + (ehdr.e_type != ET_CORE) || + ehdr.e_ident[EI_CLASS] != ELFCLASS64 || + ehdr.e_ident[EI_VERSION] != EV_CURRENT || + ehdr.e_version != EV_CURRENT || + ehdr.e_ehsize != sizeof(Elf64_Ehdr) || + ehdr.e_phentsize != sizeof(Elf64_Phdr) || + ehdr.e_phnum == 0) { + error(INFO, "Invalid elf header\n"); + return FALSE; + } + + ptr = elfcorehdr + sizeof(ehdr); + for (i = 0; i < ehdr.e_phnum; i++) { + ulong offset; + char name[16]; + + if (!readmem(ptr, PHYSADDR, &phdr, sizeof(phdr), + "Elf64_Phdr", FAULT_ON_ERROR)) + return FALSE; + + ptr += sizeof(phdr); + if (phdr.p_type != PT_NOTE) + continue; + + offset = phdr.p_offset; + if (!readmem(offset, PHYSADDR, &nhdr, sizeof(nhdr), + "Elf64_Nhdr", FAULT_ON_ERROR)) + return FALSE; + + offset += DIV_ROUND_UP(sizeof(Elf64_Nhdr), sizeof(Elf64_Word))* + sizeof(Elf64_Word); + memset(name, 0, sizeof(name)); + if (!readmem(offset, PHYSADDR, name, sizeof(name), + "Elf64_Nhdr name", FAULT_ON_ERROR)) + return FALSE; + + if(!strcmp(name, "VMCOREINFO")) { + nhdr_offset = offset; + break; + } + } + + if (!nhdr_offset) + return FALSE; + + *addr = nhdr_offset + + DIV_ROUND_UP(nhdr.n_namesz, sizeof(Elf64_Word))* + sizeof(Elf64_Word); + *len = nhdr.n_descsz; + + if (CRASHDEBUG(1)) { + fprintf(fp, "vmcoreinfo addr=%lx\n", *addr); + fprintf(fp, "vmcoreinfo len=%d\n", *len); + } + + return TRUE; +} + +/* + * Check if current kaslr_offset/phys_base is for 1st kernel or 2nd kernel. + * If we are in 2nd kernel, get kaslr_offset/phys_base from vmcoreinfo. + * + * 1. Get command line and try to retrieve "elfcorehdr=" boot parameter + * 2. If "elfcorehdr=" is not found in command line, we are in 1st kernel. + * There is nothing to do. + * 3. If "elfcorehdr=" is found, we are in 2nd kernel. Find vmcoreinfo + * using "elfcorehdr=" and retrieve kaslr_offset/phys_base from vmcoreinfo. + */ +int +get_kaslr_offset_from_vmcoreinfo(ulong cr3, ulong orig_kaslr_offset, + ulong *kaslr_offset, ulong *phys_base) +{ + ulong elfcorehdr_addr = 0; + ulong vmcoreinfo_addr; + int vmcoreinfo_len; + char *buf, *pos, *endptr; + + /* Find "elfcorehdr=" in the kernel boot parameter */ + elfcorehdr_addr = get_elfcorehdr(cr3, orig_kaslr_offset); + if (!elfcorehdr_addr) + return FALSE; + + /* Get vmcoreinfo from the address of "elfcorehdr=" */ + if (!get_vmcoreinfo(elfcorehdr_addr, &vmcoreinfo_addr, &vmcoreinfo_len)) + return FALSE; + + if (CRASHDEBUG(1)) + fprintf(fp, "Find vmcoreinfo in kdump memory\n"); + + buf = GETBUF(vmcoreinfo_len); + if (!readmem(vmcoreinfo_addr, PHYSADDR, buf, vmcoreinfo_len, + "vmcoreinfo", FAULT_ON_ERROR)) + goto free_and_return; + + /* Get phys_base form vmcoreinfo */ + pos = strstr(buf, "NUMBER(phys_base)="); + if (!pos) + goto free_and_return; + *phys_base = strtoull(pos + strlen("NUMBER(phys_base)="), &endptr, 0); + + /* Get kaslr_offset form vmcoreinfo */ + pos = strstr(buf, "KERNELOFFSET="); + if (!pos) + goto free_and_return; + *kaslr_offset = strtoull(pos + strlen("KERNELOFFSET="), &endptr, 16); + + FREEBUF(buf); + return TRUE; + +free_and_return: + FREEBUF(buf); + return FALSE; +} + +/* + * Calculate kaslr_offset and phys_base + * + * kaslr_offset: + * The difference between original address in System.map or vmlinux and + * actual address placed randomly by kaslr feature. To be more accurate, + * kaslr_offset = actual address - original address + * + * phys_base: + * Physical address where the kerenel is placed. In other words, it's a + * physical address of __START_KERNEL_map. This is also decided randomly by + * kaslr. + * + * kaslr offset and phys_base are calculated as follows: + * + * kaslr_offset: + * 1) Get IDTR and CR3 value from the dump header. + * 2) Get a virtual address of IDT from IDTR value + * --- (A) + * 3) Translate (A) to physical address using CR3, which points a top of + * page table. + * --- (B) + * 4) Get an address of vector0 (Devide Error) interrupt handler from + * IDT, which are pointed by (B). + * --- (C) + * 5) Get an address of symbol "divide_error" form vmlinux + * --- (D) + * + * Now we have two addresses: + * (C)-> Actual address of "divide_error" + * (D)-> Original address of "divide_error" in the vmlinux + * + * kaslr_offset can be calculated by the difference between these two + * value. + * + * phys_base; + * 1) Get IDT virtual address from vmlinux + * --- (E) + * + * So phys_base can be calculated using relationship of directly mapped + * address. + * + * phys_base = + * Physical address(B) - + * (Virtual address(E) + kaslr_offset - __START_KERNEL_map) + * + * Note that the address (A) cannot be used instead of (E) because (A) is + * not direct map address, it's a fixed map address. + * + * This solution works in most every case, but does not work in the + * following case. + * + * 1) If the dump is captured on early stage of kernel boot, IDTR points + * early IDT table(early_idts) instead of normal IDT(idt_table). + * 2) If the dump is captured whle kdump is working, IDTR points + * IDT table of 2nd kernel, not 1st kernel. + * + * Current implementation does not support the case 1), need + * enhancement in the future. For the case 2), get kaslr_offset and + * phys_base as follows. + * + * 1) Get kaslr_offset and phys_base using the above solution. + * 2) Get kernel boot parameter from "saved_command_line" + * 3) If "elfcorehdr=" is not included in boot parameter, we are in the + * first kernel, nothing to do any more. + * 4) If "elfcorehdr=" is included in boot parameter, we are in the 2nd + * kernel. Retrieve vmcoreinfo from address of "elfcorehdr=" and + * get kaslr_offset and phys_base from vmcoreinfo. + */ +int +calc_kaslr_offset(ulong *kaslr_offset, ulong *phys_base) +{ + uint64_t idtr = 0, cr3 = 0, idtr_paddr; + ulong divide_error_vmcore; + ulong kaslr_offset_kdump, phys_base_kdump; + int ret = FALSE; + int verbose = CRASHDEBUG(1)? 1: 0; + + if (!machine_type("X86_64")) + return FALSE; + + if (vmcore_kaslr_check()) { + idtr = qemu_get_idtr(); + cr3 = qemu_get_cr3(); + } else + return FALSE; + + /* + * Set up for kvtop. + * + * calc_kaslr_offset() is called before machdep_init(PRE_GDB), so some + * variables are not initialized yet. Set up them here to call + * x86_64_kvtop_pagetable(). + * + * TODO: XEN and 5-level is not supported + */ + vt->kernel_pgd[0] = cr3; + machdep->machspec->last_pml4_read = vt->kernel_pgd[0]; + machdep->machspec->physical_mask_shift = __PHYSICAL_MASK_SHIFT_2_6; + machdep->machspec->pgdir_shift = PGDIR_SHIFT; + if (!readmem(cr3, PHYSADDR, machdep->machspec->pml4, PAGESIZE(), + "cr3", FAULT_ON_ERROR)) + goto quit; + + /* Convert virtual address of IDT table to physical address */ + if (!x86_64_kvtop_pagetable(idtr, &idtr_paddr, verbose)) + goto quit; + + /* Now we can calculate kaslr_offset and phys_base */ + divide_error_vmcore = get_vec0_addr(idtr_paddr); + *kaslr_offset = divide_error_vmcore - st->divide_error_vmlinux; + *phys_base = idtr_paddr - + (st->idt_table_vmlinux + *kaslr_offset - __START_KERNEL_map); + + if (CRASHDEBUG(1)) { + fprintf(fp, "calc_kaslr_offset: idtr=%lx\n", idtr); + fprintf(fp, "calc_kaslr_offset: cr3=%lx\n", cr3); + fprintf(fp, "calc_kaslr_offset: idtr(phys)=%lx\n", idtr_paddr); + fprintf(fp, "calc_kaslr_offset: divide_error(vmlinux): %lx\n", + st->divide_error_vmlinux); + fprintf(fp, "calc_kaslr_offset: divide_error(vmcore): %lx\n", + divide_error_vmcore); + } + + /* + * Check if current kaslr_offset/phys_base is for 1st kernel or 2nd + * kernel. If we are in 2nd kernel, get kaslr_offset/phys_base + * from vmcoreinfo + */ + if (get_kaslr_offset_from_vmcoreinfo( + cr3, *kaslr_offset, &kaslr_offset_kdump, &phys_base_kdump)) { + *kaslr_offset = kaslr_offset_kdump; + *phys_base = phys_base_kdump; + } + + if (CRASHDEBUG(1)) { + fprintf(fp, "calc_kaslr_offset: kaslr_offset=%lx\n", + *kaslr_offset); + fprintf(fp, "calc_kaslr_offset: phys_base=%lx\n", *phys_base); + } + + ret = TRUE; +quit: + vt->kernel_pgd[0] = 0; + machdep->machspec->last_pml4_read = 0; + return ret; +} + diff --git a/netdump.h b/netdump.h index ec6691c..91ae428 100644 --- a/netdump.h +++ b/netdump.h @@ -78,6 +78,7 @@ struct vmcore_data { ulong backup_src_size; ulonglong backup_offset; ulong relocate; + ulong phys_base; }; #define DUMP_ELF_INCOMPLETE 0x1 /* dumpfile is incomplete */ diff --git a/symbols.c b/symbols.c index c793760..9e0c9df 100644 --- a/symbols.c +++ b/symbols.c @@ -624,6 +624,9 @@ kaslr_init(void) st->_stext_vmlinux = UNINITIALIZED; } } + + if (vmcore_kaslr_check()) + kt->flags2 |= KASLR_CHECK; } /* @@ -637,6 +640,22 @@ derive_kaslr_offset(bfd *abfd, int dynamic, bfd_byte *start, bfd_byte *end, unsigned long relocate; ulong _stext_relocated; + if (vmcore_kaslr_check()) { + ulong kaslr_offset = 0, phys_base = 0; + + calc_kaslr_offset(&kaslr_offset, &phys_base); + + if (kaslr_offset) { + kt->relocate = kaslr_offset * -1; + kt->flags |= RELOC_SET; + } + + if (phys_base) + kdump_set_phys_base(phys_base); + + return; + } + if (ACTIVE()) { _stext_relocated = symbol_value_from_proc_kallsyms("_stext"); if (_stext_relocated == BADVAL) @@ -12236,6 +12255,23 @@ numeric_forward(const void *P_x, const void *P_y) } } + if (vmcore_kaslr_check()) { + if (STREQ(x->name, "divide_error")) + st->divide_error_vmlinux = valueof(x); + else if (STREQ(y->name, "divide_error")) + st->divide_error_vmlinux = valueof(y); + + if (STREQ(x->name, "idt_table")) + st->idt_table_vmlinux = valueof(x); + else if (STREQ(y->name, "idt_table")) + st->idt_table_vmlinux = valueof(y); + + if (STREQ(x->name, "saved_command_line")) + st->saved_command_line_vmlinux = valueof(x); + else if (STREQ(y->name, "saved_command_line")) + st->saved_command_line_vmlinux = valueof(y); + } + xs = bfd_get_section(x); ys = bfd_get_section(y); diff --git a/x86_64.c b/x86_64.c index fc48425..8fc79b6 100644 --- a/x86_64.c +++ b/x86_64.c @@ -6377,6 +6377,15 @@ x86_64_calc_phys_base(void) return; } + if (KDUMP_DUMPFILE()) { + if (kdump_phys_base(&phys_base)) { + machdep->machspec->phys_base = phys_base; + if (CRASHDEBUG(1)) + fprintf(fp, "kdump: phys_base: %lx\n", + phys_base); + } + } + if (SADUMP_DUMPFILE()) { if (sadump_phys_base(&phys_base)) { machdep->machspec->phys_base = phys_base; -- 2.9.5

This patch fix a problem that crash cannot open a dumpfile which can be captured by sadump in KASLR enabled kernel. The sadump dumpfile has register information in the header, therefore this problem can be solved by the same way as virsh dump. Signed-off-by: Takao Indoh <indou.takao(a)jp.fujitsu.com&gt; --- defs.h | 3 +++ netdump.c | 3 +++ sadump.c | 60 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++- sadump.h | 4 ++++ symbols.c | 10 ++++++---- 5 files changed, 75 insertions(+), 5 deletions(-) diff --git a/defs.h b/defs.h index 558ab7b..2c84d73 100644 --- a/defs.h +++ b/defs.h @@ -6263,12 +6263,15 @@ FILE *set_sadump_fp(FILE *); void get_sadump_regs(struct bt_info *bt, ulong *ipp, ulong *spp); void sadump_display_regs(int, FILE *); int sadump_phys_base(ulong *); +int sadump_set_phys_base(ulong); void sadump_show_diskset(void); int sadump_is_zero_excluded(void); void sadump_set_zero_excluded(void); void sadump_unset_zero_excluded(void); struct sadump_data; struct sadump_data *get_sadump_data(void); +ulong sadump_get_idtr(void); +ulong sadump_get_cr3(void); /* * qemu.c diff --git a/netdump.c b/netdump.c index b03ba13..b0ce160 100644 --- a/netdump.c +++ b/netdump.c @@ -5132,6 +5132,9 @@ calc_kaslr_offset(ulong *kaslr_offset, ulong *phys_base) if (vmcore_kaslr_check()) { idtr = qemu_get_idtr(); cr3 = qemu_get_cr3(); + } else if (SADUMP_DUMPFILE()) { + idtr = sadump_get_idtr(); + cr3 = sadump_get_cr3(); } else return FALSE; diff --git a/sadump.c b/sadump.c index a96ba9c..d2a5c47 100644 --- a/sadump.c +++ b/sadump.c @@ -1558,15 +1558,27 @@ sadump_display_regs(int cpu, FILE *ofp) */ int sadump_phys_base(ulong *phys_base) { - if (SADUMP_VALID()) { + if (SADUMP_VALID() && !sd->phys_base) { if (CRASHDEBUG(1)) error(NOTE, "sadump: does not save phys_base.\n"); return FALSE; } + if (sd->phys_base) { + *phys_base = sd->phys_base; + return TRUE; + } + return FALSE; } +int sadump_set_phys_base(ulong phys_base) +{ + sd->phys_base = phys_base; + + return TRUE; +} + /* * Used by "sys" command to show diskset disk names. */ @@ -1649,3 +1661,49 @@ get_sadump_data(void) { return sd; } + +static int +get_sadump_smram_cpu_state_any(struct sadump_smram_cpu_state *smram) +{ + ulong offset; + struct sadump_header *sh = sd->dump_header; + int apicid; + struct sadump_smram_cpu_state scs, zero; + + offset = sd->sub_hdr_offset + sizeof(uint32_t) + + sd->dump_header->nr_cpus * sizeof(struct sadump_apic_state); + + memset(&zero, 0, sizeof(zero)); + + for (apicid = 0; apicid < sh->nr_cpus; ++apicid) { + if (!read_device(&scs, sizeof(scs), &offset)) { + error(INFO, "sadump: cannot read sub header " + "cpu_state\n"); + return FALSE; + } + if (memcmp(&scs, &zero, sizeof(scs)) != 0) { + *smram = scs; + return TRUE; + } + } + + return FALSE; +} + +ulong +sadump_get_idtr(void) +{ + struct sadump_smram_cpu_state scs; + get_sadump_smram_cpu_state_any(&scs); + + return ((uint64_t)scs.IdtUpper)<<32 | (uint64_t)scs.IdtLower; +} + +ulong +sadump_get_cr3(void) +{ + struct sadump_smram_cpu_state scs; + get_sadump_smram_cpu_state_any(&scs); + + return scs.Cr3; +} diff --git a/sadump.h b/sadump.h index 7f8e384..66aa17e 100644 --- a/sadump.h +++ b/sadump.h @@ -219,6 +219,10 @@ struct sadump_data { ulonglong backup_offset; uint64_t max_mapnr; + + ulong kaslr_offset; + ulong phys_base; + ulong cr3; }; struct sadump_data *sadump_get_sadump_data(void); diff --git a/symbols.c b/symbols.c index 9e0c9df..38720b5 100644 --- a/symbols.c +++ b/symbols.c @@ -625,7 +625,7 @@ kaslr_init(void) } } - if (vmcore_kaslr_check()) + if (vmcore_kaslr_check() || SADUMP_DUMPFILE()) kt->flags2 |= KASLR_CHECK; } @@ -640,7 +640,7 @@ derive_kaslr_offset(bfd *abfd, int dynamic, bfd_byte *start, bfd_byte *end, unsigned long relocate; ulong _stext_relocated; - if (vmcore_kaslr_check()) { + if (vmcore_kaslr_check() || SADUMP_DUMPFILE()) { ulong kaslr_offset = 0, phys_base = 0; calc_kaslr_offset(&kaslr_offset, &phys_base); @@ -650,8 +650,10 @@ derive_kaslr_offset(bfd *abfd, int dynamic, bfd_byte *start, bfd_byte *end, kt->flags |= RELOC_SET; } - if (phys_base) + if (phys_base) { kdump_set_phys_base(phys_base); + sadump_set_phys_base(phys_base); + } return; } @@ -12255,7 +12257,7 @@ numeric_forward(const void *P_x, const void *P_y) } } - if (vmcore_kaslr_check()) { + if (vmcore_kaslr_check() || SADUMP_DUMPFILE()) { if (STREQ(x->name, "divide_error")) st->divide_error_vmlinux = valueof(x); else if (STREQ(y->name, "divide_error")) -- 2.9.5