修复调用栈回溯打印不完整的问题

Author: xiaoyi1212

src/arch/x86_64/backtrace.c

@@ -3,6 +3,7 @@
 #include "limine.h"
 #include "mem/heap.h"
 #include "ptrace.h"
+#include "task/task.h"
 #include "term/klog.h"
 
 typedef struct {
@@ -14,15 +15,90 @@ LIMINE_REQUEST struct limine_kernel_file_request kfile_request = {
     .id = LIMINE_KERNEL_FILE_REQUEST,
 };
 extern char   _kernel_start[];
-static ksym_t static_ksyms[8192];
 ksym_t       *kallsyms       = NULL;
 size_t        kallsyms_num   = 0;
 void         *eh_frame_start = NULL;
 size_t        eh_frame_size  = 0;
+static uint64_t kernel_text_start = 0;
+static uint64_t kernel_text_end   = 0;
+
+const char *kallsyms_lookup(uint64_t addr, uint64_t *sym_addr);
+
+static bool addr_in_kernel_text(uint64_t addr) {
+    if (kernel_text_start && kernel_text_end) {
+        return addr >= kernel_text_start && addr < kernel_text_end;
+    }
+    return addr >= 0xffffffff80000000UL && addr < 0xfffffffffffff000UL;
+}
+
+static void get_stack_bounds(uint64_t rsp, uint64_t *stack_low, uint64_t *stack_high) {
+    tcb_t task = get_current_task();
+    if (task != NULL) {
+        uint64_t k_low  = (uint64_t)task;
+        uint64_t k_high = task->context.kernel_stack;
+        if (k_high == 0) { k_high = k_low + STACK_SIZE; }
+        if (rsp >= k_low && rsp < k_high) {
+            *stack_low  = k_low;
+            *stack_high = k_high;
+            return;
+        }
+
+        if (task->syscall_stack != 0) {
+            uint64_t s_high = task->syscall_stack;
+            uint64_t s_low  = s_high - MAX_STACK_SIZE;
+            if (rsp >= s_low && rsp < s_high) {
+                *stack_low  = s_low;
+                *stack_high = s_high;
+                return;
+            }
+        }
+
+        if (task->signal_stack != 0) {
+            uint64_t s_high = task->signal_stack;
+            uint64_t s_low  = s_high - STACK_SIZE;
+            if (rsp >= s_low && rsp < s_high) {
+                *stack_low  = s_low;
+                *stack_high = s_high;
+                return;
+            }
+        }
+    }
+
+    *stack_low  = rsp;
+    *stack_high = rsp + MAX_STACK_SIZE;
+}
+
+static int backtrace_from_rbp(uint64_t rbp, uint64_t stack_low, uint64_t stack_high,
+                              int max_frames) {
+    int count = 0;
+    uint64_t sym_addr = 0;
+
+    while (count < max_frames) {
+        if (rbp < stack_low || rbp + 16 > stack_high) { break; }
+
+        uint64_t next_rbp = *(uint64_t *)rbp;
+        uint64_t ret_addr = *((uint64_t *)rbp + 1);
+
+        if (!addr_in_kernel_text(ret_addr)) { break; }
+
+        const char *name = kallsyms_lookup(ret_addr, &sym_addr);
+        if (name) {
+            printk("  [<0x%lx>] %s+0x%lx\n", ret_addr, name, ret_addr - sym_addr);
+        } else {
+            printk("  [<0x%lx>] ???\n", ret_addr);
+        }
+        count++;
+
+        if (next_rbp <= rbp) { break; }
+        rbp = next_rbp;
+    }
+
+    return count;
+}
 
 static int ksym_cmp(const void *a, const void *b) {
-    const ksym_t *sym_a = (const ksym_t *)a;
-    const ksym_t *sym_b = (const ksym_t *)b;
+    const ksym_t *sym_a = a;
+    const ksym_t *sym_b = b;
 
     if (sym_a->addr < sym_b->addr) return -1;
     if (sym_a->addr > sym_b->addr) return 1;
@@ -64,17 +140,22 @@ void kallsyms_init_from_elf() {
                 eh_frame_size  = shdrs[i].sh_size;
                 break;
             }
+            if (strcmp(sec_name, ".text") == 0) {
+                kernel_text_start = shdrs[i].sh_addr;
+                kernel_text_end   = shdrs[i].sh_addr + shdrs[i].sh_size;
+                break;
+            }
+        default:break;
         }
     }
 
