LoongArch saves the exception return address in CSR.ERA. The crash LoongArch64 code currently labels this field as EPC in register and exception-frame output. That is misleading when comparing crash output with the architecture documentation and the kernel pt_regs layout. Rename the displayed field to ERA and fix the CSR.EUEN label while updating the same output block. This is a display-only change and does not alter how the saved exception return address is collected or used by the unwinder. Signed-off-by: Ming Wang <wangming01(a)loongson.cn&gt; --- loongarch64.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/loongarch64.c b/loongarch64.c index b0ebf8b1d99e..830c81826ebd 100644 --- a/loongarch64.c +++ b/loongarch64.c @@ -688,7 +688,7 @@ loongarch64_dump_exception_stack(struct bt_info *bt, char *pt_regs) } value_to_symstr(regs->csr_epc, buf, 16); - fprintf(fp, " epc : %016lx %s\n", regs->csr_epc, buf); + fprintf(fp, " era : %016lx %s\n", regs->csr_epc, buf); value_to_symstr(regs->regs[LOONGARCH64_EF_RA], buf, 16); fprintf(fp, " ra : %016lx %s\n", regs->regs[LOONGARCH64_EF_RA], buf); @@ -1346,10 +1346,10 @@ loongarch64_display_regs_from_elf_notes(int cpu, FILE *ofp) " R24: %016lx R25: %016lx R26: %016lx\n" " R27: %016lx R28: %016lx R29: %016lx\n" " R30: %016lx R31: %016lx\n" - " CSR epc : %016lx CSR badv: %016lx\n" + " CSR era : %016lx CSR badv: %016lx\n" " CSR crmd: %08lx CSR prmd: %08lx\n" " CSR ecfg: %08lx CSR estat: %08lx\n" - " CSR eneu: %08lx", + " CSR euen: %08lx", regs->regs[LOONGARCH64_EF_R0], regs->regs[LOONGARCH64_EF_R0 + 1], regs->regs[LOONGARCH64_EF_R0 + 2], -- 2.43.0

