[Crash-utility] [PATCH] Use registers from LKCD header to get starting ESP register

On i386/x86_64, crash uses the ESP register to start its backtrace when analysing LKCD dumps. It does this by guessing in get_lkcd_regs(). This patch uses another approach vor v8 dumps: It uses the registers saved by LKCD in the arch-specific dump header. It fixed a problem here where I head a crash dump from a customer using LKCD that showed a totally wrong backtrace in crash but lcrash worked fine. To implement this, the patch fetches the headers for all architectures and not only to IA64. We need the arch-specific header, this is done by copying the declaraction from the kernel patch (2.6.17, the latest) and using a separate header file for each architecture. Signed-off-by: Bernhard Walle <bwalle(a)suse.de&gt; --- Makefile | 31 +++++++++- defs.h | 2 kernel.c | 63 +++++++++++--------- lkcd_dump_i386.c | 32 ++++++++++ lkcd_dump_i386.h | 71 +++++++++++++++++++++++ lkcd_dump_ia64.c | 35 +++++++++++ lkcd_dump_ia64.h | 81 ++++++++++++++++++++++++++ lkcd_dump_ppc.h | 67 +++++++++++++++++++++ lkcd_dump_v7.h | 163 ++--------------------------------------------------- lkcd_dump_v8.h | 32 ++++++++++ lkcd_dump_x86_64.c | 32 ++++++++++ lkcd_dump_x86_64.h | 71 +++++++++++++++++++++++ lkcd_fix_mem.c | 18 ----- lkcd_v8.c | 140 ++++++++++++++++++++++++++++++++++++++++++++- 14 files changed, 633 insertions(+), 205 deletions(-) --- a/Makefile +++ b/Makefile @@ -97,6 +97,24 @@ OBJECT_FILES=main.o tools.o global_data. xen_hyper.o xen_hyper_command.o xen_hyper_global_data.o \ xen_hyper_dump_tables.o + +# architecture specific LKCD files + +ifeq ($(ARCH), x86_64) +CFILES += lkcd_dump_x86_64.c +OBJECT_FILES += lkcd_dump_x86_64.o +endif + +ifeq ($(ARCH), i386) +CFILES += lkcd_dump_i386.c +OBJECT_FILES += lkcd_dump_i386.o +endif + +ifeq ($(ARCH), ia64) +CFILES += lkcd_dump_ia64.c +OBJECT_FILES += lkcd_dump_ia64.o +endif + # These are the current set of crash extensions sources. They are not built # by default unless the third command line of the "all:" stanza is uncommented. # Alternatively, they can be built by entering "make extensions" from this @@ -334,6 +352,15 @@ lkcd_v7.o: ${GENERIC_HFILES} ${LKCD_DUMP lkcd_v8.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} lkcd_v8.c cc -c ${CFLAGS} -DMCLX lkcd_v8.c ${WARNING_OPTIONS} ${WARNING_ERROR} +lkcd_dump_x86_64.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} lkcd_dump_x86_64.c + cc -c ${CFLAGS} -DMCLX lkcd_dump_x86_64.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_dump_i386.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} lkcd_dump_i386.c + cc -c ${CFLAGS} -DMCLX lkcd_dump_i386.c ${WARNING_OPTIONS} ${WARNING_ERROR} + +lkcd_dump_ia64.o: ${GENERIC_HFILES} ${LKCD_DUMP_HFILES} lkcd_dump_ia64.c + cc -c ${CFLAGS} -DMCLX lkcd_dump_ia64.c ${WARNING_OPTIONS} ${WARNING_ERROR} + net.o: ${GENERIC_HFILES} net.c cc -c ${CFLAGS} net.c ${WARNING_OPTIONS} ${WARNING_ERROR} --- a/defs.h +++ b/defs.h @@ -3790,7 +3790,7 @@ void ppc_dump_machdep_table(ulong); */ ulong get_lkcd_switch_stack(ulong); -int fix_addr_v8(int); +int fix_addr_v8(); int fix_addr_v7(int); /* --- a/kernel.c +++ b/kernel.c @@ -2089,6 +2089,11 @@ get_lkcd_regs(struct bt_info *bt, ulong return; } + /* try to get it from the header */ + if (get_lkcd_regs_for_cpu(bt, eip, esp) == 0) + return; + + /* if that fails: do guessing */ sysrq_eip = sysrq_esp = 0; for (i = 0, up = (ulong *)bt->stackbuf; i < LONGS_PER_STACK; i++, up++){ @@ -2098,48 +2103,48 @@ get_lkcd_regs(struct bt_info *bt, ulong *esp = *(up-1); return; } - /* Begin 3PAR change -- required for our panic path */ + /* Begin 3PAR change -- required for our panic path */ if (STREQ(sym, "dump_ipi") && INSTACK(*(up-1), bt)) { *eip = *up; *esp = *(up-1); return; } /* End 3PAR change */ - if (STREQ(sym, "panic") && INSTACK(*(up-1), bt)) { - *eip = *up; - *esp = *(up-1); - return; - } + if (STREQ(sym, "panic") && INSTACK(*(up-1), bt)) { + *eip = *up; + *esp = *(up-1); + return; + } /* Egenera */ - if (STREQ(sym, "netdump_ipi")) { - *eip = *up; - *esp = bt->task + + if (STREQ(sym, "netdump_ipi")) { + *eip = *up; + *esp = bt->task + ((char *)(up-1) - bt->stackbuf); - return; - } - if (STREQ(sym, "smp_stop_cpu_interrupt")) { - *eip = *up; - *esp = bt->task + + return; + } + if (STREQ(sym, "smp_stop_cpu_interrupt")) { + *eip = *up; + *esp = bt->task + ((char *)(up-1) - bt->stackbuf); - return; - } - if (STREQ(sym, "stop_this_cpu")) { - *eip = *up; - *esp = bt->task + + return; + } + if (STREQ(sym, "stop_this_cpu")) { + *eip = *up; + *esp = bt->task + ((char *)(up-1) - bt->stackbuf); - return; - } - if (SYSRQ_TASK(bt->task) && - STREQ(sym, "smp_call_function_interrupt")) { - sysrq_eip = *up; - sysrq_esp = bt->task + - ((char *)(up-1) - bt->stackbuf); - } + return; + } + if (SYSRQ_TASK(bt->task) && + STREQ(sym, "smp_call_function_interrupt")) { + sysrq_eip = *up; + sysrq_esp = bt->task + + ((char *)(up-1) - bt->stackbuf); + } } if (sysrq_eip) { - *eip = sysrq_eip; - *esp = sysrq_esp; + *eip = sysrq_eip; + *esp = sysrq_esp; return; } --- /dev/null +++ b/lkcd_dump_i386.c @@ -0,0 +1,32 @@ +/* lkcd_dump_i386.c + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#include <stdint.h> +#include <stddef.h> +#include <stdio.h> + +#define LKCD_COMMON +#include "defs.h" +#include "lkcd_dump_v8.h" + + +int +get_lkcd_regs_for_cpu_arch_i386(dump_header_asm_t *dha, int cpu, ulong *eip, ulong *esp) +{ + if (eip) + *eip = dha->dha_smp_regs[cpu].eip; + if (esp) + *esp = dha->dha_smp_regs[cpu].esp; + + return 0; +} + --- /dev/null +++ b/lkcd_dump_i386.h @@ -0,0 +1,71 @@ +/* lkcd_dump_i386.h + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef LKCD_DUMP_I386_H +#define LKCD_DUMP_I386_H + +#include <linux/ptrace.h> + +/* from kernel include/asm-i386/dump.h */ +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_ASM_VERSION_NUMBER 0x5 /* version number */ + +/* + * Structure: __dump_header_asm + * Function: This is the header for architecture-specific stuff. It + * follows right after the dump header. + */ +typedef struct __dump_header_asm_i386 { + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; + + /* the esp for i386 systems */ + uint32_t dha_esp; + + /* the eip for i386 systems */ + uint32_t dha_eip; + + /* the dump registers */ + struct pt_regs dha_regs; + + /* smp specific */ + uint32_t dha_smp_num_cpus; + uint32_t dha_dumping_cpu; + struct pt_regs dha_smp_regs[NR_CPUS]; + uint32_t dha_smp_current_task[NR_CPUS]; + uint32_t dha_stack[NR_CPUS]; + uint32_t dha_stack_ptr[NR_CPUS]; +} __attribute__((packed)) dump_header_asm_i386_t; + +/* + * CPU specific part of dump_header_asm_t + */ +typedef struct dump_CPU_info_i386 { + struct pt_regs dha_smp_regs; + uint64_t dha_smp_current_task; + uint64_t dha_stack; + uint64_t dha_stack_ptr; +} __attribute__ ((packed)) dump_CPU_info_i386_t; + + +typedef struct __dump_header_asm_i386 dump_header_asm_t; +typedef struct dump_CPU_info_i386 dump_CPU_info_t; + + +#endif /* LKCD_DUMP_I386_H */ + --- /dev/null +++ b/lkcd_dump_ia64.c @@ -0,0 +1,35 @@ +/* lkcd_dump_x86_64.c + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#include <stdint.h> +#include <stddef.h> +#include <stdio.h> + +#define LKCD_COMMON +#include "defs.h" +#include "lkcd_dump_v8.h" +#include "lkcd_dump_ia64.h" + + +/* reads the load address value for IA64 */ + +int lkcd_dump_init_v8_ia64(int fd, dump_header_asm_t *dha) +{ + int ret; + + ret = read(fd, &dha->dha_kernel_addr, sizeof(dha->dha_kernel_addr)); + if (ret != sizeof(dha->dha_kernel_addr)) + return -1; + else + return 0; +} + --- /dev/null +++ b/lkcd_dump_ia64.h @@ -0,0 +1,81 @@ +/* lkcd_dump_ia64.h + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef LKCD_DUMP_IA64_H +#define LKCD_DUMP_IA64_H + +#define _ASM_IA64_FPU_H +#include <linux/ptrace.h> + +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_ASM_VERSION_NUMBER 0x5 /* version number */ + +/* + * Structure: dump_header_asm_t + * Function: This is the header for architecture-specific stuff. It + * follows right after the dump header. + */ +/*typedef struct _dump_header_asm {*/ + +typedef struct __dump_header_asm_ia64 { + + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; + + /* pointer to pt_regs, (OLD: (struct pt_regs *, NEW: (uint64_t)) */ + uint64_t dha_pt_regs; + + /* the dump registers */ + struct pt_regs dha_regs; + + /* the rnat register saved after flushrs */ + uint64_t dha_rnat; + + /* the pfs register saved after flushrs */ + uint64_t dha_pfs; + + /* the bspstore register saved after flushrs */ + uint64_t dha_bspstore; + + /* smp specific */ + uint32_t dha_smp_num_cpus; + uint32_t dha_dumping_cpu; + struct pt_regs dha_smp_regs[NR_CPUS]; + uint64_t dha_smp_current_task[NR_CPUS]; + uint64_t dha_stack[NR_CPUS]; + uint64_t dha_stack_ptr[NR_CPUS]; + + /* load address of kernel */ + uint64_t dha_kernel_addr; + +} __attribute__((packed)) dump_header_asm_ia64_t; + + +struct dump_CPU_info_ia64 { + struct pt_regs dha_smp_regs; + uint64_t dha_smp_current_task; + uint64_t dha_stack; + uint64_t dha_stack_ptr; +} __attribute__((packed)) dump_CPU_info_ia64_t; + +typedef struct dump_CPU_info_ia64 dump_CPU_info_t; +typedef struct __dump_header_asm_ia64 dump_header_asm_t; + +int lkcd_dump_init_v8_ia64(int fd, dump_header_asm_t *dha); + +#endif /* LKCD_DUMP_IA64_H */ --- /dev/null +++ b/lkcd_dump_ppc.h @@ -0,0 +1,67 @@ +/* lkcd_dump_ppc.h + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef LKCD_DUMP_PPC_H +#define LKCD_DUMP_PPC_H + +#include <linux/ptrace.h> + +/* from kernel include/asm-i386/dump.h */ +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_ASM_VERSION_NUMBER 0x5 /* version number */ + +/* + * Structure: __dump_header_asm + * Function: This is the header for architecture-specific stuff. It + * follows right after the dump header. + */ +struct __dump_header_asm_ppc { + + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; + + /* the dump registers */ + struct pt_regs dha_regs; + + /* smp specific */ + uint32_t dha_smp_num_cpus; + int dha_dumping_cpu; + struct pt_regs dha_smp_regs[NR_CPUS]; + uint64_t dha_smp_current_task[NR_CPUS]; + uint64_t dha_stack[NR_CPUS]; + uint64_t dha_stack_ptr[NR_CPUS]; +} __attribute__((packed)) dump_header_asm_ppc_t; + + +/* + * CPU specific part of dump_header_asm_t + */ +typedef struct dump_CPU_info_ppc { + struct pt_regs dha_smp_regs; + uint64_t dha_smp_current_task; + uint64_t dha_stack; + uint64_t dha_stack_ptr; +} __attribute__ ((packed)) dump_CPU_info_ppc_t; + + +typedef struct __dump_header_asm_ppc dump_header_asm_t; +typedef struct dump_CPU_info_ppc dump_CPU_info_t; + + +#endif /* LKCD_DUMP_PPC_H */ + --- a/lkcd_dump_v7.h +++ b/lkcd_dump_v7.h @@ -228,165 +228,20 @@ typedef struct lkcdinfo_s { } lkcdinfo_t; -#ifdef IA64 - -#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ - -struct pt_regs { - /* The following registers are saved by SAVE_MIN: */ - unsigned long b6; /* scratch */ - unsigned long b7; /* scratch */ - - unsigned long ar_csd; /* used by cmp8xchg16 (scratch) */ - unsigned long ar_ssd; /* reserved for future use (scratch) */ - - unsigned long r8; /* scratch (return value register 0) */ - unsigned long r9; /* scratch (return value register 1) */ - unsigned long r10; /* scratch (return value register 2) */ - unsigned long r11; /* scratch (return value register 3) */ - - unsigned long cr_ipsr; /* interrupted task's psr */ - unsigned long cr_iip; /* interrupted task's instruction pointer */ - unsigned long cr_ifs; /* interrupted task's function state */ - - unsigned long ar_unat; /* interrupted task's NaT register (preserved) */ - unsigned long ar_pfs; /* prev function state */ - unsigned long ar_rsc; /* RSE configuration */ - /* The following two are valid only if cr_ipsr.cpl > 0: */ - unsigned long ar_rnat; /* RSE NaT */ - unsigned long ar_bspstore; /* RSE bspstore */ - - unsigned long pr; /* 64 predicate registers (1 bit each) */ - unsigned long b0; /* return pointer (bp) */ - unsigned long loadrs; /* size of dirty partition << 16 */ - - unsigned long r1; /* the gp pointer */ - unsigned long r12; /* interrupted task's memory stack pointer */ - unsigned long r13; /* thread pointer */ - - unsigned long ar_fpsr; /* floating point status (preserved) */ - unsigned long r15; /* scratch */ - - /* The remaining registers are NOT saved for system calls. */ - - unsigned long r14; /* scratch */ - unsigned long r2; /* scratch */ - unsigned long r3; /* scratch */ - - /* The following registers are saved by SAVE_REST: */ - unsigned long r16; /* scratch */ - unsigned long r17; /* scratch */ - unsigned long r18; /* scratch */ - unsigned long r19; /* scratch */ - unsigned long r20; /* scratch */ - unsigned long r21; /* scratch */ - unsigned long r22; /* scratch */ - unsigned long r23; /* scratch */ - unsigned long r24; /* scratch */ - unsigned long r25; /* scratch */ - unsigned long r26; /* scratch */ - unsigned long r27; /* scratch */ - unsigned long r28; /* scratch */ - unsigned long r29; /* scratch */ - unsigned long r30; /* scratch */ - unsigned long r31; /* scratch */ - - unsigned long ar_ccv; /* compare/exchange value (scratch) */ - - /* - * Floating point registers that the kernel considers scratch: - */ - struct ia64_fpreg f6; /* scratch */ - struct ia64_fpreg f7; /* scratch */ - struct ia64_fpreg f8; /* scratch */ - struct ia64_fpreg f9; /* scratch */ - struct ia64_fpreg f10; /* scratch */ - struct ia64_fpreg f11; /* scratch */ -}; - /* - * Structure: dump_header_asm_t - * Function: This is the header for architecture-specific stuff. It - * follows right after the dump header. + * architecture specific data structures */ -typedef struct _dump_header_asm_s { - - /* the dump magic number -- unique to verify dump is valid */ - uint64_t dha_magic_number; - - /* the version number of this dump */ - uint32_t dha_version; - - /* the size of this header (in case we can't read it) */ - uint32_t dha_header_size; - - /* pointer to pt_regs */ - struct pt_regs *dha_pt_regs; - - /* the dump registers */ - struct pt_regs dha_regs; - - /* the rnat register saved after flushrs */ - uint64_t dha_rnat; - - /* the pfs register saved after flushrs */ - uint64_t dha_pfs; - - /* the bspstore register saved after flushrs */ - uint64_t dha_bspstore; - - /* smp specific */ - uint32_t dha_smp_num_cpus; - int dha_dumping_cpu; - struct pt_regs dha_smp_regs[NR_CPUS]; - void * dha_smp_current_task[NR_CPUS]; - void * dha_stack[NR_CPUS]; - void * dha_switch_stack[NR_CPUS]; - -} dump_header_asm_t; - -#define NR_CPUS 32 - -typedef struct _dump_header_asm_smp_s { - - /* the dump magic number -- unique to verify dump is valid */ - uint64_t dha_magic_number; - - /* the version number of this dump */ - uint32_t dha_version; - - /* the size of this header (in case we can't read it) */ - uint32_t dha_header_size; - - /* pointer to pt_regs */ - struct pt_regs *dha_pt_regs; - - /* the dump registers */ - struct pt_regs dha_regs; - - /* the rnat register saved after flushrs */ - uint64_t dha_rnat; - - /* the pfs register saved after flushrs */ - uint64_t dha_pfs; - - /* the bspstore register saved after flushrs */ - uint64_t dha_bspstore; - - /* smp specific */ - uint32_t dha_smp_num_cpus; - int dha_dumping_cpu; - struct pt_regs dha_smp_regs[NR_CPUS]; - void * dha_smp_current_task[NR_CPUS]; - void * dha_stack[NR_CPUS]; - void * dha_switch_stack[NR_CPUS]; - -} dump_header_asm_smp_t; - +#if defined(IA64) +# include "lkcd_dump_ia64.h" +#elif defined(X86_64) +# include "lkcd_dump_x86_64.h" +#elif defined(X86) +# include "lkcd_dump_i386.h" +#else +# error "Add support for your architecture here" #endif - #ifdef __KERNEL__ /* --- a/lkcd_dump_v8.h +++ b/lkcd_dump_v8.h @@ -235,4 +235,36 @@ typedef struct lkcdinfo_s { int stack_offset; } lkcdinfo_t; + +#if defined(IA64) + +# include "lkcd_dump_ia64.h" +# define get_lkcd_regs_for_cpu_arch(dha, cpu, eip, esp) \ + -1 + +#elif defined(X86_64) + +# include "lkcd_dump_x86_64.h" +# define get_lkcd_regs_for_cpu_arch(dha, cpu, eip, esp) \ + get_lkcd_regs_for_cpu_arch_x86_64(dha, cpu, eip, esp) + +#elif defined(X86) + +# include "lkcd_dump_i386.h" +# define get_lkcd_regs_for_cpu_arch(dha, cpu, eip, esp) \ + get_lkcd_regs_for_cpu_arch_i386(dha, cpu, eip, esp) + +#elif defined(PPC) || defined(PPC64) + +# include "lkcd_dump_ppc.h" +# define get_lkcd_regs_for_cpu_arch(dha, cpu, eip, esp) \ + -1 + +#else + +# define NO_LKCD_DUMP_ARCH 1 + +#endif + + #endif /* _DUMP_H */ --- /dev/null +++ b/lkcd_dump_x86_64.c @@ -0,0 +1,32 @@ +/* lkcd_dump_x86_64.c + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#include <stdint.h> +#include <stddef.h> +#include <stdio.h> + +#define LKCD_COMMON +#include "defs.h" +#include "lkcd_dump_v8.h" + + +int +get_lkcd_regs_for_cpu_arch_x86_64(dump_header_asm_t *dha, int cpu, ulong *eip, ulong *esp) +{ + if (eip) + *eip = dha->dha_smp_regs[cpu].rip; + if (esp) + *esp = dha->dha_smp_regs[cpu].rsp; + + return 0; +} + --- /dev/null +++ b/lkcd_dump_x86_64.h @@ -0,0 +1,71 @@ +/* lkcd_dump_x86_64.h + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ +#ifndef LKCD_DUMP_X86_64_H +#define LKCD_DUMP_X86_64_H + +#include <linux/ptrace.h> + +#define DUMP_HEADER_SIZE 0x100000 + + +/* from kernel include/asm-x86_64/dump.h */ + +/* definitions */ +#define DUMP_ASM_MAGIC_NUMBER 0xdeaddeadULL /* magic number */ +#define DUMP_ASM_VERSION_NUMBER 0x2 /* version number */ + + +/* + * Structure: dump_header_asm_t + * Function: This is the header for architecture-specific stuff. It + * follows right after the dump header. + */ +typedef struct __dump_header_asm_x86_64 { + + /* the dump magic number -- unique to verify dump is valid */ + uint64_t dha_magic_number; + + /* the version number of this dump */ + uint32_t dha_version; + + /* the size of this header (in case we can't read it) */ + uint32_t dha_header_size; + + /* the dump registers */ + struct pt_regs dha_regs; + + /* smp specific */ + uint32_t dha_smp_num_cpus; + int dha_dumping_cpu; + struct pt_regs dha_smp_regs[NR_CPUS]; + uint64_t dha_smp_current_task[NR_CPUS]; + uint64_t dha_stack[NR_CPUS]; + uint64_t dha_stack_ptr[NR_CPUS]; +} __attribute__((packed)) dump_header_asm_t_x86_64; + + +/* + * CPU specific part of dump_header_asm_t + */ +typedef struct dump_CPU_info_x86_64 { + struct pt_regs dha_smp_regs; + uint64_t dha_smp_current_task; + uint64_t dha_stack; + uint64_t dha_stack_ptr; +} __attribute__ ((packed)) dump_CPU_info_x86_64_t; + +typedef struct dump_CPU_info_x86_64 dump_CPU_info_t; +typedef struct __dump_header_asm_x86_64 dump_header_asm_t; + +#endif /* LKCD_DUMP_X86_64_H */ + --- a/lkcd_fix_mem.c +++ b/lkcd_fix_mem.c @@ -25,16 +25,8 @@ static int fix_addr(dump_header_asm_t *); int -fix_addr_v8(int fd) +fix_addr_v8(dump_header_asm_t *dha) { - static dump_header_asm_t dump_header_asm_v8 = { 0 }; - dump_header_asm_t *dha; - dha = &dump_header_asm_v8; - - if (read(lkcd->fd, dha, sizeof(dump_header_asm_t)) != - sizeof(dump_header_asm_t)) - return -1; - fix_addr(dha); return 0; @@ -59,14 +51,6 @@ fix_addr_v7(int fd) static int fix_addr(dump_header_asm_t *dha) { - - - if (dha->dha_header_size != sizeof(dump_header_asm_t)) { - error(INFO, "LKCD machine specific dump header doesn't match crash version\n"); - error(INFO, "traceback of currently executing threads may not work\n\n"); - } - - lkcd->dump_header_asm = dha; --- a/lkcd_v8.c +++ b/lkcd_v8.c @@ -19,15 +19,120 @@ */ #define LKCD_COMMON +#include <stddef.h> #include "defs.h" #include "lkcd_dump_v8.h" /* REMIND */ static dump_header_t dump_header_v8 = { 0 }; -// static dump_header_asm_t dump_header_asm_v8 = { 0 }; +#ifndef NO_LKCD_DUMP_ARCH +static dump_header_asm_t dump_header_asm_v8 = { 0 }; +#endif static dump_page_t dump_page = { 0 }; static void mclx_cache_page_headers_v8(void); static off_t lkcd_offset_to_first_page = LKCD_OFFSET_TO_FIRST_PAGE; +#define STR(x) #x + +#ifndef NO_LKCD_DUMP_ARCH +int +lkcd_dump_init_v8_arch(dump_header_t *dh, dump_header_asm_t *dha) +{ + off_t ret_of; + ssize_t ret_sz; + uint32_t hdr_size, offset, nr_cpus; + dump_header_asm_t arch_hdr; + char *hdr_buf = NULL; + + ret_of = lseek(lkcd->fd, dh->dh_header_size + + offsetof(dump_header_asm_t, dha_header_size), + SEEK_SET); + if (ret_of < 0) { + perror("lseek failed in " __FILE__ ":" STR(__LINE__)); + goto err; + } + + ret_sz = read(lkcd->fd, (char *)&hdr_size, sizeof(hdr_size)); + if (ret_sz != sizeof(hdr_size)) { + perror("Reading hdr_size failed in " __FILE__ ":" STR(__LINE__)); + goto err; + } + + ret_of = lseek(lkcd->fd, dh->dh_header_size, SEEK_SET); + if (ret_of < 0) { + perror("lseek failed in " __FILE__ ":" STR(__LINE__)); + goto err; + } + + hdr_buf = (char *)malloc(hdr_size); + if (!hdr_buf) { + perror("Could not allocate memory for dump header\n"); + goto err; + } + + ret_sz = read(lkcd->fd, (char *)hdr_buf, hdr_size); + if (ret_sz != hdr_size) { + perror("Could not read header " __FILE__ ":" STR(__LINE__)); + goto err; + } + + + /* + * Though we have KL_NR_CPUS is 128, the header size is different + * CONFIG_NR_CPUS might be different in the kernel. Hence, need + * to find out how many CPUs are configured. + */ + offset = offsetof(dump_header_asm_t, dha_smp_regs[0]); + nr_cpus = (hdr_size - offset) / sizeof(dump_CPU_info_t); + + /* check for CPU overflow */ + if (nr_cpus > NR_CPUS) { + fprintf(stderr, "CPU number too high %d (%s:%s)\n", + nr_cpus, __FILE__, __LINE__); + goto err; + } + + /* parts that don't depend on the number of CPUs */ + memcpy(&arch_hdr, (void *)hdr_buf, offset); + + /* registers */ + memcpy(&arch_hdr.dha_smp_regs, (void *)&hdr_buf[offset], + nr_cpus * sizeof(struct pt_regs)); + offset += nr_cpus * sizeof(struct pt_regs); + + /* current task */ + memcpy(&arch_hdr.dha_smp_current_task, (void *)&hdr_buf[offset], + nr_cpus * sizeof(&arch_hdr.dha_smp_current_task[0])); + offset += nr_cpus * sizeof(&arch_hdr.dha_smp_current_task[0]); + + /* stack */ + memcpy(&arch_hdr.dha_stack, (void *)&hdr_buf[offset], + nr_cpus * sizeof(&arch_hdr.dha_stack[0])); + offset += nr_cpus * sizeof(&arch_hdr.dha_stack[0]); + + /* stack_ptr */ + memcpy(&arch_hdr.dha_stack_ptr, (void *)&hdr_buf[offset], + nr_cpus * sizeof(&arch_hdr.dha_stack_ptr[0])); + offset += nr_cpus * sizeof(&arch_hdr.dha_stack_ptr[0]); + + if (arch_hdr.dha_magic_number != DUMP_ASM_MAGIC_NUMBER) { + fprintf(stderr, "Invalid magic number for x86_64\n"); + goto err; + } + +#ifdef IA64 + lkcd_dump_init_v8_ia64(lkcd->fd, &arch_hdr); +#endif + + memcpy(dha, &arch_hdr, sizeof(dump_header_asm_t)); + + return 0; + +err: + free(hdr_buf); + return -1; +} +#endif + /* * Verify and initialize the LKCD environment, storing the common data * in the global lkcd_environment structure. @@ -69,8 +174,16 @@ lkcd_dump_init_v8(FILE *fp, int fd, char lkcd->dump_header = dh; if (lkcd->debug) dump_lkcd_environment(LKCD_DUMP_HEADER_ONLY); + +#ifndef NO_LKCD_DUMP_ARCH + if (lkcd_dump_init_v8_arch(dh, &dump_header_asm_v8) != 0) { + fprintf(stderr, "Warning: Failed to initialise " + "arch specific dump code\n"); + } +#endif + #ifdef IA64 - if ( (fix_addr_v8(fd) == -1) ) + if ( (fix_addr_v8(&dump_header_asm_v8) == -1) ) return FALSE; #endif @@ -233,6 +346,29 @@ lkcd_dump_init_v8(FILE *fp, int fd, char return TRUE; } +int +get_lkcd_regs_for_cpu(struct bt_info *bt, ulong *eip, ulong *esp) +{ + int cpu; + + if (!bt || !bt->tc) { + fprintf(stderr, "get_lkcd_regs_for_cpu: invalid tc\n", cpu); + return -EINVAL; + } + + cpu = bt->tc->processor; + + if (cpu >= NR_CPUS) { + fprintf(stderr, "get_lkcd_regs_for_cpu, cpu (%d) too high\n", cpu); + return -EINVAL; + } + +#ifndef NO_LKCD_DUMP_ARCH + return get_lkcd_regs_for_cpu_arch(&dump_header_asm_v8, cpu, eip, esp); +#else + return -ENOSYS; +#endif +} /* * Return the current page's dp_size.