Currently, gdb passthroughs of 'bt', 'frame', 'up', 'down', 'info locals' don't work. This is due to gdb not knowing the register values to unwind the stack frames Every gdb passthrough goes through `gdb_interface`. And then, gdb expects `crash_target::fetch_registers` to give it the register values, which is dependent on `machdep->get_cpu_reg` to read the register values for specific architecture. ┌────────────────────────┐ gdb passthrough (eg. "bt") │ │ crash ─────────────────────────▶│ │ │ gdb_interface │ │ │ │ │ │ ┌────────────────────┐ │ fetch_registers │ │ │ │ crash_target◀────────────────────────┼─┤ gdb │ │ ─────────────────────────┼▶│ │ │ Registers (SP,NIP, etc.)│ │ │ │ │ │ │ │ │ └────────────────────┘ │ └────────────────────────┘ Implement `machdep->get_cpu_reg` on PPC64, so that crash provides the register values to gdb to unwind stack frames properly Also, with the goal to preserve the behaviour of gdb passthroughs in default mode, a hook 'machdep->gdb_mode_hook' has been introduced, which will get executed everytime when "set gdb on", and "set gdb off" are run, and can be used by any architecture. This hook has been used on PPC64 such that, `machdep->get_cpu_reg` is only set on "set gdb on", and set to NULL in default mode (or on "set gdb off"), so that behaviour of gdb passthroughs in default mode stays the same. Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- defs.h | 123 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ppc64.c | 100 +++++++++++++++++++++++++++++++++++++++++++++ tools.c | 12 ++++-- 3 files changed, 232 insertions(+), 3 deletions(-) diff --git a/defs.h b/defs.h index b6f213120975..798a49e7ec41 100644 --- a/defs.h +++ b/defs.h @@ -1074,6 +1074,7 @@ struct machdep_table { void (*show_interrupts)(int, ulong *); int (*is_page_ptr)(ulong, physaddr_t *); int (*get_cpu_reg)(int, int, const char *, int, void *); + void (*gdb_mode_hook)(int gdb_mode_enabled); }; /* @@ -6660,6 +6661,8 @@ struct machine_specific { void ppc64_init(int); void ppc64_dump_machdep_table(ulong); +int ppc64_get_cpu_reg(int cpu, int regno, const char *name, int size, + void *value); #define display_idt_table() \ error(FATAL, "-d option is not applicable to PowerPC architecture\n") #define KSYMS_START (0x1) @@ -7839,4 +7842,124 @@ enum x86_64_regnum { LAST_REGNUM }; +/* + * Register numbers to make crash_target->fetch_registers() + * ---> machdep->get_cpu_reg() work properly. + * + * These register numbers and names are given according to output of + * `rs6000_register_name`, because that is what was being used by + * crash_target::fetch_registers in case of PPC64 + */ +enum ppc64_renum { + PPC64_R0_REGNUM = 0, + PPC64_R1_REGNUM, + PPC64_R2_REGNUM, + PPC64_R3_REGNUM, + PPC64_R4_REGNUM, + PPC64_R5_REGNUM, + PPC64_R6_REGNUM, + PPC64_R7_REGNUM, + PPC64_R8_REGNUM, + PPC64_R9_REGNUM, + PPC64_R10_REGNUM, + PPC64_R11_REGNUM, + PPC64_R12_REGNUM, + PPC64_R13_REGNUM, + PPC64_R14_REGNUM, + PPC64_R15_REGNUM, + PPC64_R16_REGNUM, + PPC64_R17_REGNUM, + PPC64_R18_REGNUM, + PPC64_R19_REGNUM, + PPC64_R20_REGNUM, + PPC64_R21_REGNUM, + PPC64_R22_REGNUM, + PPC64_R23_REGNUM, + PPC64_R24_REGNUM, + PPC64_R25_REGNUM, + PPC64_R26_REGNUM, + PPC64_R27_REGNUM, + PPC64_R28_REGNUM, + PPC64_R29_REGNUM, + PPC64_R30_REGNUM, + PPC64_R31_REGNUM, + + PPC64_F0_REGNUM = 32, + PPC64_F1_REGNUM, + PPC64_F2_REGNUM, + PPC64_F3_REGNUM, + PPC64_F4_REGNUM, + PPC64_F5_REGNUM, + PPC64_F6_REGNUM, + PPC64_F7_REGNUM, + PPC64_F8_REGNUM, + PPC64_F9_REGNUM, + PPC64_F10_REGNUM, + PPC64_F11_REGNUM, + PPC64_F12_REGNUM, + PPC64_F13_REGNUM, + PPC64_F14_REGNUM, + PPC64_F15_REGNUM, + PPC64_F16_REGNUM, + PPC64_F17_REGNUM, + PPC64_F18_REGNUM, + PPC64_F19_REGNUM, + PPC64_F20_REGNUM, + PPC64_F21_REGNUM, + PPC64_F22_REGNUM, + PPC64_F23_REGNUM, + PPC64_F24_REGNUM, + PPC64_F25_REGNUM, + PPC64_F26_REGNUM, + PPC64_F27_REGNUM, + PPC64_F28_REGNUM, + PPC64_F29_REGNUM, + PPC64_F30_REGNUM, + PPC64_F31_REGNUM, + + PPC64_PC_REGNUM = 64, + PPC64_MSR_REGNUM = 65, + PPC64_CR_REGNUM = 66, + PPC64_LR_REGNUM = 67, + PPC64_CTR_REGNUM = 68, + PPC64_XER_REGNUM = 69, + PPC64_FPSCR_REGNUM = 70, + + PPC64_VR0_REGNUM = 106, + PPC64_VR1_REGNUM, + PPC64_VR2_REGNUM, + PPC64_VR3_REGNUM, + PPC64_VR4_REGNUM, + PPC64_VR5_REGNUM, + PPC64_VR6_REGNUM, + PPC64_VR7_REGNUM, + PPC64_VR8_REGNUM, + PPC64_VR9_REGNUM, + PPC64_VR10_REGNUM, + PPC64_VR11_REGNUM, + PPC64_VR12_REGNUM, + PPC64_VR13_REGNUM, + PPC64_VR14_REGNUM, + PPC64_VR15_REGNUM, + PPC64_VR16_REGNUM, + PPC64_VR17_REGNUM, + PPC64_VR18_REGNUM, + PPC64_VR19_REGNUM, + PPC64_VR20_REGNUM, + PPC64_VR21_REGNUM, + PPC64_VR22_REGNUM, + PPC64_VR23_REGNUM, + PPC64_VR24_REGNUM, + PPC64_VR25_REGNUM, + PPC64_VR26_REGNUM, + PPC64_VR27_REGNUM, + PPC64_VR28_REGNUM, + PPC64_VR29_REGNUM, + PPC64_VR30_REGNUM, + PPC64_VR31_REGNUM, + + PPC64_VSCR_REGNUM = 138, + PPC64_VRSAVE_REGNU = 139 +}; + #endif /* !GDB_COMMON */ diff --git a/ppc64.c b/ppc64.c index 7622f68289e7..61ff47c2c8d9 100644 --- a/ppc64.c +++ b/ppc64.c @@ -55,6 +55,8 @@ static void ppc64_set_bt_emergency_stack(enum emergency_stack_type type, static char * ppc64_check_eframe(struct ppc64_pt_regs *); static void ppc64_print_eframe(char *, struct ppc64_pt_regs *, struct bt_info *); +int ppc64_get_cpu_reg(int cpu, int regno, const char *name, int size, + void *value); static void parse_cmdline_args(void); static int ppc64_paca_percpu_offset_init(int); static void ppc64_init_cpu_info(void); @@ -63,6 +65,7 @@ static void ppc64_clear_machdep_cache(void); static void ppc64_init_paca_info(void); static void ppc64_vmemmap_init(void); static int ppc64_get_kvaddr_ranges(struct vaddr_range *); +static void ppc64_gdb_mode_hook(int gdb_mode_enabled); static uint get_ptetype(ulong pte); static int is_hugepage(ulong pte); static int is_hugepd(ulong pte); @@ -140,6 +143,15 @@ static inline int is_hugepd(ulong pte) } } +static void ppc64_gdb_mode_hook(int gdb_mode_enabled) +{ + if (gdb_mode_enabled) { + machdep->get_cpu_reg = ppc64_get_cpu_reg; + } else { + machdep->get_cpu_reg = NULL; + } +} + static inline uint get_ptetype(ulong pte) { uint pte_type = 0; /* 0: regular entry; 1: huge pte; 2: huge pd */ @@ -694,6 +706,8 @@ ppc64_init(int when) error(FATAL, "cannot malloc hwirqstack buffer space."); } + machdep->gdb_mode_hook = ppc64_gdb_mode_hook; + ppc64_init_paca_info(); if (!machdep->hz) { @@ -2472,6 +2486,92 @@ ppc64_print_eframe(char *efrm_str, struct ppc64_pt_regs *regs, ppc64_print_nip_lr(regs, 1); } +int +ppc64_get_cpu_reg(int cpu, int regno, const char *name, int size, + void *value) +{ + struct bt_info bt_info, bt_setup; + struct task_context *tc; + struct ppc64_pt_regs *pt_regs; + ulong ip, sp; + + /* Currently only handling registers available in pt_regs: + * + * 0-31: r0-r31 + * 64: pc/nip + * 65: msr + * + * 67: lr + * 68: ctr + */ + switch (regno) { + case PPC64_R0_REGNUM ... PPC64_R31_REGNUM: + + case PPC64_PC_REGNUM: + case PPC64_MSR_REGNUM: + case PPC64_LR_REGNUM: + case PPC64_CTR_REGNUM: + break; + + default: + // return false if we can't get that register + return FALSE; + } + + /* FIXME: Always setting the context to CURRENT_CONTEXT irrespective of whicher + * thread we switched to, in gdb + */ + tc = CURRENT_CONTEXT(); + BZERO(&bt_setup, sizeof(struct bt_info)); + clone_bt_info(&bt_setup, &bt_info, tc); + fill_stackbuf(&bt_info); + + // reusing the get_dumpfile_regs function to get pt regs structure + get_dumpfile_regs(&bt_info, &sp, &ip); + pt_regs = (struct ppc64_pt_regs *)bt_info.machdep; + + switch (regno) { + case PPC64_R0_REGNUM ... PPC64_R31_REGNUM: + if (size != sizeof(pt_regs->gpr[regno])) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->gpr[regno], size); + return TRUE; + + case PPC64_PC_REGNUM: + if (size != sizeof(pt_regs->nip)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->nip, size); + return TRUE; + + case PPC64_MSR_REGNUM: + if (size != sizeof(pt_regs->msr)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->msr, size); + return TRUE; + + case PPC64_LR_REGNUM: + if (size != sizeof(pt_regs->link)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->link, size); + return TRUE; + + case PPC64_CTR_REGNUM: + if (size != sizeof(pt_regs->ctr)) + return FALSE; // size mismatch + + memcpy(value, &pt_regs->ctr, size); + return TRUE; + } + + printf("error: %s: statement after switch case should be unreachable" + , __func__); + return FALSE; +} + /* * For vmcore typically saved with KDump or FADump, get SP and IP values * from the saved ptregs. diff --git a/tools.c b/tools.c index 0f2db108838a..b8081f350ae9 100644 --- a/tools.c +++ b/tools.c @@ -2075,12 +2075,18 @@ cmd_set(void) if (!runtime) defer(); else if (STREQ(args[optind], "on")) { - if (pc->flags & MINIMAL_MODE) + if (pc->flags & MINIMAL_MODE) { goto invalid_set_command; - else + } else { pc->flags2 |= GDB_CMD_MODE; - } else if (STREQ(args[optind], "off")) + if (machdep->gdb_mode_hook) + machdep->gdb_mode_hook(1); + } + } else if (STREQ(args[optind], "off")) { pc->flags2 &= ~GDB_CMD_MODE; + if (machdep->gdb_mode_hook) + machdep->gdb_mode_hook(0); + } else if (IS_A_NUMBER(args[optind])) { value = stol(args[optind], FAULT_ON_ERROR, NULL); -- 2.41.0