LoongArch kernels can provide ORC unwind tables. Without consuming those tables, crash falls back to a small prologue scanner, which is fragile around exception entries and functions whose frame layout does not match the simple scanner. Add initial support for reading the kernel ORC IP table, lookup table and orc_entry records, and use them while unwinding LoongArch64 kernel text frames. The unwinder handles CALL and REGS entries, carries frame-pointer state, and normalizes relocated exception-vector PCs before using them as unwind targets. For CALL entries, convert the saved return address back to the call instruction address before validation, matching the kernel unwinder convention. This avoids looking up the instruction after the call as the caller frame. This intentionally covers core kernel text first. Module and ftrace ORC handling can be added separately. Signed-off-by: Ming Wang <wangming01(a)loongson.cn&gt; --- defs.h | 25 ++++ loongarch64.c | 356 +++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 378 insertions(+), 3 deletions(-) diff --git a/defs.h b/defs.h index 6373ee1831af..30ad1ef0e0ea 100644 --- a/defs.h +++ b/defs.h @@ -7330,6 +7330,30 @@ void loongarch64_dump_machdep_table(ulong); #define KSYMS_START (0x1) +struct loongarch64_orc_entry { + short sp_offset; + short fp_offset; + short ra_offset; + uint sp_reg; + uint fp_reg; + uint ra_reg; + uint type; + uint signal; +}; + +struct loongarch64_ORC_data { + int enabled; + uint lookup_num_blocks; + ulong __start_orc_unwind_ip; + ulong __stop_orc_unwind_ip; + ulong __start_orc_unwind; + ulong __stop_orc_unwind; + ulong orc_lookup; + ulong ip_entry; + ulong orc_entry; + struct loongarch64_orc_entry orc_entry_data; +}; + struct machine_specific { ulong phys_base; ulong vmalloc_start_addr; @@ -7337,6 +7361,7 @@ struct machine_specific { ulong modules_end; struct loongarch64_pt_regs *crash_task_regs; + struct loongarch64_ORC_data orc; }; /* diff --git a/loongarch64.c b/loongarch64.c index 0b108e062b2e..2e9e28602b9b 100644 --- a/loongarch64.c +++ b/loongarch64.c @@ -41,8 +41,33 @@ struct loongarch64_unwind_frame { unsigned long sp; unsigned long pc; unsigned long ra; + unsigned long fp; }; +typedef struct __attribute__((__packed__)) { + short sp_offset; + short fp_offset; + short ra_offset; + unsigned int sp_reg:4; + unsigned int fp_reg:4; + unsigned int ra_reg:4; + unsigned int type:3; + unsigned int signal:1; +} loongarch64_kernel_orc_entry; + +#define LOONGARCH64_ORC_REG_UNDEFINED 0 +#define LOONGARCH64_ORC_REG_PREV_SP 1 +#define LOONGARCH64_ORC_REG_SP 2 +#define LOONGARCH64_ORC_REG_FP 3 + +#define LOONGARCH64_ORC_TYPE_UNDEFINED 0 +#define LOONGARCH64_ORC_TYPE_END_OF_STACK 1 +#define LOONGARCH64_ORC_TYPE_CALL 2 +#define LOONGARCH64_ORC_TYPE_REGS 3 + +#define LOONGARCH64_LOOKUP_BLOCK_ORDER 8 +#define LOONGARCH64_LOOKUP_BLOCK_SIZE (1 << LOONGARCH64_LOOKUP_BLOCK_ORDER) +#define LOONGARCH64_INSN_SIZE 4 #define LOONGARCH64_VECSIZE 0x200 #define LOONGARCH64_EXCEPTION_VECTOR_NUM 128 #define LOONGARCH64_EXCCODE_INT_START 64 @@ -70,6 +95,7 @@ static void loongarch64_dump_backtrace_entry(struct bt_info *bt, static void loongarch64_dump_exception_stack(struct bt_info *bt, char *pt_regs); static int loongarch64_is_exception_entry(struct syment *sym); static ulong loongarch64_exception_pc(int cpu, ulong pc); +static int loongarch64_is_unwind_text(ulong pc); static int loongarch64_eframe_search(struct bt_info *bt); static void loongarch64_display_full_frame(struct bt_info *bt, struct loongarch64_unwind_frame *current, @@ -82,6 +108,10 @@ static int loongarch64_get_frame(struct bt_info *bt, ulong *pcp, ulong *spp); static int loongarch64_init_active_task_regs(void); static int loongarch64_get_crash_notes(void); static int loongarch64_get_elf_notes(void); +static void loongarch64_ORC_init(void); +static int loongarch64_orc_unwind(struct bt_info *bt, + struct loongarch64_unwind_frame *current, + struct loongarch64_unwind_frame *previous); /* * 3 Levels paging PAGE_SIZE=16KB @@ -454,11 +484,12 @@ loongarch64_back_trace_cmd(struct bt_info *bt) if (bt->flags & BT_REGS_NOT_FOUND) return; - previous.sp = previous.pc = previous.ra = 0; + previous.sp = previous.pc = previous.ra = previous.fp = 0; current.pc = bt->instptr; current.sp = bt->stkptr; current.ra = 0; + current.fp = 0; if (!INSTACK(current.sp, bt)) return; @@ -466,6 +497,7 @@ loongarch64_back_trace_cmd(struct bt_info *bt) if (bt->machdep) { regs = (struct loongarch64_pt_regs *)bt->machdep; previous.pc = current.ra = regs->regs[LOONGARCH64_EF_RA]; + current.fp = regs->regs[LOONGARCH64_EF_FP]; } while (current.sp <= bt->stacktop - SIZE(pt_regs)) { @@ -523,12 +555,15 @@ loongarch64_back_trace_cmd(struct bt_info *bt) } } - if (symbol && loongarch64_is_exception_entry(symbol)) { + if (loongarch64_orc_unwind(bt, &current, &previous)) { + /* ORC has already calculated the caller frame. */ + } else if (symbol && loongarch64_is_exception_entry(symbol)) { GET_STACK_DATA(current.sp, pt_regs, sizeof(pt_regs)); regs = (struct loongarch64_pt_regs *) (pt_regs + OFFSET(pt_regs_regs)); previous.ra = regs->regs[LOONGARCH64_EF_RA]; previous.sp = regs->regs[LOONGARCH64_EF_SP]; + previous.fp = regs->regs[LOONGARCH64_EF_FP]; current.ra = regs->csr_epc; if (CRASHDEBUG(8)) @@ -554,12 +589,13 @@ loongarch64_back_trace_cmd(struct bt_info *bt) current.pc = current.ra; current.sp = previous.sp; current.ra = previous.ra; + current.fp = previous.fp; if (CRASHDEBUG(8)) fprintf(fp, "next %d pc %#lx ra %#lx sp %lx\n", level, current.pc, current.ra, current.sp); - previous.sp = previous.pc = previous.ra = 0; + previous.sp = previous.pc = previous.ra = previous.fp = 0; } } @@ -811,6 +847,319 @@ loongarch64_exception_pc(int cpu, ulong pc) return func ? func + offset : pc; } + +static int +loongarch64_is_unwind_text(ulong pc) +{ + struct syment *symbol; + ulong offset; + + if (!is_kernel_text(pc)) + return FALSE; + + symbol = value_search(pc, &offset); + if (!symbol || symbol->name[0] == '.' || + STREQ(symbol->name, "_PROCEDURE_LINKAGE_TABLE_") || + STREQ(symbol->name, "empty_zero_page") || + STRNEQ(symbol->name, "__start_") || + STRNEQ(symbol->name, "__end_")) + return FALSE; + + return TRUE; +} + +static int +loongarch64_orc_ip(ulong ip_entry_addr, ulong *ip) +{ + int ip_entry; + + if (!readmem(ip_entry_addr, KVADDR, &ip_entry, sizeof(ip_entry), + "LoongArch ORC ip", RETURN_ON_ERROR|QUIET)) + return FALSE; + + *ip = ip_entry_addr + ip_entry; + return TRUE; +} + +static struct loongarch64_orc_entry * +loongarch64_orc_get_entry(struct loongarch64_ORC_data *orc) +{ + loongarch64_kernel_orc_entry korc; + struct loongarch64_orc_entry *entry = &orc->orc_entry_data; + + if (!readmem(orc->orc_entry, KVADDR, &korc, sizeof(korc), + "LoongArch ORC entry", RETURN_ON_ERROR|QUIET)) + return NULL; + + entry->sp_offset = korc.sp_offset; + entry->fp_offset = korc.fp_offset; + entry->ra_offset = korc.ra_offset; + entry->sp_reg = korc.sp_reg; + entry->fp_reg = korc.fp_reg; + entry->ra_reg = korc.ra_reg; + entry->type = korc.type; + entry->signal = korc.signal; + + return entry; +} + +static struct loongarch64_orc_entry * +loongarch64_orc_find_in_table(ulong ip_table, ulong orc_table, + uint num_entries, ulong ip) +{ + int index; + ulong first, last, mid, found, vaddr; + struct machine_specific *ms = machdep->machspec; + struct loongarch64_ORC_data *orc = &ms->orc; + + if (!num_entries) + return NULL; + + first = ip_table; + last = ip_table + ((num_entries - 1) * sizeof(int)); + found = first; + + while (first <= last) { + mid = first + (((last - first) / sizeof(int)) / 2) * + sizeof(int); + + if (!loongarch64_orc_ip(mid, &vaddr)) + return NULL; + + if (vaddr <= ip) { + found = mid; + first = mid + sizeof(int); + } else { + if (mid == ip_table) + break; + last = mid - sizeof(int); + } + } + + index = (found - ip_table) / sizeof(int); + orc->ip_entry = found; + orc->orc_entry = orc_table + (index * SIZE(orc_entry)); + + return loongarch64_orc_get_entry(orc); +} + +static struct loongarch64_orc_entry * +loongarch64_orc_find(ulong ip) +{ + uint idx, start, stop, num_entries; + struct machine_specific *ms = machdep->machspec; + struct loongarch64_ORC_data *orc = &ms->orc; + + if (!orc->enabled) + return NULL; + + if ((ip >= kt->stext) && (ip < kt->etext)) { + if (orc->lookup_num_blocks < 2) + return NULL; + + idx = (ip - kt->stext) / LOONGARCH64_LOOKUP_BLOCK_SIZE; + if (idx >= orc->lookup_num_blocks - 1) + return NULL; + + if (!readmem(orc->orc_lookup + (idx * sizeof(uint)), KVADDR, + &start, sizeof(start), "LoongArch ORC lookup start", + RETURN_ON_ERROR|QUIET)) + return NULL; + if (!readmem(orc->orc_lookup + ((idx + 1) * sizeof(uint)), + KVADDR, &stop, sizeof(stop), "LoongArch ORC lookup stop", + RETURN_ON_ERROR|QUIET)) + return NULL; + stop++; + + if ((orc->__start_orc_unwind + (start * SIZE(orc_entry))) >= + orc->__stop_orc_unwind) + return NULL; + if ((orc->__start_orc_unwind + (stop * SIZE(orc_entry))) > + orc->__stop_orc_unwind) + return NULL; + + return loongarch64_orc_find_in_table( + orc->__start_orc_unwind_ip + (start * sizeof(int)), + orc->__start_orc_unwind + (start * SIZE(orc_entry)), + stop - start, ip); + } + + if (is_kernel_text(ip)) { + num_entries = (orc->__stop_orc_unwind_ip - + orc->__start_orc_unwind_ip) / sizeof(int); + return loongarch64_orc_find_in_table(orc->__start_orc_unwind_ip, + orc->__start_orc_unwind, num_entries, ip); + } + + return NULL; +} + +static int +loongarch64_orc_read_stack(ulong addr, ulong *value) +{ + return readmem(addr, KVADDR, value, sizeof(*value), + "LoongArch ORC stack", RETURN_ON_ERROR|QUIET); +} + +static ulong +loongarch64_orc_adjust_pc(int cpu, ulong ra) +{ + ra = loongarch64_exception_pc(cpu, ra); + return loongarch64_is_unwind_text(ra) ? ra : 0; +} + +static int +loongarch64_orc_unwind(struct bt_info *bt, + struct loongarch64_unwind_frame *current, + struct loongarch64_unwind_frame *previous) +{ + ulong cfa, pcval, fpval = current->fp; + struct loongarch64_orc_entry *orc; + struct loongarch64_pt_regs regs; + + orc = loongarch64_orc_find(current->pc); + if (!orc) + return FALSE; + + if (CRASHDEBUG(8)) + fprintf(fp, + "orc pc %lx sp %lx fp %lx -> spo %d fpo %d rao %d " + "spr %u fpr %u rar %u type %u\n", + current->pc, current->sp, current->fp, orc->sp_offset, + orc->fp_offset, orc->ra_offset, orc->sp_reg, orc->fp_reg, + orc->ra_reg, orc->type); + + if (orc->type == LOONGARCH64_ORC_TYPE_UNDEFINED || + orc->type == LOONGARCH64_ORC_TYPE_END_OF_STACK) + return FALSE; + + switch (orc->sp_reg) { + case LOONGARCH64_ORC_REG_SP: + cfa = current->sp + orc->sp_offset; + break; + case LOONGARCH64_ORC_REG_FP: + if (!current->fp) + return FALSE; + cfa = current->fp; + break; + default: + return FALSE; + } + + switch (orc->fp_reg) { + case LOONGARCH64_ORC_REG_PREV_SP: + if (!loongarch64_orc_read_stack(cfa + orc->fp_offset, &fpval)) + return FALSE; + break; + case LOONGARCH64_ORC_REG_UNDEFINED: + break; + default: + return FALSE; + } + + switch (orc->type) { + case LOONGARCH64_ORC_TYPE_CALL: + if (orc->ra_reg == LOONGARCH64_ORC_REG_PREV_SP) { + if (!loongarch64_orc_read_stack(cfa + orc->ra_offset, + &pcval)) + return FALSE; + } else if (orc->ra_reg == LOONGARCH64_ORC_REG_UNDEFINED) { + if (!current->ra || current->ra == current->pc) + return FALSE; + pcval = current->ra; + } else { + return FALSE; + } + if (pcval >= LOONGARCH64_INSN_SIZE) + pcval -= LOONGARCH64_INSN_SIZE; + pcval = loongarch64_orc_adjust_pc(bt->tc->processor, pcval); + if (!pcval && current->ra >= LOONGARCH64_INSN_SIZE) + pcval = loongarch64_orc_adjust_pc(bt->tc->processor, + current->ra - LOONGARCH64_INSN_SIZE); + if (!pcval) + return FALSE; + previous->sp = cfa; + previous->fp = fpval; + previous->ra = 0; + current->ra = pcval; + return TRUE; + + case LOONGARCH64_ORC_TYPE_REGS: + if (!readmem(cfa, KVADDR, &regs, sizeof(regs), + "LoongArch ORC pt_regs", RETURN_ON_ERROR|QUIET)) + return FALSE; + /* + * The kernel unwinder treats user-mode or empty pt_regs as a + * clean end. Crash does not need to distinguish that from a + * fallback here; a non-kernel ERA simply stops ORC unwinding. + */ + pcval = loongarch64_exception_pc(bt->tc->processor, regs.csr_epc); + if (!loongarch64_is_unwind_text(pcval)) + return FALSE; + previous->sp = regs.regs[LOONGARCH64_EF_SP]; + previous->fp = regs.regs[LOONGARCH64_EF_FP]; + previous->ra = regs.regs[LOONGARCH64_EF_RA]; + current->ra = pcval; + return TRUE; + } + + return FALSE; +} + +static void +loongarch64_ORC_init(void) +{ + int i; + char *orc_symbols[] = { + "lookup_num_blocks", + "__start_orc_unwind_ip", + "__stop_orc_unwind_ip", + "__start_orc_unwind", + "__stop_orc_unwind", + "orc_lookup", + NULL + }; + struct machine_specific *ms = machdep->machspec; + struct loongarch64_ORC_data *orc = &ms->orc; + + STRUCT_SIZE_INIT(orc_entry, "orc_entry"); + if (!VALID_STRUCT(orc_entry) || + SIZE(orc_entry) != sizeof(loongarch64_kernel_orc_entry)) { + error(WARNING, "LoongArch64 ORC unwinder: " + "orc_entry structure has changed\n"); + return; + } + + if (!MEMBER_EXISTS("orc_entry", "sp_offset") || + !MEMBER_EXISTS("orc_entry", "fp_offset") || + !MEMBER_EXISTS("orc_entry", "ra_offset") || + !MEMBER_EXISTS("orc_entry", "sp_reg") || + !MEMBER_EXISTS("orc_entry", "fp_reg") || + !MEMBER_EXISTS("orc_entry", "ra_reg") || + !MEMBER_EXISTS("orc_entry", "type")) { + error(WARNING, "LoongArch64 ORC unwinder: " + "orc_entry members have changed\n"); + return; + } + + for (i = 0; orc_symbols[i]; i++) { + if (!symbol_exists(orc_symbols[i])) + return; + } + + if (!readmem(symbol_value("lookup_num_blocks"), KVADDR, + &orc->lookup_num_blocks, sizeof(orc->lookup_num_blocks), + "LoongArch ORC lookup_num_blocks", RETURN_ON_ERROR|QUIET)) + return; + + orc->__start_orc_unwind_ip = symbol_value("__start_orc_unwind_ip"); + orc->__stop_orc_unwind_ip = symbol_value("__stop_orc_unwind_ip"); + orc->__start_orc_unwind = symbol_value("__start_orc_unwind"); + orc->__stop_orc_unwind = symbol_value("__stop_orc_unwind"); + orc->orc_lookup = symbol_value("orc_lookup"); + orc->enabled = TRUE; +} + /* * 'bt -f' commend output * Display all stack data contained in a frame @@ -1374,6 +1723,7 @@ loongarch64_init(int when) &machdep->nr_irqs); loongarch64_stackframe_init(); + loongarch64_ORC_init(); if (!machdep->hz) machdep->hz = 250; -- 2.43.0

