From: Aditya Gupta <adityag(a)linux.ibm.com&gt; Currently, 'frame' is prohibited on every architecture, even in gdb mode. But with gdb stack unwinding working correctly on some architectures (eg. ppc64, x86_64, arm64), so remove it from prohibited list, so that 'frame' command can be used This has an implication on all architectures, that 'frame' now outputs this in default mode: ``` crash> frame #0 <unavailable> in ?? () ``` instead of the before prohibited message ``` crash> frame crash: prohibited gdb command: frame ``` Though, 'frame' should work in gdb mode for architectures that implement 'machdep->get_cpu_reg' Cc: Sourabh Jain <sourabhjain(a)linux.ibm.com&gt; Cc: Hari Bathini <hbathini(a)linux.ibm.com&gt; Cc: Mahesh J Salgaonkar <mahesh(a)linux.ibm.com&gt; Cc: Naveen N. Rao <naveen.n.rao(a)linux.vnet.ibm.com&gt; Cc: Lianbo Jiang <lijiang(a)redhat.com&gt; Cc: HAGIO KAZUHITO(萩尾 一仁) <k-hagio-ab(a)nec.com&gt; Cc: Tao Liu <ltao(a)redhat.com&gt; Signed-off-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; --- gdb_interface.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/gdb_interface.c b/gdb_interface.c index b14319c..8f99a0d 100644 --- a/gdb_interface.c +++ b/gdb_interface.c @@ -711,7 +711,7 @@ static char *prohibited_list[] = { "watch", "rwatch", "awatch", "attach", "continue", "c", "fg", "detach", "finish", "handle", "interrupt", "jump", "kill", "next", "nexti", "signal", "step", "s", "stepi", "target", "until", "delete", - "clear", "disable", "enable", "condition", "ignore", "frame", "catch", + "clear", "disable", "enable", "condition", "ignore", "catch", "tcatch", "return", "file", "exec-file", "core-file", "symbol-file", "load", "si", "ni", "shell", "sy", NULL /* must be last */ -- 2.40.1

This patch is a preparation of gdb stack unwinding support. "set" command is extended with gdb context change: crash> set <pid> or crash> set <task> Then the task context of crash and gdb will both be switched to pid/task, and the following command: "bt" "gdb bt" will output the same task context. Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Co-developed-by: Tao Liu <ltao(a)redhat.com&gt; Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- crash_target.c | 21 +++++++++++++++++---- defs.h | 5 ++++- kernel.c | 11 ++++++++--- task.c | 21 +++++++++++++-------- tools.c | 8 ++++---- 5 files changed, 46 insertions(+), 20 deletions(-) diff --git a/crash_target.c b/crash_target.c index 1f62bf6..11134a7 100644 --- a/crash_target.c +++ b/crash_target.c @@ -28,7 +28,7 @@ void crash_target_init (void); extern "C" int gdb_readmem_callback(unsigned long, void *, int, int); extern "C" int crash_get_cpu_reg (int cpu, int regno, const char *regname, int regsize, void *val); - +extern "C" int gdb_change_thread_context (); /* The crash target. */ @@ -63,16 +63,21 @@ public: }; -/* We just get all the registers, so we don't use regno. */ void crash_target::fetch_registers (struct regcache *regcache, int regno) { + int r; gdb_byte regval[16]; - int cpu = inferior_ptid.tid(); struct gdbarch *arch = regcache->arch (); - for (int r = 0; r < gdbarch_num_regs (arch); r++) + if (regno >= 0) { + r = regno; + goto onetime; + } + + for (r = 0; regno == -1 && r < gdbarch_num_regs (arch); r++) { +onetime: const char *regname = gdbarch_register_name(arch, r); int regsize = register_size (arch, r); if (regsize > sizeof (regval)) @@ -129,3 +134,11 @@ crash_target_init (void) /* Now, set up the frame cache. */ reinit_frame_cache (); } + +extern "C" int +gdb_change_thread_context () +{ + target_fetch_registers(get_current_regcache(), -1); + reinit_frame_cache(); + return TRUE; +} diff --git a/defs.h b/defs.h index 98650e8..24f682b 100644 --- a/defs.h +++ b/defs.h @@ -6012,7 +6012,7 @@ extern char *help_map[]; * task.c */ void task_init(void); -int set_context(ulong, ulong); +int set_context(ulong, ulong, uint); void show_context(struct task_context *); ulong pid_to_task(ulong); ulong task_to_pid(ulong); @@ -8050,4 +8050,7 @@ enum x86_64_regnum { LAST_REGNUM }; +/* crash_target.c */ +extern int gdb_change_thread_context (); + #endif /* !GDB_COMMON */ diff --git a/kernel.c b/kernel.c index 1728b70..78b7b1e 100644 --- a/kernel.c +++ b/kernel.c @@ -6494,15 +6494,20 @@ set_cpu(int cpu) if (hide_offline_cpu(cpu)) error(FATAL, "invalid cpu number: cpu %d is OFFLINE\n", cpu); - if ((task = get_active_task(cpu))) - set_context(task, NO_PID); + task = get_active_task(cpu); + + /* Check if context is already set to given cpu */ + if (task == CURRENT_TASK()) + return; + + if (task) + set_context(task, NO_PID, TRUE); else error(FATAL, "cannot determine active task on cpu %ld\n", cpu); show_context(CURRENT_CONTEXT()); } - /* * Collect the irq_desc[] entry along with its associated handler and * action structures. diff --git a/task.c b/task.c index ebdb5be..d47d268 100644 --- a/task.c +++ b/task.c @@ -672,7 +672,7 @@ task_init(void) if (ACTIVE()) { active_pid = REMOTE() ? pc->server_pid : LOCAL_ACTIVE() ? pc->program_pid : 1; - set_context(NO_TASK, active_pid); + set_context(NO_TASK, active_pid, FALSE); tt->this_task = pid_to_task(active_pid); } else { @@ -684,7 +684,7 @@ task_init(void) else if (ELF_NOTES_VALID() && DISKDUMP_DUMPFILE()) map_cpus_to_prstatus_kdump_cmprs(); please_wait("determining panic task"); - set_context(get_panic_context(), NO_PID); + set_context(get_panic_context(), NO_PID, TRUE); please_wait_done(); } @@ -2985,9 +2985,9 @@ refresh_context(ulong curtask, ulong curpid) struct task_context *tc; if (task_exists(curtask) && pid_exists(curpid)) { - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, FALSE); } else { - set_context(tt->this_task, NO_PID); + set_context(tt->this_task, NO_PID, FALSE); complain = TRUE; if (STREQ(args[0], "set") && (argcnt == 2) && @@ -3053,7 +3053,7 @@ sort_context_array(void) curtask = CURRENT_TASK(); qsort((void *)tt->context_array, (size_t)tt->running_tasks, sizeof(struct task_context), sort_by_pid); - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, TRUE); sort_context_by_task(); } @@ -3100,7 +3100,7 @@ sort_context_array_by_last_run(void) curtask = CURRENT_TASK(); qsort((void *)tt->context_array, (size_t)tt->running_tasks, sizeof(struct task_context), sort_by_last_run); - set_context(curtask, NO_PID); + set_context(curtask, NO_PID, TRUE); sort_context_by_task(); } @@ -5281,7 +5281,7 @@ comm_exists(char *s) * that pid is selected. */ int -set_context(ulong task, ulong pid) +set_context(ulong task, ulong pid, uint update_gdb_thread) { int i; struct task_context *tc; @@ -5301,7 +5301,12 @@ set_context(ulong task, ulong pid) if (found) { CURRENT_CONTEXT() = tc; - return TRUE; + + /* change the selected thread in gdb, according to current context */ + if (update_gdb_thread) + return gdb_change_thread_context(); + else + return TRUE; } else { if (task) error(INFO, "cannot set context for task: %lx\n", task); diff --git a/tools.c b/tools.c index 0f2db10..80d4244 100644 --- a/tools.c +++ b/tools.c @@ -1871,7 +1871,7 @@ cmd_set(void) return; if (ACTIVE()) { - set_context(tt->this_task, NO_PID); + set_context(tt->this_task, NO_PID, TRUE); show_context(CURRENT_CONTEXT()); return; } @@ -1880,7 +1880,7 @@ cmd_set(void) error(INFO, "no panic task found!\n"); return; } - set_context(tt->panic_task, NO_PID); + set_context(tt->panic_task, NO_PID, TRUE); show_context(CURRENT_CONTEXT()); return; @@ -2559,14 +2559,14 @@ cmd_set(void) case STR_PID: pid = value; task = NO_TASK; - if (set_context(task, pid)) + if (set_context(task, pid, TRUE)) show_context(CURRENT_CONTEXT()); break; case STR_TASK: task = value; pid = NO_PID; - if (set_context(task, pid)) + if (set_context(task, pid, TRUE)) show_context(CURRENT_CONTEXT()); break; -- 2.40.1

This patch is a preparation of gdb stack unwinding support. "info threads" will output useful info for current task, such as pid, command, stack frame. Before the patch: crash> info threads Id Target Id Frame * 1 CPU 0 crash_setup_regs (oldregs=0x0, newregs=0xffffbd1040c57c70) ... After the patch: crash> info threads Id Target Id Frame * 1 1231 bash crash_setup_regs (oldregs=0x0, newregs=0xffffbd1040c57c70) ... Co-developed-by: Aditya Gupta <adityag(a)linux.ibm.com&gt; Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Co-developed-by: Tao Liu <ltao(a)redhat.com&gt; Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- crash_target.c | 8 +++++++- task.c | 9 +++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/crash_target.c b/crash_target.c index 52966f7..3b0efbf 100644 --- a/crash_target.c +++ b/crash_target.c @@ -29,6 +29,7 @@ extern "C" int gdb_readmem_callback(unsigned long, void *, int, int); extern "C" int crash_get_current_task_reg (int regno, const char *regname, int regsize, void *val); extern "C" int gdb_change_thread_context (); +extern "C" void crash_get_current_task_info(unsigned long *pid, char **comm); /* The crash target. */ @@ -59,7 +60,12 @@ public: bool has_registers () override { return true; } bool thread_alive (ptid_t ptid) override { return true; } std::string pid_to_str (ptid_t ptid) override - { return string_printf ("CPU %ld", ptid.tid ()); } + { + unsigned long pid; + char *comm; + crash_get_current_task_info(&pid, &comm); + return string_printf ("%ld %s", pid, comm); + } }; diff --git a/task.c b/task.c index d47d268..8c00837 100644 --- a/task.c +++ b/task.c @@ -11285,3 +11285,12 @@ check_stack_end_magic: if (!total) fprintf(fp, "No stack overflows detected\n"); } + +void crash_get_current_task_info(unsigned long *pid, char **comm); +void crash_get_current_task_info(unsigned long *pid, char **comm) +{ + struct task_context *tc = CURRENT_CONTEXT(); + + *pid = tc->pid; + *comm = tc->comm; +} -- 2.40.1

