3:44 p.m.
This patchset is based on Alexy's work [1], and is the follow-up of the
previous "gdb stack unwinding support for crash utility" patchset.
Currently gdb target analyzes only one task at a time and it backtraces
only straight stack until end of the stack. If stacks were concatenated
during exceptions or interrupts, gdb bt will show only the topmost one.
This patchset will introduce multiple stacks support for gdb stack unwinding,
which can be observed as a different threads from gdb perspective. A
short usage is as follows:
'set <PID>' - to switch to a specific task
'gdb info threads' - to see list of in-kernel stacks of this task.
'gdb thread <ID>' - to switch to the stack.
'gdb bt' - to unwind it.
E.g, with the patchset:
crash> bt
PID: 17636 TASK: ffff88032e0742c0 CPU: 11 COMMAND: "kworker/11:4"
#0 [ffff88037fca6b58] machine_kexec at ffffffff8103cef2
#1 [ffff88037fca6ba8] crash_kexec at ffffffff810c9aa3
#2 [ffff88037fca6c70] panic at ffffffff815f0444
...
#9 [ffff88037fca6ec8] do_nmi at ffffffff815fd980
#10 [ffff88037fca6ef0] end_repeat_nmi at ffffffff815fcec1
[exception RIP: memcpy+13]
RIP: ffffffff812f5b1d RSP: ffff88034f2a9728 RFLAGS: 00010046
RAX: ffffc900139fe000 RBX: ffff880374b7a1b0 RCX: 0000000000000030
RBP: ffff88034f2a9778 R8: 000000007fffffff R9: 00000000ffffffff
...
ORIG_RAX: ffffffffffffffff CS: 0010 SS: 0018
--- <NMI exception stack> ---
#11 [ffff88034f2a9728] memcpy at ffffffff812f5b1d
#12 [ffff88034f2a9728] mga_dirty_update at ffffffffa024ad2b [mgag200]
#13 [ffff88034f2a9780] mga_imageblit at ffffffffa024ae3f [mgag200]
#14 [ffff88034f2a97a0] bit_putcs at ffffffff813424ef
...
crash> info threads
Id Target Id Frame
* 1 17636 kworker/11:4 (stack 0) crash_setup_regs (oldregs=0x0,
newregs=0xffff88037fca6bb0)
2 17636 kworker/11:4 (stack 1) 0xffffffff812f5b1d in memcpy ()
crash> thread 2
crash> gdb bt
#0 0xffffffff812f5b1d in memcpy () at arch/x86/lib/memcpy_64.S:69
...
There are 2 stacks of the current task, and we can list/switch-to/unwind
each stack.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01204.html
v2 -> v1: 1) Rebase this patchset onto gdb-16.2 [2].
2) Improved the silent_call_bt() to catch the error FATAL.
[2]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01354.html
Tao Liu (5):
Add multi-threads support in crash target
Call cmd_bt silently after "set pid"
x86_64: Add gdb multi-stack unwind support
arm64: Add gdb multi-stack unwind support
ppc64: Add gdb multi-stack unwind support
arm64.c | 85 +++++++++++++++++++++++++++++++--
crash_target.c | 49 +++++++++++++++++--
defs.h | 3 +-
gdb_interface.c | 6 +--
kernel.c | 43 +++++++++++++++++
ppc64.c | 70 +++++++++++++++++++++++----
task.c | 4 +-
x86_64.c | 123 +++++++++++++++++++++++++++++++++++++++++++++---
8 files changed, 354 insertions(+), 29 deletions(-)
--
2.47.0
3:44 p.m.
New subject: [PATCH v2 1/5] Add multi-threads support in crash target
Previously, only one thread is created in crash target by [1]. And this one
thread will work as the common container for different tasks whenever
"set <pid>" to it. Its tid number is 0 and will never be deleted.
In order to support multi-stacks, we enable multi-threads in crash
target. Each thread will represent one stack, and "info threads" will
list all available stacks, "thread <id>" will switch to it.
Since multi-stacks is task binded, each task switching will trigger
a thread delete of those tid number other than 0. In addition, we will
pass the tid number to each arch's get_current_task_reg(), in order to
retrive the regs value of the specific stack.
[1]: https://www.mail-archive.com/devel@lists.crash-utility.osci.io/msg01085.html
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
arm64.c | 2 +-
crash_target.c | 42 +++++++++++++++++++++++++++++++++++++++---
defs.h | 3 ++-
gdb_interface.c | 6 +++---
ppc64.c | 4 ++--
x86_64.c | 4 ++--
6 files changed, 49 insertions(+), 12 deletions(-)
diff --git a/arm64.c b/arm64.c
index ef4a2b8..1cdde5f 100644
--- a/arm64.c
+++ b/arm64.c
@@ -204,7 +204,7 @@ out:
static int
arm64_get_current_task_reg(int regno, const char *name,
- int size, void *value)
+ int size, void *value, int sid)
{
struct bt_info bt_info, bt_setup;
struct task_context *tc;
diff --git a/crash_target.c b/crash_target.c
index 5966b7b..71998ef 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -27,8 +27,9 @@ void crash_target_init (void);
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);
+ int regsize, void *val, int sid);
extern "C" int gdb_change_thread_context (void);
+extern "C" int gdb_add_substack (int);
extern "C" void crash_get_current_task_info(unsigned long *pid, char **comm);
/* The crash target. */
@@ -66,7 +67,12 @@ public:
crash_get_current_task_info(&pid, &comm);
return string_printf ("%ld %s", pid, comm);
}
-
+ const char *extra_thread_info (thread_info *tp) override
+ {
+ static char buf[16] = {0};
+ snprintf(buf, sizeof(buf), "stack %ld", tp->ptid.tid());
+ return buf;
+ }
};
static void supply_registers(struct regcache *regcache, int regno)
@@ -79,7 +85,7 @@ static void supply_registers(struct regcache *regcache, int regno)
if (regsize > sizeof (regval))
error (_("fatal error: buffer size is not enough to fit register value"));
- if (crash_get_current_task_reg (regno, regname, regsize, (void *)®val))
+ if (crash_get_current_task_reg (regno, regname, regsize, (void *)®val,
inferior_thread()->ptid.tid()))
regcache->raw_supply (regno, regval);
else
regcache->raw_supply (regno, NULL);
@@ -144,7 +150,37 @@ crash_target_init (void)
extern "C" int
gdb_change_thread_context (void)
{
+ /* 1st, switch to tid 0 if we are not */
+ if (inferior_thread()->ptid.tid()) {
+ switch_to_thread (&(current_inferior()->thread_list.front()));
+ }
+ /* 2nd, delete threads whose tid is not 0 */
+ for (thread_info *tp : current_inferior()->threads_safe()) {
+ if (tp->ptid.tid() && tp->deletable()) {
+ delete_thread_silent(tp);
+ current_inferior()->highest_thread_num--;
+ }
+ }
+ /* 3rd, refresh regcache for tid 0 */
target_fetch_registers(get_thread_regcache(inferior_thread()), -1);
reinit_frame_cache();
return TRUE;
}
+
+/* Add a thread for each additional stack. Use stack ID as a thread ID */
+extern "C" int
+gdb_add_substack (int sid)
+{
+ thread_info *tp;
+ thread_info *current_thread = inferior_thread();
+
+ ptid_t ptid = ptid_t(CRASH_INFERIOR_PID, 0, sid + 1);
+ tp = current_inferior()->find_thread(ptid);
+ if (tp == nullptr) {
+ tp = add_thread_silent(current_inferior()->process_target(), ptid);
+ }
+ switch_to_thread (tp);
+ target_fetch_registers(get_thread_regcache(tp), -1);
+ switch_to_thread (current_thread);
+ return TRUE;
+}
\ No newline at end of file
diff --git a/defs.h b/defs.h
index 2ffa44e..eaa3af8 100644
--- a/defs.h
+++ b/defs.h
@@ -1075,7 +1075,7 @@ struct machdep_table {
void (*get_irq_affinity)(int);
void (*show_interrupts)(int, ulong *);
int (*is_page_ptr)(ulong, physaddr_t *);
- int (*get_current_task_reg)(int, const char *, int, void *);
+ int (*get_current_task_reg)(int, const char *, int, void *, int);
int (*is_cpu_prstatus_valid)(int cpu);
};
@@ -8163,5 +8163,6 @@ enum ppc64_regnum {
/* crash_target.c */
extern int gdb_change_thread_context (void);
+extern int gdb_add_substack (int);
#endif /* !GDB_COMMON */
diff --git a/gdb_interface.c b/gdb_interface.c
index fa2e85b..9f76f85 100644
--- a/gdb_interface.c
+++ b/gdb_interface.c
@@ -1076,13 +1076,13 @@ unsigned long crash_get_kaslr_offset(void)
/* Callbacks for crash_target */
int crash_get_current_task_reg (int regno, const char *regname,
- int regsize, void *value);
+ int regsize, void *value, int sid);
int crash_get_current_task_reg (int regno, const char *regname,
- int regsize, void *value)
+ int regsize, void *value, int sid)
{
if (!machdep->get_current_task_reg)
return FALSE;
- return machdep->get_current_task_reg(regno, regname, regsize, value);
+ return machdep->get_current_task_reg(regno, regname, regsize, value, sid);
}
/* arm64 kernel lr maybe has patuh */
diff --git a/ppc64.c b/ppc64.c
index 782107b..7ac12fe 100644
--- a/ppc64.c
+++ b/ppc64.c
@@ -56,7 +56,7 @@ static char * ppc64_check_eframe(struct ppc64_pt_regs *);
static void ppc64_print_eframe(char *, struct ppc64_pt_regs *,
struct bt_info *);
static int ppc64_get_current_task_reg(int regno, const char *name, int size,
- void *value);
+ void *value, int);
static void parse_cmdline_args(void);
static int ppc64_paca_percpu_offset_init(int);
static void ppc64_init_cpu_info(void);
@@ -2512,7 +2512,7 @@ ppc64_print_eframe(char *efrm_str, struct ppc64_pt_regs *regs,
static int
ppc64_get_current_task_reg(int regno, const char *name, int size,
- void *value)
+ void *value, int sid)
{
struct bt_info bt_info, bt_setup;
struct task_context *tc;
diff --git a/x86_64.c b/x86_64.c
index d4bbd15..a46fb9d 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_current_task_reg(int, const char *, int, void *);
+static int x86_64_get_current_task_reg(int, const char *, int, void *, int);
static int x86_64_verify_paddr(uint64_t);
static void GART_init(void);
static void x86_64_exception_stacks_init(void);
@@ -9233,7 +9233,7 @@ x86_64_get_kvaddr_ranges(struct vaddr_range *vrp)
static int
x86_64_get_current_task_reg(int regno, const char *name,
- int size, void *value)
+ int size, void *value, int sid)
{
struct bt_info bt_info, bt_setup;
struct task_context *tc;
--
2.47.0
3:44 p.m.
New subject: [PATCH v2 2/5] Call cmd_bt silently after "set pid"
Cmd bt will list multi-stacks of one task. After we "set <pid>" switch
context to one task, we first need a bt call to detect the multi-stacks,
however we don't want any console output from it, so a nullfp is used for
output receive. The silent bt call is only triggered once as part of task
context switch by cmd set.
A array of user_regs pointers is reserved for each supported arch. If one
extra stack found, a user_regs structure will be allocated for storing regs
value of the stack.
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
arm64.c | 4 ++++
crash_target.c | 7 +++++++
kernel.c | 43 +++++++++++++++++++++++++++++++++++++++++++
ppc64.c | 4 ++++
task.c | 4 ++--
x86_64.c | 3 +++
6 files changed, 63 insertions(+), 2 deletions(-)
diff --git a/arm64.c b/arm64.c
index 1cdde5f..8291301 100644
--- a/arm64.c
+++ b/arm64.c
@@ -126,6 +126,10 @@ struct user_regs_bitmap_struct {
ulong bitmap[32];
};
+#define MAX_EXCEPTION_STACKS 7
+ulong extra_stacks_idx = 0;
+struct user_regs_bitmap_struct *extra_stacks_regs[MAX_EXCEPTION_STACKS] = {0};
+
static inline bool is_mte_kvaddr(ulong addr)
{
/* check for ARM64_MTE enabled */
diff --git a/crash_target.c b/crash_target.c
index 71998ef..ad1480c 100644
--- a/crash_target.c
+++ b/crash_target.c
@@ -31,6 +31,9 @@ extern "C" int crash_get_current_task_reg (int regno, const
char *regname,
extern "C" int gdb_change_thread_context (void);
extern "C" int gdb_add_substack (int);
extern "C" void crash_get_current_task_info(unsigned long *pid, char **comm);
+#if defined (X86_64) || defined (ARM64) || defined (PPC64)
+extern "C" void silent_call_bt(void);
+#endif
/* The crash target. */
@@ -164,6 +167,10 @@ gdb_change_thread_context (void)
/* 3rd, refresh regcache for tid 0 */
target_fetch_registers(get_thread_regcache(inferior_thread()), -1);
reinit_frame_cache();
+#if defined (X86_64) || defined (ARM64) || defined (PPC64)
+ /* 4th, invoke bt silently to refresh the additional stacks */
+ silent_call_bt();
+#endif
return TRUE;
}
diff --git a/kernel.c b/kernel.c
index 612b956..18b125c 100644
--- a/kernel.c
+++ b/kernel.c
@@ -12002,3 +12002,46 @@ int get_linux_banner_from_vmlinux(char *buf, size_t size)
return TRUE;
}
+
+#if defined(X86_64) || defined(ARM64) || defined(PPC64)
+extern ulong extra_stacks_idx;
+extern void *extra_stacks_regs[];
+void silent_call_bt(void)
+{
+ jmp_buf main_loop_env_save;
+ unsigned long long flags_save = pc->flags;
+ FILE *fp_save = fp;
+ FILE *error_fp_save = pc->error_fp;
+ /* Redirect all cmd_bt() outputs into null */
+ fp = pc->nullfp;
+ pc->error_fp = pc->nullfp;
+
+ for (int i = 0; i < extra_stacks_idx; i++) {
+ /* Note: GETBUF/FREEBUF is not applicable for extra_stacks_regs,
+ because we are reserving extra_stacks_regs by cmd_bt()
+ for later use. But GETBUF/FREEBUF is designed for use only
+ within one cmd. See process_command_line() -> restore_sanity()
+ -> free_all_bufs(). So we use malloc/free instead. */
+ free(extra_stacks_regs[i]);
+ extra_stacks_regs[i] = NULL;
+ }
+ /* Prepare args used by cmd_bt() */
+ sprintf(pc->command_line, "bt\n");
+ argcnt = parse_line(pc->command_line, args);
+ optind = 1;
+ pc->flags |= RUNTIME;
+
+ /* Catch error FATAL generated by cmd_bt() if any */
+ memcpy(&main_loop_env_save, &pc->main_loop_env, sizeof(jmp_buf));
+ if (setjmp(pc->main_loop_env)) {
+ goto out;
+ }
+ cmd_bt();
+out:
+ /* Restore all */
+ memcpy(&pc->main_loop_env, &main_loop_env_save, sizeof(jmp_buf));
+ pc->flags = flags_save;
+ fp = fp_save;
+ pc->error_fp = error_fp_save;
+}
+#endif
diff --git a/ppc64.c b/ppc64.c
index 7ac12fe..532eb3f 100644
--- a/ppc64.c
+++ b/ppc64.c
@@ -80,6 +80,10 @@ struct user_regs_bitmap_struct {
ulong bitmap[32];
};
+#define MAX_EXCEPTION_STACKS 7
+ulong extra_stacks_idx = 0;
+struct user_regs_bitmap_struct *extra_stacks_regs[MAX_EXCEPTION_STACKS] = {0};
+
static int is_opal_context(ulong sp, ulong nip)
{
uint64_t opal_start, opal_end;
diff --git a/task.c b/task.c
index 49f771e..869f584 100644
--- a/task.c
+++ b/task.c
@@ -3061,7 +3061,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, TRUE);
+ set_context(curtask, NO_PID, FALSE);
sort_context_by_task();
}
@@ -3108,7 +3108,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, TRUE);
+ set_context(curtask, NO_PID, FALSE);
sort_context_by_task();
}
diff --git a/x86_64.c b/x86_64.c
index a46fb9d..ee23d8b 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -160,6 +160,9 @@ struct user_regs_bitmap_struct {
ulong bitmap[32];
};
+ulong extra_stacks_idx = 0;
+struct user_regs_bitmap_struct *extra_stacks_regs[MAX_EXCEPTION_STACKS] = {0};
+
/*
* Do all necessary machine-specific setup here. This is called several
* times during initialization.
--
2.47.0
3:44 p.m.
New subject: [PATCH v2 3/5] x86_64: Add gdb multi-stack unwind support
Whenever extra stack is found, a user_regs structure is allocated and
regs value copied there. Later the values will be retrived by
get_current_task_reg() by given the thread's tid, aka the index of
stack.
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
x86_64.c | 116 ++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 111 insertions(+), 5 deletions(-)
diff --git a/x86_64.c b/x86_64.c
index ee23d8b..e5fbccf 100644
--- a/x86_64.c
+++ b/x86_64.c
@@ -3508,6 +3508,9 @@ x86_64_exception_RIP_message(struct bt_info *bt, ulong rip)
#define STACK_TRANSITION_ERRMSG_I_P \
"cannot transition from IRQ stack to current process stack:\n IRQ stack
pointer: %lx\n process stack pointer: %lx\n current stack base: %lx\n"
+#define SET_REG_BITMAP(REGMAP, TYPE, MEMBER) \
+ SET_BIT(REGMAP, REG_SEQ(TYPE, MEMBER))
+
/*
* Low-budget back tracer -- dump text return addresses, following call chain
* when possible, along with any verifiable exception frames.
@@ -3528,6 +3531,7 @@ x86_64_low_budget_back_trace_cmd(struct bt_info *bt_in)
ulong last_process_stack_eframe;
ulong user_mode_eframe;
char *rip_symbol;
+ char buf[BUFSIZE];
/*
* User may have made a run-time switch.
@@ -3551,6 +3555,7 @@ x86_64_low_budget_back_trace_cmd(struct bt_info *bt_in)
irq_eframe = 0;
last_process_stack_eframe = 0;
bt->call_target = NULL;
+ extra_stacks_idx = 0;
rsp = bt->stkptr;
ms = machdep->machspec;
@@ -3632,6 +3637,81 @@ x86_64_low_budget_back_trace_cmd(struct bt_info *bt_in)
level++;
}
+ if (is_task_active(bt->task) && bt->flags & BT_DUMPFILE_SEARCH) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] =
+ (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ extra_stacks_regs[extra_stacks_idx]->ur.ip = bt->instptr;
+ extra_stacks_regs[extra_stacks_idx]->ur.sp = bt->stkptr + 8;
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, ip);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, sp);
+
+ /* Sometimes bp is needed for stack unwinding, so we try to get
+ it. The bt->instptr usually points to a inst after a call
+ inst, let's check the previous call inst. Note the call inst
+ len is 5 */
+ open_tmpfile2();
+ sprintf(buf, "x/1i 0x%lx", bt->instptr - 5);
+ gdb_pass_through(buf, pc->tmpfile2, GNU_RETURN_ON_ERROR);
+ rewind(pc->tmpfile2);
+ fgets(buf, BUFSIZE, pc->tmpfile2);
+ if (strstr(buf, "call")) {
+ if (strstr(buf, "<relocate_range>") ||
+ strstr(buf, "<relocate_kernel>")) {
+ /* OK, we are calling relocate_kernel(), which
+ * is written in assembly and hasn't changed for
+ * years, so we get some extra regs out of it. */
+ readmem(bt->stkptr - sizeof(ulong) * 6, KVADDR, buf,
+ sizeof(ulong) * 6, "relocate_kernel", FAULT_ON_ERROR);
+ extra_stacks_regs[extra_stacks_idx]->ur.r15 =
+ *(ulong *)(buf + sizeof(ulong) * 0);
+ extra_stacks_regs[extra_stacks_idx]->ur.r14 =
+ *(ulong *)(buf + sizeof(ulong) * 1);
+ extra_stacks_regs[extra_stacks_idx]->ur.r13 =
+ *(ulong *)(buf + sizeof(ulong) * 2);
+ extra_stacks_regs[extra_stacks_idx]->ur.r12 =
+ *(ulong *)(buf + sizeof(ulong) * 3);
+ extra_stacks_regs[extra_stacks_idx]->ur.bp =
+ *(ulong *)(buf + sizeof(ulong) * 4);
+ extra_stacks_regs[extra_stacks_idx]->ur.bx =
+ *(ulong *)(buf + sizeof(ulong) * 5);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, r15);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, r14);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, r13);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, r12);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, bp);
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, bx);
+ } else {
+ /* This is a try-best effort. Usually the call
+ inst will result in a next-inst addr pushed
+ in and a rbp push of the calling function.
+ So we can get rbp here */
+ readmem(extra_stacks_regs[extra_stacks_idx]->ur.sp
+ - sizeof(ulong) * 2, KVADDR,
+ &extra_stacks_regs[extra_stacks_idx]->ur.bp,
+ sizeof(ulong), "extra_stacks_regs.bp", FAULT_ON_ERROR);
+ if (INSTACK(extra_stacks_regs[extra_stacks_idx]->ur.bp, bt)) {
+ SET_REG_BITMAP(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ x86_64_user_regs_struct, bp);
+ extra_stacks_regs[extra_stacks_idx]->ur.ip -= 5;
+ }
+ }
+ }
+ close_tmpfile2();
+ gdb_add_substack(extra_stacks_idx++);
+ }
if ((estack = x86_64_in_exception_stack(bt, &estack_index))) {
in_exception_stack:
@@ -4159,6 +4239,7 @@ x86_64_dwarf_back_trace_cmd(struct bt_info *bt_in)
last_process_stack_eframe = 0;
bt->call_target = NULL;
bt->bptr = 0;
+ extra_stacks_idx = 0;
rsp = bt->stkptr;
if (!rsp) {
error(INFO, "cannot determine starting stack pointer\n");
@@ -4799,6 +4880,26 @@ x86_64_exception_frame(ulong flags, ulong kvaddr, char *local,
} else if (machdep->flags & ORC)
bt->bptr = rbp;
+ /*
+ * Preserve registers set for each additional in-kernel stack
+ */
+ if (!(cs & 3) && verified && flags & EFRAME_PRINT &&
+ extra_stacks_idx < MAX_EXCEPTION_STACKS &&
+ (!bt->machdep ||
+ bt->eframe_ip != ((struct user_regs_bitmap_struct *)bt->machdep)->ur.ip))
{
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] = (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ memcpy(&extra_stacks_regs[extra_stacks_idx]->ur,
+ pt_regs_buf, SIZE(pt_regs));
+ for (int i = 0; i < SIZE(pt_regs)/sizeof(long); i++)
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap, i);
+ gdb_add_substack(extra_stacks_idx++);
+ }
+
if (kvaddr)
FREEBUF(pt_regs_buf);
@@ -5002,9 +5103,6 @@ get_reg_from_inactive_task_frame(struct bt_info *bt, char
*reg_name,
return reg_value;
}
-#define SET_REG_BITMAP(REGMAP, TYPE, MEMBER) \
- SET_BIT(REGMAP, REG_SEQ(TYPE, MEMBER))
-
/*
* Get a stack frame combination of pc and ra from the most relevent spot.
*/
@@ -9221,7 +9319,8 @@ x86_64_get_kvaddr_ranges(struct vaddr_range *vrp)
case R##_REGNUM: \
if (!NUM_IN_BITMAP(ur_bitmap->bitmap, \
REG_SEQ(x86_64_user_regs_struct, r))) { \
- FREEBUF(ur_bitmap); \
+ if (!sid) \
+ FREEBUF(ur_bitmap); \
return FALSE; \
} \
break;
@@ -9256,6 +9355,12 @@ x86_64_get_current_task_reg(int regno, const char *name,
if (!tc)
return FALSE;
+ /* Non zero stack ID, use extra stacks regs */
+ if (sid && sid <= extra_stacks_idx) {
+ ur_bitmap = extra_stacks_regs[sid - 1];
+ goto get_sub;
+ }
+
/*
* Task is active, grab CPU's registers
*/
@@ -9280,6 +9385,7 @@ x86_64_get_current_task_reg(int regno, const char *name,
}
/* Get subset registers from stack frame*/
+get_sub:
switch (regno) {
CHECK_REG_CASE(RAX, ax);
CHECK_REG_CASE(RBX, bx);
@@ -9341,7 +9447,7 @@ get_all:
COPY_REG_CASE(ORIG_RAX, orig_ax);
}
- if (bt_info.need_free) {
+ if (!sid && bt_info.need_free) {
FREEBUF(ur_bitmap);
bt_info.need_free = FALSE;
}
--
2.47.0
3:44 p.m.
New subject: [PATCH v2 4/5] arm64: Add gdb multi-stack unwind support
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
arm64.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 75 insertions(+), 4 deletions(-)
diff --git a/arm64.c b/arm64.c
index 8291301..53cbf48 100644
--- a/arm64.c
+++ b/arm64.c
@@ -226,6 +226,12 @@ arm64_get_current_task_reg(int regno, const char *name,
tc = CURRENT_CONTEXT();
if (!tc)
return FALSE;
+
+ if (sid && sid <= extra_stacks_idx) {
+ ur_bitmap = extra_stacks_regs[extra_stacks_idx - 1];
+ goto get_sub;
+ }
+
BZERO(&bt_setup, sizeof(struct bt_info));
clone_bt_info(&bt_setup, &bt_info, tc);
fill_stackbuf(&bt_info);
@@ -241,25 +247,29 @@ arm64_get_current_task_reg(int regno, const char *name,
goto get_all;
}
+get_sub:
switch (regno) {
case X0_REGNUM ... X30_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(arm64_pt_regs, regs[0]) + regno - X0_REGNUM)) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case SP_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(arm64_pt_regs, sp))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case PC_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(arm64_pt_regs, pc))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
@@ -287,7 +297,7 @@ get_all:
break;
}
- if (bt_info.need_free) {
+ if (!sid && bt_info.need_free) {
FREEBUF(ur_bitmap);
bt_info.need_free = FALSE;
}
@@ -3680,6 +3690,7 @@ arm64_back_trace_cmd(struct bt_info *bt)
int level;
ulong exception_frame;
FILE *ofp;
+ extra_stacks_idx = 0;
if (bt->flags & BT_OPT_BACK_TRACE) {
if (machdep->flags & UNW_4_14) {
@@ -3733,6 +3744,29 @@ arm64_back_trace_cmd(struct bt_info *bt)
stackframe.fp = bt->frameptr;
}
+ if (is_task_active(bt->task)) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] = (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ if (bt->task != tt->panic_task && stackframe.sp) {
+ readmem(stackframe.sp - 8, KVADDR,
&extra_stacks_regs[extra_stacks_idx]->ur.pc,
+ sizeof(ulong), "extra_stacks_regs.pc", RETURN_ON_ERROR);
+ readmem(stackframe.sp - 16, KVADDR,
&extra_stacks_regs[extra_stacks_idx]->ur.sp,
+ sizeof(ulong), "extra_stacks_regs.sp", RETURN_ON_ERROR);
+ } else {
+ extra_stacks_regs[extra_stacks_idx]->ur.pc = stackframe.pc;
+ extra_stacks_regs[extra_stacks_idx]->ur.sp = stackframe.sp;
+ }
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(arm64_pt_regs, pc));
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(arm64_pt_regs, sp));
+ gdb_add_substack (extra_stacks_idx++);
+ }
+
if (bt->flags & BT_TEXT_SYMBOLS) {
arm64_print_text_symbols(bt, &stackframe, ofp);
if (BT_REFERENCE_FOUND(bt)) {
@@ -3854,6 +3888,29 @@ arm64_back_trace_cmd_v2(struct bt_info *bt)
stackframe.fp = bt->frameptr;
}
+ if (is_task_active(bt->task)) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] = (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ if (bt->task != tt->panic_task && stackframe.sp) {
+ readmem(stackframe.sp - 8, KVADDR,
&extra_stacks_regs[extra_stacks_idx]->ur.pc,
+ sizeof(ulong), "extra_stacks_regs.pc", RETURN_ON_ERROR);
+ readmem(stackframe.sp - 16, KVADDR,
&extra_stacks_regs[extra_stacks_idx]->ur.sp,
+ sizeof(ulong), "extra_stacks_regs.sp", RETURN_ON_ERROR);
+ } else {
+ extra_stacks_regs[extra_stacks_idx]->ur.pc = stackframe.pc;
+ extra_stacks_regs[extra_stacks_idx]->ur.sp = stackframe.sp;
+ }
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(arm64_pt_regs, pc));
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(arm64_pt_regs, sp));
+ gdb_add_substack (extra_stacks_idx++);
+ }
+
if (bt->flags & BT_TEXT_SYMBOLS) {
arm64_print_text_symbols(bt, &stackframe, ofp);
if (BT_REFERENCE_FOUND(bt)) {
@@ -4468,6 +4525,20 @@ arm64_print_exception_frame(struct bt_info *bt, ulong pt_regs, int
mode, FILE *o
fprintf(ofp, "ORIG_X0: %016lx SYSCALLNO: %lx",
(ulong)regs->orig_x0, (ulong)regs->syscallno);
fprintf(ofp, " PSTATE: %08lx\n", (ulong)regs->pstate);
+ } else if (!bt->machdep ||
+ regs->pc != ((struct user_regs_bitmap_struct *)bt->machdep)->ur.pc) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] =
+ (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ memcpy(&extra_stacks_regs[extra_stacks_idx]->ur, regs,
+ sizeof(struct arm64_pt_regs));
+ for (int i = 0; i < sizeof(struct arm64_pt_regs)/sizeof(long); i++)
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap, i);
+ gdb_add_substack (extra_stacks_idx++);
}
}
--
2.47.0
3:44 p.m.
New subject: [PATCH v2 5/5] ppc64: Add gdb multi-stack unwind support
Co-developed-by: Alexey Makhalov <alexey.makhalov(a)broadcom.com>
Co-developed-by: Tao Liu <ltao(a)redhat.com>
Signed-off-by: Tao Liu <ltao(a)redhat.com>
---
ppc64.c | 62 +++++++++++++++++++++++++++++++++++++++++++++++++++------
1 file changed, 56 insertions(+), 6 deletions(-)
diff --git a/ppc64.c b/ppc64.c
index 532eb3f..3b74c95 100644
--- a/ppc64.c
+++ b/ppc64.c
@@ -2053,6 +2053,7 @@ ppc64_back_trace_cmd(struct bt_info *bt)
char buf[BUFSIZE];
struct gnu_request *req;
extern void print_stack_text_syms(struct bt_info *, ulong, ulong);
+ extra_stacks_idx = 0;
bt->flags |= BT_EXCEPTION_FRAME;
@@ -2071,6 +2072,26 @@ ppc64_back_trace_cmd(struct bt_info *bt)
req->pc = bt->instptr;
req->sp = bt->stkptr;
+ if (is_task_active(bt->task)) {
+ struct ppc64_pt_regs *pr = (struct ppc64_pt_regs *)bt->machdep;
+ if (pr->nip != req->pc && pr->gpr[1] != req->sp) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] =
+ (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ extra_stacks_regs[extra_stacks_idx]->ur.nip = req->pc;
+ extra_stacks_regs[extra_stacks_idx]->ur.gpr[1] = req->sp;
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(ppc64_pt_regs, nip));
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap,
+ REG_SEQ(ppc64_pt_regs, gpr[0]) + 1);
+ gdb_add_substack (extra_stacks_idx++);
+ }
+ }
+
if (bt->flags &
(BT_TEXT_SYMBOLS|BT_TEXT_SYMBOLS_PRINT|BT_TEXT_SYMBOLS_NOPRINT)) {
if (!INSTACK(req->sp, bt))
@@ -2512,6 +2533,23 @@ ppc64_print_eframe(char *efrm_str, struct ppc64_pt_regs *regs,
fprintf(fp, " %s [%lx] exception frame:\n", efrm_str, regs->trap);
ppc64_print_regs(regs);
ppc64_print_nip_lr(regs, 1);
+
+ if (!((regs->msr >> MSR_PR_LG) & 0x1) &&
+ (!bt->machdep ||
+ regs->nip != ((struct user_regs_bitmap_struct *)bt->machdep)->ur.nip)) {
+ if (!extra_stacks_regs[extra_stacks_idx]) {
+ extra_stacks_regs[extra_stacks_idx] =
+ (struct user_regs_bitmap_struct *)
+ malloc(sizeof(struct user_regs_bitmap_struct));
+ }
+ memset(extra_stacks_regs[extra_stacks_idx], 0,
+ sizeof(struct user_regs_bitmap_struct));
+ memcpy(&extra_stacks_regs[extra_stacks_idx]->ur, regs,
+ sizeof(struct ppc64_pt_regs));
+ for (int i = 0; i < sizeof(struct ppc64_pt_regs)/sizeof(ulong); i++)
+ SET_BIT(extra_stacks_regs[extra_stacks_idx]->bitmap, i);
+ gdb_add_substack (extra_stacks_idx++);
+ }
}
static int
@@ -2552,6 +2590,12 @@ ppc64_get_current_task_reg(int regno, const char *name, int size,
tc = CURRENT_CONTEXT();
if (!tc)
return FALSE;
+
+ if (sid && sid <= extra_stacks_idx) {
+ ur_bitmap = extra_stacks_regs[sid - 1];
+ goto get_sub;
+ }
+
BZERO(&bt_setup, sizeof(struct bt_info));
clone_bt_info(&bt_setup, &bt_info, tc);
fill_stackbuf(&bt_info);
@@ -2570,39 +2614,45 @@ ppc64_get_current_task_reg(int regno, const char *name, int size,
goto get_all;
}
+get_sub:
switch (regno) {
case PPC64_R0_REGNUM ... PPC64_R31_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(ppc64_pt_regs, gpr[0]) + regno - PPC64_R0_REGNUM)) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case PPC64_PC_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(ppc64_pt_regs, nip))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case PPC64_MSR_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(ppc64_pt_regs, msr))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case PPC64_LR_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(ppc64_pt_regs, link))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
case PPC64_CTR_REGNUM:
if (!NUM_IN_BITMAP(ur_bitmap->bitmap,
REG_SEQ(ppc64_pt_regs, ctr))) {
- FREEBUF(ur_bitmap);
+ if (!sid)
+ FREEBUF(ur_bitmap);
return FALSE;
}
break;
@@ -2645,7 +2695,7 @@ get_all:
ret = TRUE;
break;
}
- if (bt_info.need_free) {
+ if (!sid && bt_info.need_free) {
FREEBUF(ur_bitmap);
bt_info.need_free = FALSE;
}
--
2.47.0
17
days inactive
87
days old
devel@lists.crash-utility.osci.io
5 comments
1 participants
participants (1)
-
Alexey Makhalov -
Tao Liu