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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.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; 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- crash_target.c | 20 +++++++++++++++++--- defs.h | 5 ++++- kernel.c | 11 ++++++++--- task.c | 21 +++++++++++++-------- tools.c | 8 ++++---- 5 files changed, 46 insertions(+), 19 deletions(-) diff --git a/crash_target.c b/crash_target.c index 1f62bf6..03718b5 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,22 @@ 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 +135,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 3cb8e63..0d872b2 100644 --- a/defs.h +++ b/defs.h @@ -6013,7 +6013,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); @@ -8051,4 +8051,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; 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.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 ?? () 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; 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 012ffdc..c0e6a29 100644 --- a/defs.h +++ b/defs.h @@ -7902,6 +7902,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 0bed96a..3ed40c0 100644 --- a/gdb-10.2.patch +++ b/gdb-10.2.patch @@ -16171,3 +16171,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. 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- defs.h | 19 +++- x86_64.c | 291 ++++++++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 283 insertions(+), 27 deletions(-) diff --git a/defs.h b/defs.h index 8450aea..ed52cc3 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 */ @@ -8008,7 +8022,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 { @@ -8052,6 +8066,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 5ab2852..4ba0b40 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_current_task_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() ? @@ -4971,22 +4989,124 @@ 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; + ulong pcp_save = *pcp; + ulong spp_save = *spp; + ulong sp; if (bt->flags & BT_SKIP_IDLE) bt->flags &= ~BT_SKIP_IDLE; + if (pcp) + *pcp = x86_64_get_pc(bt); + if (spp) + sp = *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. + */ + sp += 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; + *pcp = pcp_save; + *spp = spp_save; + 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; + *pcp = pcp_save; + *spp = spp_save; + 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 = sp; + ur_bitmap->bitmap += 0x50000; + + bt->machdep = ur_bitmap; + bt->need_free = TRUE; } /* @@ -6458,6 +6578,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 */ @@ -9071,17 +9199,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. 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; 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 ed52cc3..fd00462 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

