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 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; 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

Hi Tao, Thanks for sending the series. Maybe you missed CCing people ? Also this patch's 'author' line is missing, maybe while editing the commit it messed up ? I will proceed with testing the series, might do it later, currently my mails got messed up, I got some mails in Inbox (those patches with me in Cc), and others in my crash-utility folder (those with Cc: crash-utility). Thanks, Aditya Gupta On 28/04/24 09:32, Tao Liu wrote: > Currently for most gdb_interface call, in which a non-null file pointer > is passed, GDB's output stream is replaced with the passed file pointer > > Due to this, 'info threads', which is a gdb passthrough, doesn't print any > thread, after support was added to get registers from crash_target: > > crash> info threads > Id Target Id Frame > > This empty output of 'info threads' was due to a subtle bug in > gdb_interface. > > After this gdb passthrough is run, 'datatype_info' is called, with file > pointer set to null_fp (pointing to /dev/null). And after > 'datatype_info' returns, any output by gdb goes to /dev/null, and hence > the output is lost. > > Fix this by restoring the original output streams, after gdb_interface > has handled the output > > After this patch: > > crash> info threads > Id Target Id Frame > * 1 2131 bash 0xc000000000051e40 in crash_fadump (regs=0x0, str=0xc000000002c60510 <buf> "sysrq triggered crash") at arch/powerpc/kernel/fadump.c:735 > > 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; > Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; > --- > gdb-10.2.patch | 53 ++++++++++++++++++++++++++++++++++++++++++++++++++ > 1 file changed, 53 insertions(+) > > diff --git a/gdb-10.2.patch b/gdb-10.2.patch > index 3694b13..0bed96a 100644 > --- a/gdb-10.2.patch > +++ b/gdb-10.2.patch > @@ -16118,3 +16118,56 @@ exit 0 > subclass (SYMBOL_NONE) > { > /* We can't use an initializer list for members of a base class, and > +--- gdb-10.2/gdb/ui-file.h.orig > ++++ gdb-10.2/gdb/ui-file.h > +@@ -195,6 +195,7 @@ public: > + > + bool can_emit_style_escape () override; > + > ++ FILE *get_stream(void); > + /* Sets the internal stream to FILE, and saves the FILE's file > + descriptor in M_FD. */ > + void set_stream (FILE *file); > +--- gdb-10.2/gdb/ui-file.c.orig > ++++ gdb-10.2/gdb/ui-file.c > +@@ -161,6 +161,12 @@ stdio_file::~stdio_file () > + fclose (m_file); > + } > + > ++FILE* > ++stdio_file::get_stream(void) > ++{ > ++ return m_file; > ++} > ++ > + void > + stdio_file::set_stream (FILE *file) > + { > +--- gdb-10.2/gdb/symtab.c.orig > ++++ gdb-10.2/gdb/symtab.c > +@@ -6964,8 +6964,12 @@ void > + gdb_command_funnel_1(struct gnu_request *req) > + { > + struct symbol *sym; > ++ FILE *original_stdout_stream = nullptr; > ++ FILE *original_stderr_stream = nullptr; > + > + if (req->command != GNU_VERSION && req->command != GNU_USER_PRINT_OPTION) { > ++ original_stdout_stream = (dynamic_cast< stdio_file * >gdb_stdout)->get_stream(); > ++ original_stderr_stream = (dynamic_cast< stdio_file * >gdb_stderr)->get_stream(); > + (dynamic_cast<stdio_file *>gdb_stdout)->set_stream(req->fp); > + (dynamic_cast<stdio_file *>gdb_stderr)->set_stream(req->fp); > + } > +@@ -7068,6 +7072,12 @@ gdb_command_funnel_1(struct gnu_request *req) > + req->flags |= GNU_COMMAND_FAILED; > + break; > + } > ++ > ++ /* Restore the streams gdb output was using */ > ++ if (original_stdout_stream) > ++ (dynamic_cast<stdio_file *>gdb_stdout)->set_stream(original_stdout_stream); > ++ if (original_stderr_stream) > ++ (dynamic_cast<stdio_file *>gdb_stderr)->set_stream(original_stderr_stream); > + } > + > + /*

Hi Tao, On 30/04/24 08:11, Tao Liu wrote: Sure. I meant, the 'Author' of this commit changed, if you notice patch #1, #8. It has a line on top of the patch: "From: Aditya Gupta <adityag(a)linux.ibm.com&gt;&quot; This is not there in patch #6. Whenever the commit's author is different than the mail sender, git format-patch will add this line, and when this patch series is merged, git will take the 'From' here as the author. If you see in your git log of the branch, it will show you as author. This would have happened due to editing, resetting the change, commiting it again, somewhere the Author field got changed automatically. Sure, I will test that Tao. Thanks, Aditya Gupta

Hi Aditya, On Wed, May 1, 2024 at 4:23 PM Tao Liu <ltao(a)redhat.com&gt; wrote: Kindly ping... Any results for your testing? Thanks, Tao Liu

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 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. 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 0c21eb8..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_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() ? @@ -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. 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

Signed-off-by: Tao Liu <ltao(a)redhat.com&gt; --- arm64.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++++--- defs.h | 36 ++++++++++++++++++ 2 files changed, 145 insertions(+), 5 deletions(-) diff --git a/arm64.c b/arm64.c index af0e0d7..5f9be82 100644 --- a/arm64.c +++ b/arm64.c @@ -116,6 +116,23 @@ static void arm64_get_struct_page_size(struct machine_specific *ms); #define mte_tag_reset(addr) (((ulong)addr & ~mte_tag_shifted(KASAN_TAG_KERNEL)) | \ mte_tag_shifted(KASAN_TAG_KERNEL)) +struct user_regs_bitmap_struct { + struct { + union { + struct arm64_user_pt_regs user_regs; + struct { + u64 regs[31]; + u64 sp; + u64 pc; + u64 pstate; + }; + }; + u64 orig_x0; + u64 syscallno; + }; + ulong bitmap; +}; + static inline bool is_mte_kvaddr(ulong addr) { /* check for ARM64_MTE enabled */ @@ -174,6 +191,85 @@ arm64_vmemmap_is_page_ptr(ulong addr, physaddr_t *phys) return FALSE; } +static int +arm64_get_current_task_reg(int regno, const char *name, + int size, void *value) +{ + struct bt_info bt_info, bt_setup; + struct task_context *tc; + struct user_regs_bitmap_struct *ur_bitmap; + ulong ip, sp; + bool ret = FALSE; + + switch (regno) { + case X0_REGNUM ... PC_REGNUM: + break; + default: + return FALSE; + } + + tc = CURRENT_CONTEXT(); + if (!tc) + return FALSE; + BZERO(&bt_setup, sizeof(struct bt_info)); + clone_bt_info(&bt_setup, &bt_info, tc); + fill_stackbuf(&bt_info); + + 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; + + if (!bt_info.need_free) { + goto get_all; + } + switch (ur_bitmap->bitmap) { + case 0x1a0000000: + switch (regno) { + case X29_REGNUM: + case SP_REGNUM: + case PC_REGNUM: + break; + default: + return FALSE; + } + break; + } + +get_all: + switch (regno) { + case X0_REGNUM ... X30_REGNUM: + if (size != sizeof(ur_bitmap->regs[regno])) { + ret = FALSE; break; + } else { + memcpy(value, &ur_bitmap->regs[regno], size); + ret = TRUE; break; + } + case SP_REGNUM: + if (size != sizeof(ur_bitmap->sp)) { + ret = FALSE; break; + } else { + memcpy(value, &ur_bitmap->sp, size); + ret = TRUE; break; + } + case PC_REGNUM: + if (size != sizeof(ur_bitmap->pc)) { + ret = FALSE; break; + } else { + memcpy(value, &ur_bitmap->pc, size); + ret = TRUE; break; + } + } + + if (bt_info.need_free) { + FREEBUF(ur_bitmap); + bt_info.need_free = FALSE; + } + return ret; +} + /* * Do all necessary machine-specific setup here. This is called several times * during initialization. @@ -472,6 +568,7 @@ arm64_init(int when) machdep->dumpfile_init = NULL; machdep->verify_line_number = NULL; machdep->init_kernel_pgd = arm64_init_kernel_pgd; + machdep->get_current_task_reg = arm64_get_current_task_reg; /* use machdep parameters */ arm64_calc_phys_offset(); @@ -3785,6 +3882,7 @@ arm64_get_dumpfile_stackframe(struct bt_info *bt, struct arm64_stackframe *frame try_kernel: frame->sp = ptregs->sp; frame->fp = ptregs->regs[29]; + bt->machdep = ptregs; } if (arm64_in_kdump_text(bt, frame) || @@ -3814,21 +3912,27 @@ static void arm64_get_stack_frame(struct bt_info *bt, ulong *pcp, ulong *spp) { int ret; + struct user_regs_bitmap_struct *ur_bitmap; struct arm64_stackframe stackframe = { 0 }; if (DUMPFILE() && is_task_active(bt->task)) { ret = arm64_get_dumpfile_stackframe(bt, &stackframe); + bt->need_free = FALSE; } else { if (bt->flags & BT_SKIP_IDLE) bt->flags &= ~BT_SKIP_IDLE; ret = arm64_get_stackframe(bt, &stackframe); - } - if (!ret) - error(WARNING, - "cannot determine starting stack frame for task %lx\n", - bt->task); + ur_bitmap = (struct user_regs_bitmap_struct *)GETBUF(sizeof(*ur_bitmap)); + memset(ur_bitmap, 0, sizeof(*ur_bitmap)); + ur_bitmap->pc = stackframe.pc; + ur_bitmap->sp = stackframe.sp; + ur_bitmap->regs[29] = stackframe.fp; + ur_bitmap->bitmap += 0x1a0000000; + bt->machdep = ur_bitmap; + bt->need_free = TRUE; + } bt->frameptr = stackframe.fp; if (pcp) diff --git a/defs.h b/defs.h index fd00462..05d8e14 100644 --- a/defs.h +++ b/defs.h @@ -8073,6 +8073,42 @@ enum x86_64_regnum { LAST_REGNUM }; +enum arm64_regnum { + X0_REGNUM, + X1_REGNUM, + X2_REGNUM, + X3_REGNUM, + X4_REGNUM, + X5_REGNUM, + X6_REGNUM, + X7_REGNUM, + X8_REGNUM, + X9_REGNUM, + X10_REGNUM, + X11_REGNUM, + X12_REGNUM, + X13_REGNUM, + X14_REGNUM, + X15_REGNUM, + X16_REGNUM, + X17_REGNUM, + X18_REGNUM, + X19_REGNUM, + X20_REGNUM, + X21_REGNUM, + X22_REGNUM, + X23_REGNUM, + X24_REGNUM, + X25_REGNUM, + X26_REGNUM, + X27_REGNUM, + X28_REGNUM, + X29_REGNUM, + X30_REGNUM, + SP_REGNUM, + PC_REGNUM, +}; + /* * Register numbers to make crash_target->fetch_registers() * ---> machdep->get_current_task_reg() work properly. -- 2.40.1