The stack unwinding is for kernel addresses only. If non-kernel address encountered, it is usually a user space address, or non-address value like a function call parameter. So stopping stack unwinding at non-kernel address will decrease the invalid unwind results. Before: crash> gdb bt #0 0xffffffff816a8f65 in context_switch ... #1 __schedule () ... #2 0xffffffff816a94e9 in schedule ... #3 0xffffffff816a86fd in schedule_hrtimeout_range_clock ... #4 0xffffffff816a8733 in schedule_hrtimeout_range ... #5 0xffffffff8124bb7e in ep_poll ... #6 0xffffffff8124d00d in SYSC_epoll_wait ... #7 SyS_epoll_wait ... #8 <signal handler called> #9 0x00007f0449407923 in ?? () #10 0xffff880100000001 in ?? () #11 0xffff880169b3c010 in ?? () #12 0x0000000000000040 in irq_stack_union () #13 0xffff880169b3c058 in ?? () #14 0xffff880169b3c048 in ?? () #15 0xffff880169b3c050 in ?? () #16 0x0000000000000000 in ?? () After: crash> gdb bt #0 0xffffffff816a8f65 in context_switch ... #1 __schedule () ... #2 0xffffffff816a94e9 in schedule () ... #3 0xffffffff816a86fd in schedule_hrtimeout_range_clock ... #4 0xffffffff816a8733 in schedule_hrtimeout_range ... #5 0xffffffff8124bb7e in ep_poll ... #6 0xffffffff8124d00d in SYSC_epoll_wait ... #7 SyS_epoll_wait ... #8 <signal handler called> #9 0x00007f0449407923 in ?? () Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 1 + gdb-10.2.patch | 26 ++++++++++++++++++++++++++ gdb_interface.c | 6 ++++++ 3 files changed, 33 insertions(+) diff --git a/defs.h b/defs.h index 6c47154..a6cf200 100644 --- a/defs.h +++ b/defs.h @@ -7901,6 +7901,7 @@ extern unsigned char *gdb_prettyprint_arrays; extern unsigned int *gdb_repeat_count_threshold; extern unsigned char *gdb_stop_print_at_null; extern unsigned int *gdb_output_radix; +int is_kvaddr(ulong); /* * gdb/top.c diff --git a/gdb-10.2.patch b/gdb-10.2.patch index e9248b5..af3859e 100644 --- a/gdb-10.2.patch +++ b/gdb-10.2.patch @@ -16110,3 +16110,29 @@ exit 0 } /* +--- gdb-10.2/gdb/frame.c.orig ++++ gdb-10.2/gdb/frame.c +@@ -2331,6 +2331,10 @@ inside_entry_func (frame_info *this_frame) + This function should not contain target-dependent tests, such as + checking whether the program-counter is zero. */ + ++#ifdef CRASH_MERGE ++extern "C" int is_kvaddr(ulong); ++#endif ++ + struct frame_info * + get_prev_frame (struct frame_info *this_frame) + { +@@ -2353,7 +2357,11 @@ get_prev_frame (struct frame_info *this_frame) + get_frame_id (this_frame); + + frame_pc_p = get_frame_pc_if_available (this_frame, &frame_pc); +- ++#ifdef CRASH_MERGE ++ if (!is_kvaddr(frame_pc)) { ++ return NULL; ++ } ++#endif + /* tausq/2004-12-07: Dummy frames are skipped because it doesn't make much + sense to stop unwinding at a dummy frame. One place where a dummy + frame may have an address "inside_main_func" is on HPUX. On HPUX, the diff --git a/gdb_interface.c b/gdb_interface.c index b13d5fd..e76ecc6 100644 --- a/gdb_interface.c +++ b/gdb_interface.c @@ -947,6 +947,12 @@ gdb_lookup_module_symbol(ulong addr, ulong *offset) } } +int +is_kvaddr(ulong addr) +{ + return IS_KVADDR(addr); +} + /* * Used by gdb_interface() to catch gdb-related errors, if desired. */ -- 2.40.1