From: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; By doing it we avoid dropping gdb caches unnecessarily. 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Signed-off-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; --- task.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/task.c b/task.c index 8c00837..3814f6d 100644 --- a/task.c +++ b/task.c @@ -5287,6 +5287,9 @@ set_context(ulong task, ulong pid, uint update_gdb_thread) struct task_context *tc; int found; + if (CURRENT_CONTEXT() && CURRENT_TASK() == task) + return TRUE; + tc = FIRST_CONTEXT(); for (i = 0, found = FALSE; i < RUNNING_TASKS(); i++, tc++) { -- 2.40.1

From: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; There are several versions of debug.guest format. Current version of the code is able to parse only version 4. Improve parser to support other known versions. Split data structures on sub-structures and introduce a helper functions to calculate a gap between them based on the version number. Implement additional data structure (struct mainmeminfo_old) and logic specifically for original (version 1) format support. 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; Cc: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; Signed-off-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; --- vmware_guestdump.c | 316 ++++++++++++++++++++++++++++++++------------- 1 file changed, 229 insertions(+), 87 deletions(-) diff --git a/vmware_guestdump.c b/vmware_guestdump.c index 5be26c8..5c7ee4d 100644 --- a/vmware_guestdump.c +++ b/vmware_guestdump.c @@ -2,6 +2,8 @@ * vmware_guestdump.c * * Copyright (c) 2020 VMware, Inc. + * Copyright (c) 2024 Broadcom. All Rights Reserved. The term "Broadcom" + * refers to Broadcom Inc. and/or its subsidiaries. * * 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 @@ -13,7 +15,7 @@ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * - * Author: Alexey Makhalov <amakhalov(a)vmware.com&gt; + * Author: Alexey Makhalov <alexey.makhalov(a)broadcom.com&gt; */ #include "defs.h" @@ -21,20 +23,31 @@ #define LOGPRX "vmw: " -#define GUESTDUMP_VERSION 4 -#define GUESTDUMP_MAGIC1 1 -#define GUESTDUMP_MAGIC2 0 - +/* + * debug.guest file layout + * 00000000: guest dump header, it includes: + * 1. Version (4 bytes) \ + * 2. Number of Virtual CPUs (4 bytes) } - struct guestdumpheader + * 3. Reserved gap + * 4. Main Memory information - struct mainmeminfo{,_old} + * (use get_vcpus_offset() to get total size of guestdumpheader) + * vcpus_offset: ---------\ + * 1. struct vcpu_state1 \ + * 2. reserved gap } num_vcpus times + * 3. struct vcpu_state2 / + * 4. 4KB of reserved data / + * --------/ + * + */ struct guestdumpheader { uint32_t version; uint32_t num_vcpus; - uint8_t magic1; - uint8_t reserved1; - uint32_t cpu_vendor; - uint64_t magic2; +} __attribute__((packed)) hdr; + +struct mainmeminfo { uint64_t last_addr; uint64_t memsize_in_pages; - uint32_t reserved2; + uint32_t reserved1; uint32_t mem_holes; struct memhole { uint64_t ppn; @@ -42,14 +55,36 @@ struct guestdumpheader { } holes[2]; } __attribute__((packed)); -struct vcpu_state { +/* Used by version 1 only */ +struct mainmeminfo_old { + uint64_t last_addr; + uint32_t memsize_in_pages; + uint32_t reserved1; + uint32_t mem_holes; + struct memhole1 { + uint32_t ppn; + uint32_t pages; + } holes[2]; + /* There are additional fields, see get_vcpus_offset() calculation. */ +} __attribute__((packed)); + +/* First half of vcpu_state */ +struct vcpu_state1 { uint32_t cr0; uint64_t cr2; uint64_t cr3; uint64_t cr4; uint64_t reserved1[10]; uint64_t idt_base; - uint16_t reserved2[21]; +} __attribute__((packed)); + +/* + * Unused fields between vcpu_state1 and vcpu_state2 swill be skipped. + * See get_vcpu_gapsize() calculation. + */ + +/* Second half of vcpu_state */ +struct vcpu_state2 { struct x86_64_pt_regs { uint64_t r15; uint64_t r14; @@ -76,9 +111,41 @@ struct vcpu_state { uint8_t reserved3[65]; } __attribute__((packed)); +/* + * Returns the size of the guest dump header. + */ +static inline long +get_vcpus_offset(uint32_t version, int mem_holes) +{ + switch (version) { + case 1: /* ESXi 6.7 and older */ + return sizeof(struct guestdumpheader) + 13 + sizeof(struct mainmeminfo_old) + + (mem_holes == -1 ? 0 : 8 * mem_holes + 4); + case 3: /* ESXi 6.8 */ + return sizeof(struct guestdumpheader) + 14 + sizeof(struct mainmeminfo); + case 4: /* ESXi 7.0 */ + case 5: /* ESXi 8.0 */ + return sizeof(struct guestdumpheader) + 14 + sizeof(struct mainmeminfo); + case 6: /* ESXi 8.0u2 */ + return sizeof(struct guestdumpheader) + 15 + sizeof(struct mainmeminfo); + + } + return 0; +} + +/* + * Returns the size of reserved (unused) fields in the middle of vcpu_state structure. + */ +static inline long +get_vcpu_gapsize(uint32_t version) +{ + if (version < 4) + return 45; + return 42; +} /* - * vmware_guestdump is extension to vmware_vmss with ability to debug + * vmware_guestdump is an extension to the vmware_vmss with ability to debug * debug.guest and debug.vmem files. * * debug.guest.gz and debug.vmem.gz can be obtained using following @@ -86,73 +153,136 @@ struct vcpu_state { * monitor.mini-suspend_on_panic = TRUE * monitor.suspend_on_triplefault = TRUE * - * guestdump (debug.guest) is simplified version of *.vmss which does - * not contain full VM state, but minimal guest state, such as memory + * guestdump (debug.guest) is a simplified version of the *.vmss which does + * not contain a full VM state, but minimal guest state, such as a memory * layout and CPUs state, needed for debugger. is_vmware_guestdump() * and vmware_guestdump_init() functions parse guestdump header and - * populate vmss data structure (from vmware_vmss.c). As result, all + * populate vmss data structure (from vmware_vmss.c). In result, all * handlers (except mempry_dump) from vmware_vmss.c can be reused. * - * debug.guest does not have dedicated header magic or signature for - * its format. To probe debug.guest we need to perform header fields - * and file size validity. In addition, check for the filename - * extension, which must be ".guest". + * debug.guest does not have a dedicated header magic or file format signature + * To probe debug.guest we need to perform series of validations. In addition, + * we check for the filename extension, which must be ".guest". */ - int is_vmware_guestdump(char *filename) { - struct guestdumpheader hdr; + struct mainmeminfo mmi; + long vcpus_offset; FILE *fp; - uint64_t filesize, holes_sum = 0; + uint64_t filesize, expected_filesize, holes_sum = 0; int i; if (strcmp(filename + strlen(filename) - 6, ".guest")) return FALSE; - if ((fp = fopen(filename, "r")) == NULL) { + if ((fp = fopen(filename, "r")) == NULL) { error(INFO, LOGPRX"Failed to open '%s': [Error %d] %s\n", - filename, errno, strerror(errno)); + filename, errno, strerror(errno)); return FALSE; - } + } if (fread(&hdr, sizeof(struct guestdumpheader), 1, fp) != 1) { error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", - "guestdumpheader", filename, errno, strerror(errno)); + "guestdumpheader", filename, errno, strerror(errno)); + fclose(fp); + return FALSE; + } + + vcpus_offset = get_vcpus_offset(hdr.version, -1 /* Unknown yet, adjust it later */); + + if (!vcpus_offset) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Not supported version %d\n", hdr.version); fclose(fp); return FALSE; } + if (hdr.version == 1) { + struct mainmeminfo_old tmp; + if (fseek(fp, vcpus_offset - sizeof(struct mainmeminfo_old), SEEK_SET) == -1) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n", + filename, errno, strerror(errno)); + fclose(fp); + return FALSE; + } + + if (fread(&tmp, sizeof(struct mainmeminfo_old), 1, fp) != 1) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", + "mainmeminfo_old", filename, errno, strerror(errno)); + fclose(fp); + return FALSE; + } + mmi.last_addr = tmp.last_addr; + mmi.memsize_in_pages = tmp.memsize_in_pages; + mmi.mem_holes = tmp.mem_holes; + mmi.holes[0].ppn = tmp.holes[0].ppn; + mmi.holes[0].pages = tmp.holes[0].pages; + mmi.holes[1].ppn = tmp.holes[1].ppn; + mmi.holes[1].pages = tmp.holes[1].pages; + /* vcpu_offset adjustment for mem_holes is required only for version 1. */ + vcpus_offset = get_vcpus_offset(hdr.version, mmi.mem_holes); + } else { + if (fseek(fp, vcpus_offset - sizeof(struct mainmeminfo), SEEK_SET) == -1) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n", + filename, errno, strerror(errno)); + fclose(fp); + return FALSE; + } + + if (fread(&mmi, sizeof(struct mainmeminfo), 1, fp) != 1) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", + "mainmeminfo", filename, errno, strerror(errno)); + fclose(fp); + return FALSE; + } + } if (fseek(fp, 0L, SEEK_END) == -1) { - error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n", - filename, errno, strerror(errno)); + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n", + filename, errno, strerror(errno)); fclose(fp); return FALSE; } filesize = ftell(fp); fclose(fp); - if (hdr.mem_holes > 2) - goto unrecognized; + if (mmi.mem_holes > 2) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Unexpected mmi.mem_holes value %d\n", + mmi.mem_holes); + return FALSE; + } - for (i = 0; i < hdr.mem_holes; i++) { + for (i = 0; i < mmi.mem_holes; i++) { /* hole start page */ - vmss.regions[i].startpagenum = hdr.holes[i].ppn; + vmss.regions[i].startpagenum = mmi.holes[i].ppn; /* hole end page */ - vmss.regions[i].startppn = hdr.holes[i].ppn + hdr.holes[i].pages; - holes_sum += hdr.holes[i].pages; + vmss.regions[i].startppn = mmi.holes[i].ppn + mmi.holes[i].pages; + holes_sum += mmi.holes[i].pages; + } + + if ((mmi.last_addr + 1) != ((mmi.memsize_in_pages + holes_sum) << VMW_PAGE_SHIFT)) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Memory size check failed\n"); + return FALSE; } - if (hdr.version != GUESTDUMP_VERSION || - hdr.magic1 != GUESTDUMP_MAGIC1 || - hdr.magic2 != GUESTDUMP_MAGIC2 || - (hdr.last_addr + 1) != ((hdr.memsize_in_pages + holes_sum) << VMW_PAGE_SHIFT) || - filesize != sizeof(struct guestdumpheader) + - hdr.num_vcpus * (sizeof (struct vcpu_state) + VMW_PAGE_SIZE)) - goto unrecognized; + expected_filesize = vcpus_offset + hdr.num_vcpus * (sizeof(struct vcpu_state1) + + get_vcpu_gapsize(hdr.version) + sizeof(struct vcpu_state2) + VMW_PAGE_SIZE); + if (filesize != expected_filesize) { + if (CRASHDEBUG(1)) + error(INFO, LOGPRX"Incorrect file size: %d != %d\n", + filesize, expected_filesize); + return FALSE; + } - vmss.memsize = hdr.memsize_in_pages << VMW_PAGE_SHIFT; - vmss.regionscount = hdr.mem_holes + 1; + vmss.memsize = mmi.memsize_in_pages << VMW_PAGE_SHIFT; + vmss.regionscount = mmi.mem_holes + 1; vmss.memoffset = 0; vmss.num_vcpus = hdr.num_vcpus; return TRUE; @@ -169,7 +299,8 @@ vmware_guestdump_init(char *filename, FILE *ofp) FILE *fp = NULL; int i, result = TRUE; char *vmem_filename = NULL; - struct vcpu_state vs; + struct vcpu_state1 vs1; + struct vcpu_state2 vs2; char *p; if (!machine_type("X86") && !machine_type("X86_64")) { @@ -180,14 +311,14 @@ vmware_guestdump_init(char *filename, FILE *ofp) goto exit; } - if ((fp = fopen(filename, "r")) == NULL) { + if ((fp = fopen(filename, "r")) == NULL) { error(INFO, LOGPRX"Failed to open '%s': [Error %d] %s\n", filename, errno, strerror(errno)); result = FALSE; goto exit; - } + } - if (fseek(fp, sizeof(struct guestdumpheader), SEEK_SET) == -1) { + if (fseek(fp, get_vcpus_offset(hdr.version, vmss.regionscount - 1), SEEK_SET) == -1) { error(INFO, LOGPRX"Failed to fseek '%s': [Error %d] %s\n", filename, errno, strerror(errno)); result = FALSE; @@ -203,7 +334,19 @@ vmware_guestdump_init(char *filename, FILE *ofp) } for (i = 0; i < vmss.num_vcpus; i++) { - if (fread(&vs, sizeof(struct vcpu_state), 1, fp) != 1) { + if (fread(&vs1, sizeof(struct vcpu_state1), 1, fp) != 1) { + error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", + "vcpu_state", filename, errno, strerror(errno)); + result = FALSE; + goto exit; + } + if (fseek(fp, get_vcpu_gapsize(hdr.version), SEEK_CUR) == -1) { + error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", + "vcpu_state", filename, errno, strerror(errno)); + result = FALSE; + goto exit; + } + if (fread(&vs2, sizeof(struct vcpu_state2), 1, fp) != 1) { error(INFO, LOGPRX"Failed to read '%s' from file '%s': [Error %d] %s\n", "vcpu_state", filename, errno, strerror(errno)); result = FALSE; @@ -217,29 +360,29 @@ vmware_guestdump_init(char *filename, FILE *ofp) } vmss.vcpu_regs[i] = 0; - vmss.regs64[i]->rax = vs.regs64.rax; - vmss.regs64[i]->rcx = vs.regs64.rcx; - vmss.regs64[i]->rdx = vs.regs64.rdx; - vmss.regs64[i]->rbx = vs.regs64.rbx; - vmss.regs64[i]->rbp = vs.regs64.rbp; - vmss.regs64[i]->rsp = vs.regs64.rsp; - vmss.regs64[i]->rsi = vs.regs64.rsi; - vmss.regs64[i]->rdi = vs.regs64.rdi; - vmss.regs64[i]->r8 = vs.regs64.r8; - vmss.regs64[i]->r9 = vs.regs64.r9; - vmss.regs64[i]->r10 = vs.regs64.r10; - vmss.regs64[i]->r11 = vs.regs64.r11; - vmss.regs64[i]->r12 = vs.regs64.r12; - vmss.regs64[i]->r13 = vs.regs64.r13; - vmss.regs64[i]->r14 = vs.regs64.r14; - vmss.regs64[i]->r15 = vs.regs64.r15; - vmss.regs64[i]->idtr = vs.idt_base; - vmss.regs64[i]->cr[0] = vs.cr0; - vmss.regs64[i]->cr[2] = vs.cr2; - vmss.regs64[i]->cr[3] = vs.cr3; - vmss.regs64[i]->cr[4] = vs.cr4; - vmss.regs64[i]->rip = vs.regs64.rip; - vmss.regs64[i]->rflags = vs.regs64.eflags; + vmss.regs64[i]->rax = vs2.regs64.rax; + vmss.regs64[i]->rcx = vs2.regs64.rcx; + vmss.regs64[i]->rdx = vs2.regs64.rdx; + vmss.regs64[i]->rbx = vs2.regs64.rbx; + vmss.regs64[i]->rbp = vs2.regs64.rbp; + vmss.regs64[i]->rsp = vs2.regs64.rsp; + vmss.regs64[i]->rsi = vs2.regs64.rsi; + vmss.regs64[i]->rdi = vs2.regs64.rdi; + vmss.regs64[i]->r8 = vs2.regs64.r8; + vmss.regs64[i]->r9 = vs2.regs64.r9; + vmss.regs64[i]->r10 = vs2.regs64.r10; + vmss.regs64[i]->r11 = vs2.regs64.r11; + vmss.regs64[i]->r12 = vs2.regs64.r12; + vmss.regs64[i]->r13 = vs2.regs64.r13; + vmss.regs64[i]->r14 = vs2.regs64.r14; + vmss.regs64[i]->r15 = vs2.regs64.r15; + vmss.regs64[i]->idtr = vs1.idt_base; + vmss.regs64[i]->cr[0] = vs1.cr0; + vmss.regs64[i]->cr[2] = vs1.cr2; + vmss.regs64[i]->cr[3] = vs1.cr3; + vmss.regs64[i]->cr[4] = vs1.cr4; + vmss.regs64[i]->rip = vs2.regs64.rip; + vmss.regs64[i]->rflags = vs2.regs64.eflags; vmss.vcpu_regs[i] = REGS_PRESENT_ALL; } @@ -268,9 +411,9 @@ vmware_guestdump_init(char *filename, FILE *ofp) fprintf(ofp, LOGPRX"vmem file: %s\n\n", vmem_filename); if (CRASHDEBUG(1)) { - vmware_guestdump_memory_dump(ofp); - dump_registers_for_vmss_dump(); - } + vmware_guestdump_memory_dump(ofp); + dump_registers_for_vmss_dump(); + } exit: if (fp) @@ -296,24 +439,23 @@ exit: int vmware_guestdump_memory_dump(FILE *ofp) { + uint64_t holes_sum = 0; + unsigned i; + fprintf(ofp, "vmware_guestdump:\n"); fprintf(ofp, " Header: version=%d num_vcpus=%llu\n", - GUESTDUMP_VERSION, (ulonglong)vmss.num_vcpus); + hdr.version, (ulonglong)vmss.num_vcpus); fprintf(ofp, "Total memory: %llu\n", (ulonglong)vmss.memsize); - if (vmss.regionscount > 1) { - uint64_t holes_sum = 0; - unsigned i; - fprintf(ofp, "Memory regions[%d]:\n", vmss.regionscount); - fprintf(ofp, " [0x%016x-", 0); - for (i = 0; i < vmss.regionscount - 1; i++) { - fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.regions[i].startpagenum << VMW_PAGE_SHIFT); - fprintf(ofp, " [0x%016llx-", (ulonglong)vmss.regions[i].startppn << VMW_PAGE_SHIFT); - holes_sum += vmss.regions[i].startppn - vmss.regions[i].startpagenum; - } - fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.memsize + (holes_sum << VMW_PAGE_SHIFT)); + fprintf(ofp, "Memory regions[%d]:\n", vmss.regionscount); + fprintf(ofp, " [0x%016x-", 0); + for (i = 0; i < vmss.regionscount - 1; i++) { + fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.regions[i].startpagenum << VMW_PAGE_SHIFT); + fprintf(ofp, " [0x%016llx-", (ulonglong)vmss.regions[i].startppn << VMW_PAGE_SHIFT); + holes_sum += vmss.regions[i].startppn - vmss.regions[i].startpagenum; } + fprintf(ofp, "0x%016llx]\n", (ulonglong)vmss.memsize + (holes_sum << VMW_PAGE_SHIFT)); return TRUE; } -- 2.40.1