The fallback prologue scanner may find a saved RA slot and read a word from the stack. In corrupted, interrupted, or partially unwound frames, that word is not guaranteed to be a kernel return address. Do not blindly replace the current RA with the scanned stack value. Keep the existing RA unless the scanned value is a kernel address, or unless the current RA is already not a kernel address. This keeps the fallback scanner from discarding a better caller candidate with obvious stack noise. Signed-off-by: Ming Wang <wangming01(a)loongson.cn&gt; --- loongarch64.c | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/loongarch64.c b/loongarch64.c index c25a3bbf6d6c..34e29c9f2d67 100644 --- a/loongarch64.c +++ b/loongarch64.c @@ -702,11 +702,17 @@ loongarch64_analyze_function(ulong start, ulong offset, previous->sp = current->sp + spadjust; - if (rapos && !readmem(rapos, KVADDR, &current->ra, - sizeof(current->ra), "RA from stack", - RETURN_ON_ERROR)) { - error(FATAL, "Cannot read RA from stack %lx", rapos); - return; + if (rapos) { + ulong ra; + + if (!readmem(rapos, KVADDR, &ra, sizeof(ra), "RA from stack", + RETURN_ON_ERROR)) { + error(FATAL, "Cannot read RA from stack %lx", rapos); + return; + } + + if (IS_KVADDR(ra) || !IS_KVADDR(current->ra)) + current->ra = ra; } } -- 2.43.0