This patch will add stack unwinding support for x86_64 CPU arch. It follows the tech path of ppc64_get_stack_frame() & ppc64_get_cpu_reg() in ppc64.c, to get and consume the cpu regs. One different case is, we need to handle inactive_task_frame structure specifically in x86_64. If inactive_task_frame structure enabled, for inactive tasks, 7 regs can be get from inactive_task_frame in stack, and sp need to rewind back to skip inactive_task_frame structure (See code comments in x86_64.c:x86_64_get_stack_frame()); for active tasks, we get regs by the original way. If inactive_task_frame structure is not enabled, for inactive tasks, the stack frame is organized as linked list, and sp/bp can be get from stack; for active tasks, we get regs by the original way. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 19 +++- x86_64.c | 284 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 276 insertions(+), 27 deletions(-) diff --git a/defs.h b/defs.h index 7026e5c..221dff0 100644 --- a/defs.h +++ b/defs.h @@ -2241,6 +2241,20 @@ struct offset_table { /* stash of commonly-used offsets */ long mnt_namespace_nr_mounts; long mount_mnt_node; long log_caller_id; + long inactive_task_frame_r15; + long inactive_task_frame_r14; + long inactive_task_frame_r13; + long inactive_task_frame_r12; + long inactive_task_frame_flags; + long inactive_task_frame_si; + long inactive_task_frame_di; + long inactive_task_frame_bx; + long thread_struct_es; + long thread_struct_ds; + long thread_struct_fsbase; + long thread_struct_gsbase; + long thread_struct_fs; + long thread_struct_gs; }; struct size_table { /* stash of commonly-used sizes */ @@ -8007,7 +8021,7 @@ extern int have_full_symbols(void); /* * Register numbers must be in sync with gdb/features/i386/64bit-core.c - * to make crash_target->fetch_registers() ---> machdep->get_cpu_reg() + * to make crash_target->fetch_registers() ---> machdep->get_current_task_reg() * working properly. */ enum x86_64_regnum { @@ -8051,6 +8065,9 @@ enum x86_64_regnum { FOSEG_REGNUM, FOOFF_REGNUM, FOP_REGNUM, + FS_BASE_REGNUM = 152, + GS_BASE_REGNUM, + ORIG_RAX_REGNUM, LAST_REGNUM }; diff --git a/x86_64.c b/x86_64.c index 502817d..6d42fe4 100644 --- a/x86_64.c +++ b/x86_64.c @@ -126,7 +126,7 @@ static int x86_64_get_framesize(struct bt_info *, ulong, ulong, char *); static void x86_64_framesize_debug(struct bt_info *); static void x86_64_get_active_set(void); static int x86_64_get_kvaddr_ranges(struct vaddr_range *); -static int x86_64_get_cpu_reg(int, int, const char *, int, void *); +static int x86_64_get_current_task_reg(int, const char *, int, void *); static int x86_64_verify_paddr(uint64_t); static void GART_init(void); static void x86_64_exception_stacks_init(void); @@ -143,6 +143,29 @@ struct machine_specific x86_64_machine_specific = { 0 }; static const char *exception_functions_orig[]; static const char *exception_functions_5_8[]; +/* Use this hardwired version -- sometimes the + * debuginfo doesn't pick this up even though + * it exists in the kernel; it shouldn't change. + */ +struct x86_64_user_regs_struct { + unsigned long r15, r14, r13, r12, bp, bx; + unsigned long r11, r10, r9, r8, ax, cx, dx; + unsigned long si, di, orig_ax, ip, cs; + unsigned long flags, sp, ss, fs_base; + unsigned long gs_base, ds, es, fs, gs; +}; + +struct user_regs_bitmap_struct { + struct { + unsigned long r15, r14, r13, r12, bp, bx; + unsigned long r11, r10, r9, r8, ax, cx, dx; + unsigned long si, di, orig_ax, ip, cs; + unsigned long flags, sp, ss, fs_base; + unsigned long gs_base, ds, es, fs, gs; + }; + ulong bitmap; +}; + /* * Do all necessary machine-specific setup here. This is called several * times during initialization. @@ -195,7 +218,7 @@ x86_64_init(int when) machdep->machspec->irq_eframe_link = UNINITIALIZED; machdep->machspec->irq_stack_gap = UNINITIALIZED; machdep->get_kvaddr_ranges = x86_64_get_kvaddr_ranges; - machdep->get_cpu_reg = x86_64_get_cpu_reg; + machdep->get_current_task_reg = x86_64_get_current_task_reg; if (machdep->cmdline_args[0]) parse_cmdline_args(); if ((string = pc->read_vmcoreinfo("relocate"))) { @@ -500,6 +523,12 @@ x86_64_init(int when) MEMBER_OFFSET_INIT(thread_struct_rsp, "thread_struct", "sp"); if (INVALID_MEMBER(thread_struct_rsp0)) MEMBER_OFFSET_INIT(thread_struct_rsp0, "thread_struct", "sp0"); + MEMBER_OFFSET_INIT(thread_struct_es, "thread_struct", "es"); + MEMBER_OFFSET_INIT(thread_struct_ds, "thread_struct", "ds"); + MEMBER_OFFSET_INIT(thread_struct_fsbase, "thread_struct", "fsbase"); + MEMBER_OFFSET_INIT(thread_struct_gsbase, "thread_struct", "gsbase"); + MEMBER_OFFSET_INIT(thread_struct_fs, "thread_struct", "fs"); + MEMBER_OFFSET_INIT(thread_struct_gs, "thread_struct", "gs"); STRUCT_SIZE_INIT(tss_struct, "tss_struct"); MEMBER_OFFSET_INIT(tss_struct_ist, "tss_struct", "ist"); if (INVALID_MEMBER(tss_struct_ist)) { @@ -583,17 +612,6 @@ x86_64_init(int when) "user_regs_struct", "r15"); STRUCT_SIZE_INIT(user_regs_struct, "user_regs_struct"); if (!VALID_STRUCT(user_regs_struct)) { - /* Use this hardwired version -- sometimes the - * debuginfo doesn't pick this up even though - * it exists in the kernel; it shouldn't change. - */ - struct x86_64_user_regs_struct { - unsigned long r15, r14, r13, r12, bp, bx; - unsigned long r11, r10, r9, r8, ax, cx, dx; - unsigned long si, di, orig_ax, ip, cs; - unsigned long flags, sp, ss, fs_base; - unsigned long gs_base, ds, es, fs, gs; - }; ASSIGN_SIZE(user_regs_struct) = sizeof(struct x86_64_user_regs_struct); ASSIGN_OFFSET(user_regs_struct_rip) = @@ -891,7 +909,7 @@ x86_64_dump_machdep_table(ulong arg) fprintf(fp, " is_page_ptr: x86_64_is_page_ptr()\n"); fprintf(fp, " verify_paddr: x86_64_verify_paddr()\n"); fprintf(fp, " get_kvaddr_ranges: x86_64_get_kvaddr_ranges()\n"); - fprintf(fp, " get_cpu_reg: x86_64_get_cpu_reg()\n"); + fprintf(fp, "get_current_task_reg: x86_64_get_current_task_reg()\n"); fprintf(fp, " init_kernel_pgd: x86_64_init_kernel_pgd()\n"); fprintf(fp, "clear_machdep_cache: x86_64_clear_machdep_cache()\n"); fprintf(fp, " xendump_p2m_create: %s\n", PVOPS_XEN() ? @@ -4970,22 +4988,117 @@ x86_64_eframe_verify(struct bt_info *bt, long kvaddr, long cs, long ss, return FALSE; } +#define GET_REG_FROM_INACTIVE_TASK_FRAME(reg) \ +({ \ + ulong offset, reg_value = 0, rsp; \ + if (VALID_MEMBER(inactive_task_frame_bp)) { \ + offset = OFFSET(task_struct_thread) + OFFSET(thread_struct_rsp); \ + readmem(bt->task + offset, KVADDR, &rsp, \ + sizeof(ulong), "thread_struct.rsp", FAULT_ON_ERROR); \ + readmem(rsp + OFFSET(inactive_task_frame_##reg), KVADDR, &reg_value, \ + sizeof(ulong), "inactive_task_frame.##reg", FAULT_ON_ERROR); \ + } \ + reg_value; \ +}) + /* * Get a stack frame combination of pc and ra from the most relevent spot. */ static void x86_64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp) { - if (bt->flags & BT_DUMPFILE_SEARCH) - return x86_64_get_dumpfile_stack_frame(bt, pcp, spp); + struct user_regs_bitmap_struct *ur_bitmap; if (bt->flags & BT_SKIP_IDLE) bt->flags &= ~BT_SKIP_IDLE; + if (pcp) + *pcp = x86_64_get_pc(bt); + if (spp) + *spp = x86_64_get_sp(bt); + ur_bitmap = (struct user_regs_bitmap_struct *)GETBUF(sizeof(*ur_bitmap)); + memset(ur_bitmap, 0, sizeof(struct user_regs_bitmap_struct)); + + if (VALID_MEMBER(inactive_task_frame_bp)) { + if (!is_task_active(bt->task)) { + /* + * For inactive tasks in live and dumpfile, regs can be + * get from inactive_task_frame struct. + */ + ur_bitmap->r15 = GET_REG_FROM_INACTIVE_TASK_FRAME(r15); + ur_bitmap->r14 = GET_REG_FROM_INACTIVE_TASK_FRAME(r14); + ur_bitmap->r13 = GET_REG_FROM_INACTIVE_TASK_FRAME(r13); + ur_bitmap->r12 = GET_REG_FROM_INACTIVE_TASK_FRAME(r12); + ur_bitmap->bx = GET_REG_FROM_INACTIVE_TASK_FRAME(bx); + ur_bitmap->bp = GET_REG_FROM_INACTIVE_TASK_FRAME(bp); + /* + For inactive tasks: + crash> task -x 1|grep sp + sp = 0xffffc90000013d00 + crash> rd ffffc90000013d00 32 + ffffc90000013d00: ffff888104dad4a8 0000000000000000 r15,r14 + ffffc90000013d10: ffff888100280000 ffff888100216500 r13,r12 + ffffc90000013d20: ffff888100217018 ffff88817fd2c800 rbx,rbp + ffffc90000013d30: ffffffff81a6a1b3 ffffc90000013de0 saved_rip,... + ffffc90000013d40: ffff888100000004 99ccbf53ea493000 + ffffc90000013d50: ffff888100216500 ffff888100216500 + + crash> dis __schedule + ... + 0xffffffff81a6a1ab <__schedule+507>: mov %r13,%rsi + 0xffffffff81a6a1ae <__schedule+510>: call 0xffffffff81003490 <__switch_to_asm> + 0xffffffff81a6a1b3 <__schedule+515>: mov %rax,%rdi <<=== saved_rip + ... + crash> dis __switch_to_asm + 0xffffffff81003490 <__switch_to_asm>: push %rbp + 0xffffffff81003491 <__switch_to_asm+1>: push %rbx + 0xffffffff81003492 <__switch_to_asm+2>: push %r12 + 0xffffffff81003494 <__switch_to_asm+4>: push %r13 + 0xffffffff81003496 <__switch_to_asm+6>: push %r14 + 0xffffffff81003498 <__switch_to_asm+8>: push %r15 + 0xffffffff8100349a <__switch_to_asm+10>: mov %rsp,0x14d8(%rdi) + ... + Now saved_rip = ffffffff81a6a1b3, and we are starting + the stack unwind at saved_rip, which is function __schedule() + instead of function __switch_to_asm(), so the stack pointer should + be rewind from ffffc90000013d00 back to ffffc90000013d38, + aka *spp += 7 * reg_len. Otherwise we are unwinding function + __schedule() but with __switch_to_asm()'s stack frame, which + will fail. + */ + *spp += 7 * sizeof(unsigned long); + ur_bitmap->bitmap += 0x3f; + } else { + /* + * For active tasks in dumpfile, we get regs through the + * original way. For active tasks in live, we only get + * ip and sp in the end of the function. + */ + if (bt->flags & BT_DUMPFILE_SEARCH) { + FREEBUF(ur_bitmap); + bt->need_free = FALSE; + return x86_64_get_dumpfile_stack_frame(bt, pcp, spp); + } + } + } else { + if (!is_task_active(bt->task)) { + readmem(*spp, KVADDR, &(ur_bitmap->bp), + sizeof(ulong), "ur_bitmap->bp", FAULT_ON_ERROR); + ur_bitmap->bitmap += 0x10; + } else { + if (bt->flags & BT_DUMPFILE_SEARCH) { + FREEBUF(ur_bitmap); + bt->need_free = FALSE; + return x86_64_get_dumpfile_stack_frame(bt, pcp, spp); + } + } + } - if (pcp) - *pcp = x86_64_get_pc(bt); - if (spp) - *spp = x86_64_get_sp(bt); + ur_bitmap->ip = *pcp; + ur_bitmap->sp = *spp; + ur_bitmap->bitmap += 0x50000; + + bt->machdep = ur_bitmap; + bt->need_free = TRUE; } /* @@ -6457,6 +6570,14 @@ x86_64_ORC_init(void) MEMBER_OFFSET_INIT(inactive_task_frame_bp, "inactive_task_frame", "bp"); MEMBER_OFFSET_INIT(inactive_task_frame_ret_addr, "inactive_task_frame", "ret_addr"); + MEMBER_OFFSET_INIT(inactive_task_frame_r15, "inactive_task_frame", "r15"); + MEMBER_OFFSET_INIT(inactive_task_frame_r14, "inactive_task_frame", "r14"); + MEMBER_OFFSET_INIT(inactive_task_frame_r13, "inactive_task_frame", "r13"); + MEMBER_OFFSET_INIT(inactive_task_frame_r12, "inactive_task_frame", "r12"); + MEMBER_OFFSET_INIT(inactive_task_frame_flags, "inactive_task_frame", "flags"); + MEMBER_OFFSET_INIT(inactive_task_frame_si, "inactive_task_frame", "si"); + MEMBER_OFFSET_INIT(inactive_task_frame_di, "inactive_task_frame", "di"); + MEMBER_OFFSET_INIT(inactive_task_frame_bx, "inactive_task_frame", "bx"); orc->has_signal = MEMBER_EXISTS("orc_entry", "signal"); /* added at 6.3 */ orc->has_end = MEMBER_EXISTS("orc_entry", "end"); /* removed at 6.4 */ @@ -9069,17 +9190,128 @@ x86_64_get_kvaddr_ranges(struct vaddr_range *vrp) return cnt; } +#define REG_CASE(R, r) \ + case R##_REGNUM: \ + if (size != sizeof(ur_bitmap->r)) { \ + ret = FALSE; break; \ + } else { \ + memcpy(value, &ur_bitmap->r, size); \ + ret = TRUE; break; \ + } + static int -x86_64_get_cpu_reg(int cpu, int regno, const char *name, +x86_64_get_current_task_reg(int regno, const char *name, int size, void *value) { - if (regno >= LAST_REGNUM) - return FALSE; + struct bt_info bt_info, bt_setup; + struct task_context *tc; + struct user_regs_bitmap_struct *ur_bitmap; + ulong ip, sp; + bool ret = FALSE; - if (VMSS_DUMPFILE()) - return vmware_vmss_get_cpu_reg(cpu, regno, name, size, value); + switch (regno) { + case RAX_REGNUM ... GS_REGNUM: + case FS_BASE_REGNUM ... ORIG_RAX_REGNUM: + break; + default: + return FALSE; + } - return FALSE; + tc = CURRENT_CONTEXT(); + if (!tc) + return FALSE; + + if (VMSS_DUMPFILE()) + return vmware_vmss_get_cpu_reg(tc->processor, regno, name, size, value); + + 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); + if (bt_info.stackbuf) + FREEBUF(bt_info.stackbuf); + ur_bitmap = (struct user_regs_bitmap_struct *)bt_info.machdep; + if (!ur_bitmap) + return FALSE; + + /* Get all registers from elf notes*/ + if (!bt_info.need_free) { + goto get_all; + } + + /* Get subset registers from stack frame*/ + switch (ur_bitmap->bitmap) { + case 0x5003f: + switch (regno) { + case R12_REGNUM ... R15_REGNUM: + case RBP_REGNUM: + case RBX_REGNUM: + case RIP_REGNUM: + case RSP_REGNUM: + break; + default: + return FALSE; + } + break; + case 0x50010: + switch (regno) { + case RBP_REGNUM: + case RIP_REGNUM: + case RSP_REGNUM: + break; + default: + return FALSE; + } + break; + case 0x50000: + switch (regno) { + case RIP_REGNUM: + case RSP_REGNUM: + break; + default: + return FALSE; + } + break; + } + +get_all: + switch (regno) { + REG_CASE(RAX, ax); + REG_CASE(RBX, bx); + REG_CASE(RCX, cx); + REG_CASE(RDX, dx); + REG_CASE(RSI, si); + REG_CASE(RDI, di); + REG_CASE(RBP, bp); + REG_CASE(RSP, sp); + REG_CASE(R8, r8); + REG_CASE(R9, r9); + REG_CASE(R10, r10); + REG_CASE(R11, r11); + REG_CASE(R12, r12); + REG_CASE(R13, r13); + REG_CASE(R14, r14); + REG_CASE(R15, r15); + REG_CASE(RIP, ip); + REG_CASE(EFLAGS, flags); + REG_CASE(CS, cs); + REG_CASE(SS, ss); + REG_CASE(DS, ds); + REG_CASE(ES, es); + REG_CASE(FS, fs); + REG_CASE(GS, gs); + REG_CASE(FS_BASE, fs_base); + REG_CASE(GS_BASE, gs_base); + REG_CASE(ORIG_RAX, orig_ax); + } + + if (bt_info.need_free) { + FREEBUF(ur_bitmap); + bt_info.need_free = FALSE; + } + return ret; } /* -- 2.40.1

There is recursive dependence for cpumask_t and will exhause the stack, see the following stack trace: (gdb) bt ...snip... #61965 0x00000000005de98c in datatype_info (name=name@entry=0xa5b1fd "cpumask_t", member=member@entry=0x0, dm=dm@entry=0xfffffffffffffffc) at symbols.c:6694 #61966 0x000000000057e4ea in cpu_map_size ... #61967 0x000000000058e7bd in get_cpus_online ... #61968 0x000000000061fa4b in diskdump_get_prstatus_percpu ... #61969 0x0000000000616d74 in get_netdump_regs_x86_64 ... #61970 0x0000000000585290 in get_dumpfile_regs ... #61971 0x00000000005b7a3c in x86_64_get_current_task_reg ... #61972 0x0000000000650389 in crash_target::fetch_registers ... #61973 0x00000000008f385a in target_fetch_registers ... #61974 0x000000000086ecda in regcache::raw_update ... #61975 regcache::raw_update ... #61976 0x000000000086ed7a in readable_regcache::raw_read ... #61977 0x000000000086f063 in readable_regcache::cooked_read_value ... #61978 0x000000000089c4ee in sentinel_frame_prev_register ... #61979 0x0000000000786c76 in frame_unwind_register_value ... #61980 0x0000000000786f18 in frame_register_unwind ... #61981 0x0000000000787267 in frame_unwind_register ... #61982 0x00000000007ad9b0 in i386_unwind_pc ... #61983 0x00000000007866c0 in frame_unwind_pc ... #61984 0x000000000078679c in get_frame_pc ... #61985 get_frame_address_in_block ... #61986 0x0000000000786849 in get_frame_address_in_block_if_available ... #61987 0x0000000000691466 in get_frame_block ... #61988 0x00000000008b9430 in get_selected_block ... #61989 0x000000000084f8f2 in parse_exp_in_context ... #61990 0x000000000084f9e5 in parse_exp_1 ... #61991 parse_expression ... #61992 0x00000000008d44da in gdb_get_datatype ... #61993 gdb_command_funnel_1 ... #61994 0x00000000008d48ae in gdb_command_funnel ... #61995 0x000000000059cc42 in gdb_interface ... #61996 0x00000000005de98c in datatype_info (name=name@entry=0xa5b1fd "cpumask_t", member=member@entry=0x0, dm=dm@entry=0xfffffffffffffffc) at symbols.c:6694 #61997 0x000000000057e4ea in cpu_map_size ... #61998 0x000000000058e7bd in get_cpus_online () ... #61999 0x000000000061fa4b in diskdump_get_prstatus_percpu ... #62000 0x0000000000616d74 in get_netdump_regs_x86_64 ... #62001 0x0000000000585290 in get_dumpfile_regs ... #62002 0x00000000005b7a3c in x86_64_get_current_task_reg ... #62003 0x0000000000650389 in crash_target::fetch_registers ... The cpumask_t will be recursively evaluated. This patch will fix the bug. Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 1 + kernel.c | 17 ++++++++++------- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/defs.h b/defs.h index 221dff0..0db9dea 100644 --- a/defs.h +++ b/defs.h @@ -2429,6 +2429,7 @@ struct size_table { /* stash of commonly-used sizes */ long maple_tree; long maple_node; long module_memory; + long cpumask_t; }; struct array_table { diff --git a/kernel.c b/kernel.c index 3730c55..2cae305 100644 --- a/kernel.c +++ b/kernel.c @@ -157,6 +157,7 @@ kernel_init() if (!(kt->cpu_flags = (ulong *)calloc(NR_CPUS, sizeof(ulong)))) error(FATAL, "cannot malloc cpu_flags array"); + STRUCT_SIZE_INIT(cpumask_t, "cpumask_t"); cpu_maps_init(); kt->stext = symbol_value("_stext"); @@ -913,9 +914,10 @@ cpu_map_size(const char *type) struct gnu_request req; if (LKCD_KERNTYPES()) { - if ((len = STRUCT_SIZE("cpumask_t")) < 0) - error(FATAL, "cannot determine type cpumask_t\n"); - return len; + if (INVALID_SIZE(cpumask_t)) + error(FATAL, "cannot determine type cpumask_t\n"); + else + return SIZE(cpumask_t); } sprintf(map_symbol, "cpu_%s_map", type); @@ -925,11 +927,10 @@ cpu_map_size(const char *type) return len; } - len = STRUCT_SIZE("cpumask_t"); - if (len < 0) + if (INVALID_SIZE(cpumask_t)) return sizeof(ulong); else - return len; + return SIZE(cpumask_t); } /* @@ -952,8 +953,10 @@ cpu_maps_init(void) { ACTIVE_MAP, "active" }, }; - if ((len = STRUCT_SIZE("cpumask_t")) < 0) + if (INVALID_SIZE(cpumask_t)) len = sizeof(ulong); + else + len = SIZE(cpumask_t); buf = GETBUF(len); -- 2.40.1