Changeset aa0d227 in mainline

Timestamp:

2010-07-16T10:11:41Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

4d0f97d

Parents:

4003861 (diff), c8dea4f (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge from lp:~jakub/helenos/upa

Location:

kernel

Files:

• arch/abs32le/src/debug/stacktrace.c (modified) (1 diff)
• arch/amd64/src/debug/stacktrace.c (modified) (3 diffs)
• arch/arm32/src/debug/stacktrace.c (modified) (3 diffs)
• arch/ia32/src/debug/stacktrace.c (modified) (1 diff)
• arch/ia64/src/debug/stacktrace.c (modified) (1 diff)
• arch/mips32/include/debugger.h (modified) (1 diff)
• arch/mips32/src/debug/stacktrace.c (modified) (1 diff)
• arch/mips32/src/debug/stacktrace_asm.S (modified) (1 diff)
• arch/mips32/src/debugger.c (modified) (1 diff)
• arch/ppc32/src/debug/stacktrace.c (modified) (1 diff)
• arch/sparc64/src/debug/stacktrace.c (modified) (4 diffs)
• generic/include/stacktrace.h (modified) (3 diffs)
• generic/src/debug/stacktrace.c (modified) (6 diffs)

kernel/arch/abs32le/src/debug/stacktrace.c

@@ -37 +37 @@
 #include <typedefs.h>
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return true;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return true;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
         return true;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return true;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return true;
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
         return true;

kernel/arch/amd64/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA       1
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         
@@ -53 +53 @@
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         *ra = stack[FRAME_OFFSET_RA];
         
@@ -61 +61 @@
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint64_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint64_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra, (uint64_t *) fp + FRAME_OFFSET_RA,
-            sizeof(*ra));
+        return !copy_from_uspace((void *) ra,
+            (uint64_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
 }
 

kernel/arch/arm32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA         -1
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
 
         *prev = stack[FRAME_OFFSET_FP_PREV];
@@ -53 +53 @@
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
 
         *ra = stack[FRAME_OFFSET_RA];
@@ -61 +61 @@
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
-            sizeof(*ra));
+        return !copy_from_uspace((void *) ra,
+            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
 }
 

kernel/arch/ia32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA         1
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         return true;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
         *ra = stack[FRAME_OFFSET_RA];
         return true;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
-            sizeof(*ra));
+        return !copy_from_uspace((void *) ra,
+            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
 }
 

kernel/arch/ia64/src/debug/stacktrace.c

@@ -37 +37 @@
 #include <typedefs.h>
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return false;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return false;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
         return false;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return false;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return false;
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
         return false;

kernel/arch/mips32/include/debugger.h

@@ -68 +68 @@
 extern bpinfo_t breakpoints[BKPOINTS_MAX];
 
+extern bool is_jump(unative_t);
+
 extern void debugger_init(void);
 extern void debugger_bpoint(istate_t *);

kernel/arch/mips32/src/debug/stacktrace.c

@@ -36 +36 @@
 #include <syscall/copy.h>
 #include <typedefs.h>