-    size_t num_symbols = symtabsz / sizeof(Elf64_Sym);
+    const size_t num_symbols = symtabsz / sizeof(Elf64_Sym);
 
     kallsyms = calloc(num_symbols, sizeof(ksym_t));
 
     for (size_t i = 0; i < num_symbols; i++) {
         Elf64_Sym *sym      = &symtab[i];
         char      *sym_name = &strtab[sym->st_name];
-        uint64_t   bind     = ELF64_ST_BIND(sym->st_info);
         uint64_t   type     = ELF64_ST_TYPE(sym->st_info);
         if (sym->st_shndx == SHN_UNDEF) continue;
         if (type == STT_FUNC) {
@@ -107,7 +188,7 @@ const char *kallsyms_lookup(uint64_t addr, uint64_t *sym_addr) {
 }
 
 void print_kernel_backtrace(struct interrupt_frame *frame, uint64_t saved_rbp) {
-    printk("Call Trace (stack scanning):\n");
+    printk("Call Trace:\n");
 
     uint64_t    sym_addr = 0;
     const char *name     = kallsyms_lookup(frame->rip, &sym_addr);
@@ -117,29 +198,45 @@ void print_kernel_backtrace(struct interrupt_frame *frame, uint64_t saved_rbp) {
         printk("  [<0x%lx>] ??? (RIP)\n", frame->rip);
     }
 
-    // 从 RSP 开始向上扫描栈（限制范围防止越界）
-    uint64_t      *stack      = (uint64_t *)frame->rsp;
-    const uint64_t stack_top  = frame->rsp + 0x2000; // 扫描最多 8KB
-    int            count      = 0;
-    const int      max_frames = 20;
-
-    for (uint64_t *p = stack; p < (uint64_t *)stack_top && count < max_frames; p++) {
-        uint64_t candidate = *p;
-
-        // 合法内核地址范围（根据你的链接脚本）
-        if (candidate >= 0xffffffff80000000UL && candidate < 0xfffffffffffff000UL) {
-            // 检查是否对齐（指令地址通常是 16 字节对齐）
-            if ((candidate & 0xF) == 0) {
-                const char *name = kallsyms_lookup(candidate, &sym_addr);
-                if (name) {
-                    printk("  [<0x%lx>] %s+0x%lx\n", candidate, name, candidate - sym_addr);
-                } else {
-                    printk("  [<0x%lx>] ???\n", candidate);
-                }
-                count++;
+    const int max_frames = 20;
+    int       count      = 0;
+
+    uint64_t stack_low  = 0;
+    uint64_t stack_high = 0;
+    get_stack_bounds(frame->rsp, &stack_low, &stack_high);
+
+    if (saved_rbp >= stack_low && saved_rbp + 16 <= stack_high) {
+        uint64_t rbp = 0;
+        uint64_t ret = *((uint64_t *)saved_rbp + 1);
+        if (ret == frame->rip) {
+            rbp = *(uint64_t *)saved_rbp; // handler 栈帧，取中断前的 RBP
+        } else {
+            rbp = saved_rbp; // saved_rbp 本身就是中断前的 RBP
+        }
+        if (rbp >= stack_low && rbp + 16 <= stack_high) {
+            count = backtrace_from_rbp(rbp, stack_low, stack_high, max_frames);
+        }
+    }
+
+    if (count == 0) {
+        uint64_t start_rsp = frame->rsp;
+        if (start_rsp < stack_low || start_rsp >= stack_high) { start_rsp = stack_low; }
+
+        for (uint64_t *p = (uint64_t *)start_rsp;
+             (uint64_t)p + sizeof(uint64_t) <= stack_high && count < max_frames; p++) {
+            const uint64_t candidate = *p;
+
+            if (!addr_in_kernel_text(candidate)) { continue; }
+
+            const char *name = kallsyms_lookup(candidate, &sym_addr);
+            if (name) {
+                printk("  [<0x%lx>] %s+0x%lx\n", candidate, name, candidate - sym_addr);
+            } else {
+                printk("  [<0x%lx>] ???\n", candidate);
             }
+            count++;
         }
     }
 
-    if (count == 0) { printk("  (no valid return addresses found on stack)\n"); }
+    if (count == 0) { printk("  (no valid return addresses found)\n"); }
 }