In few cases, the backtrace shown by crash (in default mode), can be different than the backtrace shown by gdb (ie. in gdb mode), due to different implementations (on PPC64, crash uses backchains/framepointer, while gdb uses debuginfo, to unwind) Example, in "crash mode", 'bt' might print these frames: ------ A1 A2 C1 ------ While, in "gdb mode", 'bt' might print: ------ A1 B1 <--- extra inline frame A2 C1 ------ This can cause confusion, since 'bt' is implemented in crash, while 'frame'/'up'/'down' are gdb passthroughs. So 'frame' might show frame 'B1' at level #1, which isn't even there in the backtrace crash shows Implement 'frame', 'up', 'down' in crash ("default mode"), which any architecture can support by implementing both of these functions: 1. 'machdep->print_stack_frame': to print any arbitrary frame, identified by the frame level 2. 'machdep->is_frame_num_valid': to check if frame level is valid This patch implements these machdep functions for powerpc64 This has an implication on other architectures that in default mode, 'frame','up','down' might show "command not supported" Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- defs.h | 10 ++++ global_data.c | 3 + help.c | 34 ++++++++++++ kernel.c | 150 ++++++++++++++++++++++++++++++++++++++++++++++++++ ppc64.c | 145 ++++++++++++++++++++++++++++++++++++++++++++++++ task.c | 1 + 6 files changed, 343 insertions(+) diff --git a/defs.h b/defs.h index 798a49e7ec41..198e805db119 100644 --- a/defs.h +++ b/defs.h @@ -828,6 +828,7 @@ struct kernel_table { /* kernel data */ struct task_context { /* context stored for each task */ ulong task; ulong thread_info; + int frame_num; ulong pid; char comm[TASK_COMM_LEN+1]; int processor; @@ -921,6 +922,7 @@ struct task_table { /* kernel/local task table data */ #define CURRENT_TASK() (tt->current->task) #define CURRENT_PID() (tt->current->pid) #define CURRENT_COMM() (tt->current->comm) +#define CURRENT_FRAME() (tt->current->frame_num) #define RUNNING_TASKS() (tt->running_tasks) #define FIRST_CONTEXT() (tt->context_array) @@ -1021,6 +1023,8 @@ struct machdep_table { uint64_t memsize; int (*eframe_search)(struct bt_info *); void (*back_trace)(struct bt_info *); + void (*print_stack_frame)(int frame_num, struct bt_info *bt); + int (*is_frame_num_valid)(int frame_num, struct bt_info *bt); ulong (*processor_speed)(void); int (*uvtop)(struct task_context *, ulong, physaddr_t *, int); int (*kvtop)(struct task_context *, ulong, physaddr_t *, int); @@ -5310,11 +5314,14 @@ void cmd_runq(void); /* task.c */ void cmd_sig(void); /* task.c */ void cmd_bt(void); /* kernel.c */ void cmd_dis(void); /* kernel.c */ +void cmd_down(void); /* kernel.c */ +void cmd_frame(void); /* kernel.c */ void cmd_mod(void); /* kernel.c */ void cmd_log(void); /* kernel.c */ void cmd_sys(void); /* kernel.c */ void cmd_irq(void); /* kernel.c */ void cmd_timer(void); /* kernel.c */ +void cmd_up(void); /* kernel.c */ void cmd_waitq(void); /* kernel.c */ void cmd_sym(void); /* symbols.c */ void cmd_struct(void); /* symbols.c */ @@ -5884,9 +5891,11 @@ extern char *help_alias[]; extern char *help_ascii[]; extern char *help_bpf[]; extern char *help_bt[]; +extern char *help_frame[]; extern char *help_btop[]; extern char *help_dev[]; extern char *help_dis[]; +extern char *help_down[]; extern char *help_eval[]; extern char *help_exit[]; extern char *help_extend[]; @@ -5925,6 +5934,7 @@ extern char *help_sys[]; extern char *help_task[]; extern char *help_timer[]; extern char *help_union[]; +extern char *help_up[]; extern char *help_vm[]; extern char *help_vtop[]; extern char *help_waitq[]; diff --git a/global_data.c b/global_data.c index f9bb7d079f51..bb8282e50c43 100644 --- a/global_data.c +++ b/global_data.c @@ -77,11 +77,13 @@ struct command_table_entry linux_command_table[] = { {"btop", cmd_btop, help_btop, 0}, {"dev", cmd_dev, help_dev, 0}, {"dis", cmd_dis, help_dis, MINIMAL}, + {"down", cmd_down, help_down, REFRESH_TASK_TABLE}, {"eval", cmd_eval, help_eval, MINIMAL}, {"exit", cmd_quit, help_exit, MINIMAL}, {"extend", cmd_extend, help_extend, MINIMAL}, {"files", cmd_files, help_files, REFRESH_TASK_TABLE}, {"foreach", cmd_foreach, help_foreach, REFRESH_TASK_TABLE}, + {"frame", cmd_frame, help_frame, REFRESH_TASK_TABLE}, {"fuser", cmd_fuser, help_fuser, REFRESH_TASK_TABLE}, {"gdb", cmd_gdb, help_gdb, REFRESH_TASK_TABLE}, {"help", cmd_help, help_help, MINIMAL}, @@ -116,6 +118,7 @@ struct command_table_entry linux_command_table[] = { {"task", cmd_task, help_task, REFRESH_TASK_TABLE}, {"test", cmd_test, NULL, HIDDEN_COMMAND}, {"timer", cmd_timer, help_timer, 0}, + {"up", cmd_up, help_up, REFRESH_TASK_TABLE}, {"union", cmd_union, help_union, 0}, {"vm", cmd_vm, help_vm, REFRESH_TASK_TABLE}, {"vtop", cmd_vtop, help_vtop, REFRESH_TASK_TABLE}, diff --git a/help.c b/help.c index cc7ab20e343e..a289ece93833 100644 --- a/help.c +++ b/help.c @@ -2476,6 +2476,40 @@ char *help_extend[] = { NULL }; +char *help_frame[] = { +"frame", +"Select and print a stack frame.", +"[-f|-F|-l] [frame_number]", +"If no argument[s] passed, print the current stack frame.", +"A single numerical argument specifies the frame number to select", +" -f display all stack data contained in a frame", +" -F[F] similar to -f, except that the stack data is displayed symbolically", +" when appropriate; if the stack data references a slab cache object,", +" the name of the slab cache will be displayed in brackets; on ia64,", +" the substitution is done to the argument register contents.", +" If -F is entered twice, and the stack data references a slab", +" object, both the address and the name of the slab cache will be", +" displayed in brackets.", +" -l show file and line number of stack trace text location.", +NULL +}; + +char *help_up[] = { +"up", +"Select and print stack frame that called this one.", +"[number_of_frames]", +"Can be used to move between frames. Optionally takes number of frames to go up.", +NULL +}; + +char *help_down[] = { +"down", +"Select and print stack frame called by this one.", +"[number_of_frames]", +"Can be used to move between frames. Optionally takes number of frames to go down.", +NULL +}; + char *help_mach[] = { "mach", "machine specific data", diff --git a/kernel.c b/kernel.c index e6920e241c4e..a7dd32dd21a1 100644 --- a/kernel.c +++ b/kernel.c @@ -22,6 +22,7 @@ #include <libgen.h> #include <ctype.h> #include <stdbool.h> +#include <stdlib.h> #include "xendump.h" #if defined(GDB_7_6) || defined(GDB_10_2) #define __CONFIG_H__ 1 @@ -3547,6 +3548,155 @@ get_dumpfile_regs(struct bt_info *bt, ulong *eip, ulong *esp) bt->stkptr = *esp; } +/* + * Get registers including EIP, ESP, and pass on to machine-specific + * is_frame_num_valid command + */ +static int +is_frame_num_valid(int frame_num) +{ + struct bt_info bt_info, bt_setup = { 0 }; + ulong ip, sp; + + clone_bt_info(&bt_setup, &bt_info, CURRENT_CONTEXT()); + + if (frame_num < 0) + return FALSE; + + // fill kernel stack into a buffer + fill_stackbuf(&bt_info); + + get_dumpfile_regs(&bt_info, &ip, &sp); + + return machdep->is_frame_num_valid(frame_num, &bt_info); +} + +/* + * Get registers including EIP, ESP, and pass on to machine-specific + * print_stack_frame + */ +void +print_current_frame(ulonglong bt_flags) +{ + struct bt_info bt_info, bt_setup = { 0 }; + struct task_context *tc; + ulong ip, sp; + + tc = CURRENT_CONTEXT(); + clone_bt_info(&bt_setup, &bt_info, tc); + + bt_info.flags |= bt_flags; + fill_stackbuf(&bt_info); + get_dumpfile_regs(&bt_info, &sp, &ip); + + machdep->print_stack_frame(CURRENT_FRAME(), &bt_info); +} + +void +cmd_frame(void) +{ + struct task_context *tc; + int frame_num; + int c; + ulonglong bt_flags = 0; + + // If these functions are not defined by arch-specific init code, return early + if (!machdep->print_stack_frame || !machdep->is_frame_num_valid) { + command_not_supported(); + return; + } + + while ((c = getopt(argcnt, args, "fFl")) != EOF) { + switch (c) { + case 'f': + bt_flags |= BT_FULL; + break; + case 'F': + if (bt_flags & BT_FULL_SYM_SLAB) // is 'F' repeated multiple times + bt_flags |= BT_FULL_SYM_SLAB2; + else + bt_flags |= (BT_FULL | BT_FULL_SYM_SLAB); + break; + case 'l': + if (NO_LINE_NUMBERS()) + error(INFO, "line numbers are not available\n"); + else + bt_flags |= BT_LINE_NUMBERS; + break; + default: + argerrs++; + break; + }; + + if (argerrs) + cmd_usage(pc->curcmd, SYNOPSIS); + } + + tc = CURRENT_CONTEXT(); + + /* purpose of using args[optind] is to allow passing frame number and + * options in any order + */ + if (args[optind]) { + frame_num = strtol(args[optind], NULL, 10); + if (!is_frame_num_valid(frame_num)) { + error(FATAL, "Passed frame number is invalid."); + return; + } + + tc->frame_num = frame_num; + } + + print_current_frame(bt_flags); +} + +void +cmd_up(void) +{ + struct task_context *tc; + int frame_num; + + if (!machdep->print_stack_frame || !machdep->is_frame_num_valid) { + command_not_supported(); + return; + } + tc = CURRENT_CONTEXT(); + if (args[optind + 1]) + frame_num = CURRENT_FRAME() + strtol(args[optind + 1], NULL, 10); + else + frame_num = CURRENT_FRAME() + 1; + if (!is_frame_num_valid(frame_num)) { + error(FATAL, "Initial frame selected; you cannot go up."); + return; + } + + tc->frame_num = frame_num; + print_current_frame(0); +} + +void +cmd_down(void) +{ + struct task_context *tc; + int frame_num; + + if (!machdep->print_stack_frame) { + command_not_supported(); + return; + } + tc = CURRENT_CONTEXT(); + if (args[optind + 1]) + frame_num = CURRENT_FRAME() - strtol(args[optind + 1], NULL, 10); + else + frame_num = CURRENT_FRAME() - 1; + if (CURRENT_FRAME() <= 0) { + error(INFO, "Bottom (innermost) frame selected; you cannot go down."); + return; + } + + tc->frame_num = frame_num; + print_current_frame(0); +} /* * Store the head of the kernel module list for future use. diff --git a/ppc64.c b/ppc64.c index 61ff47c2c8d9..dd5549ed9ecf 100644 --- a/ppc64.c +++ b/ppc64.c @@ -33,6 +33,8 @@ static int ppc64_eframe_search(struct bt_info *); static void ppc64_back_trace_cmd(struct bt_info *); static void ppc64_back_trace(struct gnu_request *, struct bt_info *); static void get_ppc64_frame(struct bt_info *, ulong *, ulong *); +static int ppc64_is_frame_num_valid(int, struct bt_info *); +static void ppc64_print_stack_frame(int, struct bt_info *); static void ppc64_print_stack_entry(int,struct gnu_request *, ulong, ulong, struct bt_info *); static void ppc64_dump_irq(int); @@ -395,6 +397,8 @@ ppc64_init(int when) machdep->is_uvaddr = generic_is_uvaddr; machdep->eframe_search = ppc64_eframe_search; machdep->back_trace = ppc64_back_trace_cmd; + machdep->print_stack_frame = ppc64_print_stack_frame; + machdep->is_frame_num_valid = ppc64_is_frame_num_valid; machdep->processor_speed = ppc64_processor_speed; machdep->uvtop = ppc64_uvtop; machdep->kvtop = ppc64_kvtop; @@ -2262,6 +2266,147 @@ ppc64_display_full_frame(struct bt_info *bt, ulong nextsp, FILE *ofp) fprintf(ofp, "\n"); } +/* Check whether a frame number is valid + */ +static int +ppc64_is_frame_num_valid(int frame_num, struct bt_info *bt) +{ + ulong sp = bt->stkptr; + + while (frame_num-- > 0) { + sp = *(ulong *)&bt->stackbuf[sp - bt->stackbase]; + + if (!INSTACK(sp, bt)) + return FALSE; + } + + return TRUE; +} + +/* Prints one frame, identified by the frame_num, where frame_num=0 is the + * innermost frame (first frame in backtrace) + * + * It gets the `pc` and `sp` and finally calls `ppc64_print_stack_entry` + */ +static void +ppc64_print_stack_frame(int frame_num, struct bt_info *bt) +{ + struct gnu_request req = { 0 }; + ulong newpc = 0, newsp; + ulong eframe_lr = 0; + int eframe_found, marker; + enum emergency_stack_type estype; + int c = bt->tc->processor; + ulong nmi_sp = 0; + + req.task = bt->task; + + req.pc = bt->instptr; + req.sp = bt->stkptr; + + int cnt = frame_num; + + newsp = req.sp; + newpc = req.pc; + + while (cnt-- >= 0) { + req.sp = newsp; + req.pc = newpc; + + newsp = *(ulong *)&bt->stackbuf[newsp - bt->stackbase]; + + if (!INSTACK(req.sp, bt)) { + error(FATAL, + "%s: current frame numberx (%d) is not valid (likely more than number of frames available)", + __func__, frame_num); + return; + } + + // rest of the loop is copied from ppc64_back_trace, focused on updating req.pc + if (IS_KVADDR(newsp)) { + /* + * In 2.4, HW interrupt stack will be used to save + * smp_call_functions symbols. i.e, when the dumping + * CPU is issued IPI call to freeze other CPUS, + */ + if (INSTACK(newsp, bt) && (newsp + 16 > bt->stacktop)) + newsp = + *(ulong *)&bt->stackbuf[newsp - bt->stackbase]; + if (!INSTACK(newsp, bt)) { + estype = ppc64_in_emergency_stack(c, newsp, true); + if (estype) { + if (!nmi_sp && estype == NMI_EMERGENCY_STACK) + nmi_sp = newsp; + ppc64_set_bt_emergency_stack(estype, bt); + } else { + /* + * Switch HW interrupt stack or emergency stack + * to process's stack. + */ + bt->stackbase = GET_STACKBASE(bt->task); + bt->stacktop = GET_STACKTOP(bt->task); + alter_stackbuf(bt); + } + } + + if (IS_KVADDR(newsp) && INSTACK(newsp, bt)) + newpc = *(ulong *)&bt->stackbuf[newsp + 16 - + bt->stackbase]; + } + + if (BT_REFERENCE_FOUND(bt)) + return; + + eframe_found = FALSE; + /* + * Is this frame an exception one? + * In 2.6, 0x7265677368657265 is saved and used + * to determine the exception frame. + */ + if (THIS_KERNEL_VERSION < LINUX(2, 6, 0)) { + if (frame_num && (newsp - req.sp - STACK_FRAME_OVERHEAD) >= + sizeof(struct ppc64_pt_regs)) + eframe_found = TRUE; + else if (STREQ(req.name, ".ret_from_except")) + eframe_found = TRUE; + } else if ((newsp - req.sp - STACK_FRAME_OVERHEAD) >= + sizeof(struct ppc64_pt_regs)) { + readmem(req.sp + 0x60, KVADDR, &marker, + sizeof(ulong), "stack frame", FAULT_ON_ERROR); + + if (marker == EXCP_FRAME_MARKER) + eframe_found = TRUE; + } + if (eframe_found) { + char *efrm_str = NULL; + struct ppc64_pt_regs regs; + + readmem(req.sp + STACK_FRAME_OVERHEAD, KVADDR, &regs, + sizeof(struct ppc64_pt_regs), + "exception frame", FAULT_ON_ERROR); + + efrm_str = ppc64_check_eframe(&regs); + if (efrm_str) { + eframe_lr = regs.link; + newpc = regs.nip; + newsp = regs.gpr[1]; + } + } + } + + req.name = closest_symbol(req.pc); + if (!req.name) { + if (CRASHDEBUG(1)) + error(FATAL, "%s hit unknown symbol (%lx).\n", __func__, req.pc); + } + + bt->flags |= BT_SAVE_LASTSP; + + ppc64_print_stack_entry(frame_num, &req, newsp, eframe_lr, bt); + + bt->flags |= ~(ulonglong)BT_SAVE_LASTSP; +} + /* * print one entry of a stack trace */ diff --git a/task.c b/task.c index b9076da35565..5c43a1600114 100644 --- a/task.c +++ b/task.c @@ -2948,6 +2948,7 @@ add_context(ulong task, char *tp) tc->mm_struct = *mm_addr; tc->task = task; tc->tc_next = NULL; + tc->frame_num = 0; /* * Fill a tgid_context structure with the data from -- 2.41.0