-
-bool kernel_frame_pointer_validate(uintptr_t fp)
+#include <arch/debugger.h>
+#include <print.h>
+
+#define R0      0U
+#define SP      29U
+#define RA      31U
+
+#define OP_SHIFT        26
+#define RS_SHIFT        21
+#define RT_SHIFT        16
+#define RD_SHIFT        11
+
+#define HINT_SHIFT      6
+#define BASE_SHIFT      RS_SHIFT
+#define IMM_SHIFT       0
+#define OFFSET_SHIFT    IMM_SHIFT
+
+#define RS_MASK         (0x1f << RS_SHIFT)
+#define RT_MASK         (0x1f << RT_SHIFT)
+#define RD_MASK         (0x1f << RD_SHIFT)
+#define HINT_MASK       (0x1f << HINT_SHIFT)
+#define BASE_MASK       RS_MASK
+#define IMM_MASK        (0xffff << IMM_SHIFT)
+#define OFFSET_MASK     IMM_MASK        
+
+#define RS_GET(inst)            (((inst) & RS_MASK) >> RS_SHIFT)
+#define RD_GET(inst)            (((inst) & RD_MASK) >> RD_SHIFT)
+#define IMM_GET(inst)           (int16_t)(((inst) & IMM_MASK) >> IMM_SHIFT)
+#define BASE_GET(inst)          RS_GET(inst)
+#define OFFSET_GET(inst)        IMM_GET(inst)   
+
+#define ADDU_R_SP_R0_TEMPL \
+        ((0x0 << OP_SHIFT) | (SP << RS_SHIFT) | (R0 << RT_SHIFT) | 0x21)
+#define ADDU_SP_R_R0_TEMPL \
+        ((0x0 << OP_SHIFT) | (SP << RD_SHIFT) | (R0 << RT_SHIFT) | 0x21)
+#define ADDI_SP_SP_IMM_TEMPL \
+        ((0x8 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
+#define ADDIU_SP_SP_IMM_TEMPL \
+        ((0x9 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
+#define JR_RA_TEMPL \
+        ((0x0 << OP_SHIFT) | (RA << RS_SHIFT) | (0x0 << HINT_SHIFT) | 0x8)
+#define SW_RA_TEMPL \
+        ((0x2b << OP_SHIFT) | (RA << RT_SHIFT))
+
+#define IS_ADDU_R_SP_R0(inst) \
+        (((inst) & ~RD_MASK) == ADDU_R_SP_R0_TEMPL)
+#define IS_ADDU_SP_R_R0(inst) \
+        (((inst) & ~RS_MASK) == ADDU_SP_R_R0_TEMPL)
+#define IS_ADDI_SP_SP_IMM(inst) \
+        (((inst) & ~IMM_MASK) == ADDI_SP_SP_IMM_TEMPL)
+#define IS_ADDIU_SP_SP_IMM(inst) \
+        (((inst) & ~IMM_MASK) == ADDIU_SP_SP_IMM_TEMPL)
+#define IS_JR_RA(inst) \
+        (((inst) & ~HINT_MASK) == JR_RA_TEMPL)
+#define IS_SW_RA(inst) \
+        (((inst) & ~(BASE_MASK | OFFSET_MASK)) == SW_RA_TEMPL)
+
+extern char ktext_start;
+extern char ktext_end;
+
+static bool
+scan(stack_trace_context_t *ctx, uintptr_t *prev_fp, uintptr_t *prev_ra)
+{
+        uint32_t *inst = (void *) ctx->pc;
+        bool has_fp = false;
+        size_t frame_size;
+        unsigned int fp = SP;
+
+        do {
+                inst--;
+#if 0
+                /*
+                 * This is one of the situations in which the theory (ABI) does
+                 * not meet the practice (GCC). GCC simply does not place the
+                 * JR $ra instruction as dictated by the ABI, rendering the
+                 * official stack tracing algorithm somewhat unapplicable.
+                 */
+
+                if (IS_ADDU_R_SP_R0(*inst)) {
+                        uint32_t *cur;
+                        fp = RD_GET(*inst);
+                        /*
+                         * We have a candidate for frame pointer.
+                         */
+                        
+                        /* Seek to the end of this function. */
+                        for (cur = inst + 1; !IS_JR_RA(*cur); cur++)
+                                ;
+                        /* Scan the last basic block */
+                        for (cur--; !is_jump(*(cur - 1)); cur--) {
+                                if (IS_ADDU_SP_R_R0(*cur) &&
+                                    (fp == RS_GET(*cur))) {
+                                        has_fp = true;
+                                }
+                        }
+                        continue;
+                }
+                
+                if (IS_JR_RA(*inst)) {
+                        if (!ctx->istate)
+                                return false;
+                        /*
+                         * No stack frame has been allocated yet.
+                         * Use the values stored in istate.
+                         */
+                        if (prev_fp)
+                                *prev_fp = ctx->istate->sp;
+                        if (prev_ra)
+                                *prev_ra = ctx->istate->ra - 8;
+                        ctx->istate = NULL;
+                        return true;
+                }
+#endif
+
+        } while ((!IS_ADDIU_SP_SP_IMM(*inst) && !IS_ADDI_SP_SP_IMM(*inst)) ||
+            (IMM_GET(*inst) >= 0));
+        
+        /*
+         * We are at the instruction which allocates the space for the current
+         * stack frame.
+         */
+        frame_size = -IMM_GET(*inst);
+        if (prev_fp)
+                *prev_fp = ctx->fp + frame_size;
+
+        /*
+         * Scan the first basic block for the occurrence of
+         * SW $ra, OFFSET($base).
+         */
+        for (inst++; !is_jump(*(inst - 1)) && (uintptr_t) inst < ctx->pc;
+            inst++) {
+                if (IS_SW_RA(*inst)) {
+                        unsigned int base = BASE_GET(*inst);
+                        int16_t offset = OFFSET_GET(*inst);
+
+                        if (base == SP || (has_fp && base == fp)) {
+                                uint32_t *addr = (void *) (ctx->fp + offset);
+                                
+                                if (offset % 4 != 0)
+                                        return false;
+                                /* cannot store below current stack pointer */
+                                if (offset < 0)
+                                        return false;
+                                /* too big offsets are suspicious */
+                                if (offset > 32 * 4)
+                                        return false;
+
+                                if (prev_ra)
+                                        *prev_ra = *addr;
+                                return true;
+                        }
+                }
+        }
+
+        /*
+         * The first basic block does not save the return address or saves it
+         * after ctx->pc, which means that the correct value is in istate.
+         */
+        if (prev_ra) {
+                if (!ctx->istate)
+                        return false;
+                *prev_ra = ctx->istate->ra - 8;
+                ctx->istate = NULL;
+        }
+        return true;
+}
+
+
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
+{
+        return !((ctx->fp == 0) || ((ctx->fp % 8) != 0) ||
+            (ctx->pc % 4 != 0) || (ctx->pc < (uintptr_t) &ktext_start) ||
+            (ctx->pc >= (uintptr_t) &ktext_end));
+}
+
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
+{
+        return scan(ctx, prev, NULL);
+}
+
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
+{
+        return scan(ctx, NULL, ra);
+}
+
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return false;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return false;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
         return false;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
-{
-        return false;
-}
-
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
-{
-        return false;
-}
-
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
-{
-        return false;
-}
-
 /** @}
  */

kernel/arch/mips32/src/debug/stacktrace_asm.S

@@ -37 +37 @@
 frame_pointer_get:
         j $ra
-        xor $v0, $v0
+        move $v0, $sp
 
 program_counter_get:
         j $ra
-        xor $v0, $v0
+        move $v0, $ra

kernel/arch/mips32/src/debugger.c

@@ -134 +134 @@
  *
  */
-static bool is_jump(unative_t instr)
+bool is_jump(unative_t instr)
 {
         unsigned int i;

kernel/arch/ppc32/src/debug/stacktrace.c

@@ -40 +40 @@
 #define FRAME_OFFSET_RA       1
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
         *prev = stack[FRAME_OFFSET_FP_PREV];
         return true;
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint32_t *stack = (void *) fp;
+        uint32_t *stack = (void *) ctx->fp;
         *ra = stack[FRAME_OFFSET_RA];
         return true;
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return !copy_from_uspace((void *) prev,
-            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
+            (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
-            sizeof(*ra));
+        return !copy_from_uspace((void *) ra,
+            (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
 }
 

kernel/arch/sparc64/src/debug/stacktrace.c

@@ -50 +50 @@
 extern void alloc_window_and_flush(void);
 
-bool kernel_frame_pointer_validate(uintptr_t fp)
+bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         uintptr_t kstack;
@@ -63 +63 @@
         kstack -= PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE;
 
-        if (THREAD && (fp == kstack))
+        if (THREAD && (ctx->fp == kstack))
                 return false;
-        return fp != 0;
+        return ctx->fp != 0;
 }
 
-bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         alloc_window_and_flush();
         *prev = stack[FRAME_OFFSET_FP_PREV] + STACK_BIAS;
@@ -76 +76 @@
 }
 
-bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
 {
-        uint64_t *stack = (void *) fp;
+        uint64_t *stack = (void *) ctx->fp;
         alloc_window_and_flush();
         *ra = stack[FRAME_OFFSET_RA];
@@ -84 +84 @@
 }
 
-bool uspace_frame_pointer_validate(uintptr_t fp)
+bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
 {
         return false;
 }
 
-bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
+bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
 {
         return false;
 }
 
-bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
+bool uspace_return_address_get(stack_trace_context_t *ctx , uintptr_t *ra)
 {
         return false;

kernel/generic/include/stacktrace.h

@@ -42 +42 @@
 
 typedef struct {
-        bool (* frame_pointer_validate)(uintptr_t);
-        bool (* frame_pointer_prev)(uintptr_t, uintptr_t *);
-        bool (* return_address_get)(uintptr_t, uintptr_t *);
+        uintptr_t fp;
+        uintptr_t pc;
+        struct istate *istate;
+} stack_trace_context_t;
+
+typedef struct {
+        bool (* stack_trace_context_validate)(stack_trace_context_t *);
+        bool (* frame_pointer_prev)(stack_trace_context_t *, uintptr_t *);
+        bool (* return_address_get)(stack_trace_context_t *, uintptr_t *);
         bool (* symbol_resolve)(uintptr_t, const char **, uintptr_t *);
 } stack_trace_ops_t;
@@ -53 +59 @@
 extern void stack_trace(void);
 extern void stack_trace_istate(struct istate *);
-extern void stack_trace_fp_pc(stack_trace_ops_t *, uintptr_t, uintptr_t);
+extern void stack_trace_ctx(stack_trace_ops_t *, stack_trace_context_t *);
 
 /*
@@ -61 +67 @@
 extern uintptr_t program_counter_get(void);
 
-extern bool kernel_frame_pointer_validate(uintptr_t);
-extern bool kernel_frame_pointer_prev(uintptr_t, uintptr_t *);
-extern bool kernel_return_address_get(uintptr_t, uintptr_t *);
+extern bool kernel_stack_trace_context_validate(stack_trace_context_t *);
+extern bool kernel_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
+extern bool kernel_return_address_get(stack_trace_context_t *, uintptr_t *);
 
-extern bool uspace_frame_pointer_validate(uintptr_t);
-extern bool uspace_frame_pointer_prev(uintptr_t, uintptr_t *);
-extern bool uspace_return_address_get(uintptr_t, uintptr_t *);
+extern bool uspace_stack_trace_context_validate(stack_trace_context_t *);
+extern bool uspace_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
+extern bool uspace_return_address_get(stack_trace_context_t *, uintptr_t *);
 
 #endif

kernel/generic/src/debug/stacktrace.c

@@ -27 +27 @@
  */
 
-/** @addtogroup genericdebug 
+/** @addtogroup genericdebug
  * @{
  */
@@ -42 +42 @@
 
 void
-stack_trace_fp_pc(stack_trace_ops_t *ops, uintptr_t fp, uintptr_t pc)
+stack_trace_ctx(stack_trace_ops_t *ops, stack_trace_context_t *ctx)
 {
         int cnt = 0;
         const char *symbol;
         uintptr_t offset;
+        uintptr_t fp;
+        uintptr_t pc;
         
-        while (cnt++ < STACK_FRAMES_MAX && ops->frame_pointer_validate(fp)) {
+        while (cnt++ < STACK_FRAMES_MAX &&
+            ops->stack_trace_context_validate(ctx)) {
                 if (ops->symbol_resolve &&
-                    ops->symbol_resolve(pc, &symbol, &offset)) {
+                    ops->symbol_resolve(ctx->pc, &symbol, &offset)) {
                         if (offset)
-                                printf("%p: %s+%" PRIp "()\n", fp, symbol, offset);
+                                printf("%p: %s+%" PRIp "()\n",
+                                    ctx->fp, symbol, offset);
                         else
-                                printf("%p: %s()\n", fp, symbol);
+                                printf("%p: %s()\n",
+                                    ctx->fp, symbol);
                 } else {
-                        printf("%p: %p()\n", fp, pc);
+                        printf("%p: %p()\n", ctx->fp, ctx->pc);
                 }
-                if (!ops->return_address_get(fp, &pc))
+                if (!ops->return_address_get(ctx, &pc))
                         break;
-                if (!ops->frame_pointer_prev(fp, &fp))
+                if (!ops->frame_pointer_prev(ctx, &fp))
                         break;
+                ctx->fp = fp;
+                ctx->pc = pc;
         }
 }
@@ -67 +74 @@
 void stack_trace(void)
 {
-        stack_trace_fp_pc(&kst_ops, frame_pointer_get(), program_counter_get());
+        stack_trace_context_t ctx = {
+                .fp = frame_pointer_get(),
+                .pc = program_counter_get(),
+                .istate = NULL
+        };
+
+        stack_trace_ctx(&kst_ops, &ctx);
 
         /*
@@ -78 +91 @@
 void stack_trace_istate(istate_t *istate)
 {
+        stack_trace_context_t ctx = {
+                .fp = istate_get_fp(istate),
+                .pc = istate_get_pc(istate),
+                .istate = istate
+        };
+        
         if (istate_from_uspace(istate))
-                stack_trace_fp_pc(&ust_ops, istate_get_fp(istate),
-                    istate_get_pc(istate));
+                stack_trace_ctx(&ust_ops, &ctx);
         else
-                stack_trace_fp_pc(&kst_ops, istate_get_fp(istate),
-                    istate_get_pc(istate));
+                stack_trace_ctx(&kst_ops, &ctx);
 }
 
-static bool kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
+static bool
+kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
 {
         return (symtab_name_lookup(addr, sp, op) == 0);
@@ -92 +110 @@
 
 stack_trace_ops_t kst_ops = {
-        .frame_pointer_validate = kernel_frame_pointer_validate,
+        .stack_trace_context_validate = kernel_stack_trace_context_validate,
         .frame_pointer_prev = kernel_frame_pointer_prev,
         .return_address_get = kernel_return_address_get,
@@ -99 +117 @@
 
 stack_trace_ops_t ust_ops = {
-        .frame_pointer_validate = uspace_frame_pointer_validate,
+        .stack_trace_context_validate = uspace_stack_trace_context_validate,
         .frame_pointer_prev = uspace_frame_pointer_prev,
         .return_address_get = uspace_return_address_get,