Changes in / [4d0f97d:24697c3] in mainline


Ignore:
Location:
kernel
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r4d0f97d r24697c3  
    3737#include <typedefs.h>
    3838
    39 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     39bool kernel_frame_pointer_validate(uintptr_t fp)
    4040{
    4141        return true;
    4242}
    4343
    44 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     44bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4545{
    4646        return true;
    4747}
    4848
    49 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     49bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5050{
    5151        return true;
    5252}
    5353
    54 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     54bool uspace_frame_pointer_validate(uintptr_t fp)
    5555{
    5656        return true;
    5757}
    5858
    59 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     59bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6060{
    6161        return true;
    6262}
    6363
    64 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     64bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    6565{
    6666        return true;

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

    r4d0f97d r24697c3  
    4040#define FRAME_OFFSET_RA       1
    4141
    42 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     42bool kernel_frame_pointer_validate(uintptr_t fp)
    4343{
    44         return ctx->fp != 0;
     44        return fp != 0;
    4545}
    4646
    47 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     47bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4848{
    49         uint64_t *stack = (void *) ctx->fp;
     49        uint64_t *stack = (void *) fp;
    5050        *prev = stack[FRAME_OFFSET_FP_PREV];
    5151       
    … …  
    5353}
    5454
    55 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     55bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5656{
    57         uint64_t *stack = (void *) ctx->fp;
     57        uint64_t *stack = (void *) fp;
    5858        *ra = stack[FRAME_OFFSET_RA];
    5959       
    … …  
    6161}
    6262
    63 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     63bool uspace_frame_pointer_validate(uintptr_t fp)
    6464{
    65         return ctx->fp != 0;
     65        return fp != 0;
    6666}
    6767
    68 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     68bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6969{
    7070        return !copy_from_uspace((void *) prev,
    71             (uint64_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     71            (uint64_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
    7272}
    7373
    74 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     74bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    7575{
    76         return !copy_from_uspace((void *) ra,
    77             (uint64_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
     76        return !copy_from_uspace((void *) ra, (uint64_t *) fp + FRAME_OFFSET_RA,
     77            sizeof(*ra));
    7878}
    7979

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

    r4d0f97d r24697c3  
    4040#define FRAME_OFFSET_RA         -1
    4141
    42 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     42bool kernel_frame_pointer_validate(uintptr_t fp)
    4343{
    44         return ctx->fp != 0;
     44        return fp != 0;
    4545}
    4646
    47 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     47bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4848{
    49         uint32_t *stack = (void *) ctx->fp;
     49        uint32_t *stack = (void *) fp;
    5050
    5151        *prev = stack[FRAME_OFFSET_FP_PREV];
    … …  
    5353}
    5454
    55 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     55bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5656{
    57         uint32_t *stack = (void *) ctx->fp;
     57        uint32_t *stack = (void *) fp;
    5858
    5959        *ra = stack[FRAME_OFFSET_RA];
    … …  
    6161}
    6262
    63 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     63bool uspace_frame_pointer_validate(uintptr_t fp)
    6464{
    65         return ctx->fp != 0;
     65        return fp != 0;
    6666}
    6767
    68 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     68bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6969{
    7070        return !copy_from_uspace((void *) prev,
    71             (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     71            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
    7272}
    7373
    74 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     74bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    7575{
    76         return !copy_from_uspace((void *) ra,
    77             (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
     76        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
     77            sizeof(*ra));
    7878}
    7979

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

    r4d0f97d r24697c3  
    4040#define FRAME_OFFSET_RA         1
    4141
    42 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     42bool kernel_frame_pointer_validate(uintptr_t fp)
    4343{
    44         return ctx->fp != 0;
     44        return fp != 0;
    4545}
    4646
    47 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     47bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4848{
    49         uint32_t *stack = (void *) ctx->fp;
     49        uint32_t *stack = (void *) fp;
    5050        *prev = stack[FRAME_OFFSET_FP_PREV];
    5151        return true;
    5252}
    5353
    54 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     54bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5555{
    56         uint32_t *stack = (void *) ctx->fp;
     56        uint32_t *stack = (void *) fp;
    5757        *ra = stack[FRAME_OFFSET_RA];
    5858        return true;
    5959}
    6060
    61 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     61bool uspace_frame_pointer_validate(uintptr_t fp)
    6262{
    63         return ctx->fp != 0;
     63        return fp != 0;
    6464}
    6565
    66 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     66bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6767{
    6868        return !copy_from_uspace((void *) prev,
    69             (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     69            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
    7070}
    7171
    72 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     72bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    7373{
    74         return !copy_from_uspace((void *) ra,
    75             (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
     74        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
     75            sizeof(*ra));
    7676}
    7777

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

    r4d0f97d r24697c3  
    3737#include <typedefs.h>
    3838
    39 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     39bool kernel_frame_pointer_validate(uintptr_t fp)
    4040{
    4141        return false;
    4242}
    4343
    44 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     44bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4545{
    4646        return false;
    4747}
    4848
    49 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     49bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5050{
    5151        return false;
    5252}
    5353
    54 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     54bool uspace_frame_pointer_validate(uintptr_t fp)
    5555{
    5656        return false;
    5757}
    5858
    59 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     59bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6060{
    6161        return false;
    6262}
    6363
    64 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     64bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    6565{
    6666        return false;

  • kernel/arch/mips32/include/debugger.h

    r4d0f97d r24697c3  
    6868extern bpinfo_t breakpoints[BKPOINTS_MAX];
    6969
    70 extern bool is_jump(unative_t);
    71 
    7270extern void debugger_init(void);
    7371extern void debugger_bpoint(istate_t *);

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

    r4d0f97d r24697c3  
    3636#include <syscall/copy.h>
    3737#include <typedefs.h>
    38 #include <arch/debugger.h>
    39 #include <print.h>
    4038
    41 #define R0      0U
    42 #define SP      29U
    43 #define RA      31U
    44 
    45 #define OP_SHIFT        26
    46 #define RS_SHIFT        21
    47 #define RT_SHIFT        16
    48 #define RD_SHIFT        11
    49 
    50 #define HINT_SHIFT      6
    51 #define BASE_SHIFT      RS_SHIFT
    52 #define IMM_SHIFT       0
    53 #define OFFSET_SHIFT    IMM_SHIFT
    54 
    55 #define RS_MASK         (0x1f << RS_SHIFT)
    56 #define RT_MASK         (0x1f << RT_SHIFT)
    57 #define RD_MASK         (0x1f << RD_SHIFT)
    58 #define HINT_MASK       (0x1f << HINT_SHIFT)
    59 #define BASE_MASK       RS_MASK
    60 #define IMM_MASK        (0xffff << IMM_SHIFT)
    61 #define OFFSET_MASK     IMM_MASK       
    62 
    63 #define RS_GET(inst)            (((inst) & RS_MASK) >> RS_SHIFT)
    64 #define RD_GET(inst)            (((inst) & RD_MASK) >> RD_SHIFT)
    65 #define IMM_GET(inst)           (int16_t)(((inst) & IMM_MASK) >> IMM_SHIFT)
    66 #define BASE_GET(inst)          RS_GET(inst)
    67 #define OFFSET_GET(inst)        IMM_GET(inst)   
    68 
    69 #define ADDU_R_SP_R0_TEMPL \
    70         ((0x0 << OP_SHIFT) | (SP << RS_SHIFT) | (R0 << RT_SHIFT) | 0x21)
    71 #define ADDU_SP_R_R0_TEMPL \
    72         ((0x0 << OP_SHIFT) | (SP << RD_SHIFT) | (R0 << RT_SHIFT) | 0x21)
    73 #define ADDI_SP_SP_IMM_TEMPL \
    74         ((0x8 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
    75 #define ADDIU_SP_SP_IMM_TEMPL \
    76         ((0x9 << OP_SHIFT) | (SP << RS_SHIFT) | (SP << RT_SHIFT))
    77 #define JR_RA_TEMPL \
    78         ((0x0 << OP_SHIFT) | (RA << RS_SHIFT) | (0x0 << HINT_SHIFT) | 0x8)
    79 #define SW_RA_TEMPL \
    80         ((0x2b << OP_SHIFT) | (RA << RT_SHIFT))
    81 
    82 #define IS_ADDU_R_SP_R0(inst) \
    83         (((inst) & ~RD_MASK) == ADDU_R_SP_R0_TEMPL)
    84 #define IS_ADDU_SP_R_R0(inst) \
    85         (((inst) & ~RS_MASK) == ADDU_SP_R_R0_TEMPL)
    86 #define IS_ADDI_SP_SP_IMM(inst) \
    87         (((inst) & ~IMM_MASK) == ADDI_SP_SP_IMM_TEMPL)
    88 #define IS_ADDIU_SP_SP_IMM(inst) \
    89         (((inst) & ~IMM_MASK) == ADDIU_SP_SP_IMM_TEMPL)
    90 #define IS_JR_RA(inst) \
    91         (((inst) & ~HINT_MASK) == JR_RA_TEMPL)
    92 #define IS_SW_RA(inst) \
    93         (((inst) & ~(BASE_MASK | OFFSET_MASK)) == SW_RA_TEMPL)
    94 
    95 extern char ktext_start;
    96 extern char ktext_end;
    97 
    98 static bool
    99 scan(stack_trace_context_t *ctx, uintptr_t *prev_fp, uintptr_t *prev_ra)
    100 {
    101         uint32_t *inst = (void *) ctx->pc;
    102         bool has_fp = false;
    103         size_t frame_size;
    104         unsigned int fp = SP;
    105 
    106         do {
    107                 inst--;
    108 #if 0
    109                 /*
    110                  * This is one of the situations in which the theory (ABI) does
    111                  * not meet the practice (GCC). GCC simply does not place the
    112                  * JR $ra instruction as dictated by the ABI, rendering the
    113                  * official stack tracing algorithm somewhat unapplicable.
    114                  */
    115 
    116                 if (IS_ADDU_R_SP_R0(*inst)) {
    117                         uint32_t *cur;
    118                         fp = RD_GET(*inst);
    119                         /*
    120                          * We have a candidate for frame pointer.
    121                          */
    122                        
    123                         /* Seek to the end of this function. */
    124                         for (cur = inst + 1; !IS_JR_RA(*cur); cur++)
    125                                 ;
    126                         /* Scan the last basic block */
    127                         for (cur--; !is_jump(*(cur - 1)); cur--) {
    128                                 if (IS_ADDU_SP_R_R0(*cur) &&
    129                                     (fp == RS_GET(*cur))) {
    130                                         has_fp = true;
    131                                 }
    132                         }
    133                         continue;
    134                 }
    135                
    136                 if (IS_JR_RA(*inst)) {
    137                         if (!ctx->istate)
    138                                 return false;
    139                         /*
    140                          * No stack frame has been allocated yet.
    141                          * Use the values stored in istate.
    142                          */
    143                         if (prev_fp)
    144                                 *prev_fp = ctx->istate->sp;
    145                         if (prev_ra)
    146                                 *prev_ra = ctx->istate->ra - 8;
    147                         ctx->istate = NULL;
    148                         return true;
    149                 }
    150 #endif
    151 
    152         } while ((!IS_ADDIU_SP_SP_IMM(*inst) && !IS_ADDI_SP_SP_IMM(*inst)) ||
    153             (IMM_GET(*inst) >= 0));
    154        
    155         /*
    156          * We are at the instruction which allocates the space for the current
    157          * stack frame.
    158          */
    159         frame_size = -IMM_GET(*inst);
    160         if (prev_fp)
    161                 *prev_fp = ctx->fp + frame_size;
    162 
    163         /*
    164          * Scan the first basic block for the occurrence of
    165          * SW $ra, OFFSET($base).
    166          */
    167         for (inst++; !is_jump(*(inst - 1)) && (uintptr_t) inst < ctx->pc;
    168             inst++) {
    169                 if (IS_SW_RA(*inst)) {
    170                         unsigned int base = BASE_GET(*inst);
    171                         int16_t offset = OFFSET_GET(*inst);
    172 
    173                         if (base == SP || (has_fp && base == fp)) {
    174                                 uint32_t *addr = (void *) (ctx->fp + offset);
    175                                
    176                                 if (offset % 4 != 0)
    177                                         return false;
    178                                 /* cannot store below current stack pointer */
    179                                 if (offset < 0)
    180                                         return false;
    181                                 /* too big offsets are suspicious */
    182                                 if (offset > 32 * 4)
    183                                         return false;
    184 
    185                                 if (prev_ra)
    186                                         *prev_ra = *addr;
    187                                 return true;
    188                         }
    189                 }
    190         }
    191 
    192         /*
    193          * The first basic block does not save the return address or saves it
    194          * after ctx->pc, which means that the correct value is in istate.
    195          */
    196         if (prev_ra) {
    197                 if (!ctx->istate)
    198                         return false;
    199                 *prev_ra = ctx->istate->ra - 8;
    200                 ctx->istate = NULL;
    201         }
    202         return true;
    203 }
    204 
    205 
    206 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
    207 {
    208         return !((ctx->fp == 0) || ((ctx->fp % 8) != 0) ||
    209             (ctx->pc % 4 != 0) || (ctx->pc < (uintptr_t) &ktext_start) ||
    210             (ctx->pc >= (uintptr_t) &ktext_end));
    211 }
    212 
    213 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
    214 {
    215         return scan(ctx, prev, NULL);
    216 }
    217 
    218 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
    219 {
    220         return scan(ctx, NULL, ra);
    221 }
    222 
    223 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     39bool kernel_frame_pointer_validate(uintptr_t fp)
    22440{
    22541        return false;
    22642}
    22743
    228 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     44bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    22945{
    23046        return false;
    23147}
    23248
    233 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     49bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
     50{
     51        return false;
     52}
     53
     54bool uspace_frame_pointer_validate(uintptr_t fp)
     55{
     56        return false;
     57}
     58
     59bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
     60{
     61        return false;
     62}
     63
     64bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    23465{
    23566        return false;

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

    r4d0f97d r24697c3  
    3737frame_pointer_get:
    3838        j $ra
    39         move $v0, $sp
     39        xor $v0, $v0
    4040
    4141program_counter_get:
    4242        j $ra
    43         move $v0, $ra
     43        xor $v0, $v0

  • kernel/arch/mips32/src/debugger.c

    r4d0f97d r24697c3  
    134134 *
    135135 */
    136 bool is_jump(unative_t instr)
     136static bool is_jump(unative_t instr)
    137137{
    138138        unsigned int i;

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

    r4d0f97d r24697c3  
    4040#define FRAME_OFFSET_RA       1
    4141
    42 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     42bool kernel_frame_pointer_validate(uintptr_t fp)
    4343{
    44         return ctx->fp != 0;
     44        return fp != 0;
    4545}
    4646
    47 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     47bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    4848{
    49         uint32_t *stack = (void *) ctx->fp;
     49        uint32_t *stack = (void *) fp;
    5050        *prev = stack[FRAME_OFFSET_FP_PREV];
    5151        return true;
    5252}
    5353
    54 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     54bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    5555{
    56         uint32_t *stack = (void *) ctx->fp;
     56        uint32_t *stack = (void *) fp;
    5757        *ra = stack[FRAME_OFFSET_RA];
    5858        return true;
    5959}
    6060
    61 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     61bool uspace_frame_pointer_validate(uintptr_t fp)
    6262{
    63         return ctx->fp != 0;
     63        return fp != 0;
    6464}
    6565
    66 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     66bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    6767{
    6868        return !copy_from_uspace((void *) prev,
    69             (uint32_t *) ctx->fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
     69            (uint32_t *) fp + FRAME_OFFSET_FP_PREV, sizeof(*prev));
    7070}
    7171
    72 bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     72bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    7373{
    74         return !copy_from_uspace((void *) ra,
    75             (uint32_t *) ctx->fp + FRAME_OFFSET_RA, sizeof(*ra));
     74        return !copy_from_uspace((void *) ra, (uint32_t *) fp + FRAME_OFFSET_RA,
     75            sizeof(*ra));
    7676}
    7777

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

    r4d0f97d r24697c3  
    5050extern void alloc_window_and_flush(void);
    5151
    52 bool kernel_stack_trace_context_validate(stack_trace_context_t *ctx)
     52bool kernel_frame_pointer_validate(uintptr_t fp)
    5353{
    5454        uintptr_t kstack;
    … …  
    6363        kstack -= PREEMPTIBLE_HANDLER_STACK_FRAME_SIZE;
    6464
    65         if (THREAD && (ctx->fp == kstack))
     65        if (THREAD && (fp == kstack))
    6666                return false;
    67         return ctx->fp != 0;
     67        return fp != 0;
    6868}
    6969
    70 bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     70bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    7171{
    72         uint64_t *stack = (void *) ctx->fp;
     72        uint64_t *stack = (void *) fp;
    7373        alloc_window_and_flush();
    7474        *prev = stack[FRAME_OFFSET_FP_PREV] + STACK_BIAS;
    … …  
    7676}
    7777
    78 bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     78bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
    7979{
    80         uint64_t *stack = (void *) ctx->fp;
     80        uint64_t *stack = (void *) fp;
    8181        alloc_window_and_flush();
    8282        *ra = stack[FRAME_OFFSET_RA];
    … …  
    8484}
    8585
    86 bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
     86bool uspace_frame_pointer_validate(uintptr_t fp)
    8787{
    8888        return false;
    8989}
    9090
    91 bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     91bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    9292{
    9393        return false;
    9494}
    9595
    96 bool uspace_return_address_get(stack_trace_context_t *ctx , uintptr_t *ra)
     96bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    9797{
    9898        return false;

  • kernel/generic/include/stacktrace.h

    r4d0f97d r24697c3  
    4242
    4343typedef struct {
    44         uintptr_t fp;
    45         uintptr_t pc;
    46         struct istate *istate;
    47 } stack_trace_context_t;
    48 
    49 typedef struct {
    50         bool (* stack_trace_context_validate)(stack_trace_context_t *);
    51         bool (* frame_pointer_prev)(stack_trace_context_t *, uintptr_t *);
    52         bool (* return_address_get)(stack_trace_context_t *, uintptr_t *);
     44        bool (* frame_pointer_validate)(uintptr_t);
     45        bool (* frame_pointer_prev)(uintptr_t, uintptr_t *);
     46        bool (* return_address_get)(uintptr_t, uintptr_t *);
    5347        bool (* symbol_resolve)(uintptr_t, const char **, uintptr_t *);
    5448} stack_trace_ops_t;
    … …  
    5953extern void stack_trace(void);
    6054extern void stack_trace_istate(struct istate *);
    61 extern void stack_trace_ctx(stack_trace_ops_t *, stack_trace_context_t *);
     55extern void stack_trace_fp_pc(stack_trace_ops_t *, uintptr_t, uintptr_t);
    6256
    6357/*
    … …  
    6761extern uintptr_t program_counter_get(void);
    6862
    69 extern bool kernel_stack_trace_context_validate(stack_trace_context_t *);
    70 extern bool kernel_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
    71 extern bool kernel_return_address_get(stack_trace_context_t *, uintptr_t *);
     63extern bool kernel_frame_pointer_validate(uintptr_t);
     64extern bool kernel_frame_pointer_prev(uintptr_t, uintptr_t *);
     65extern bool kernel_return_address_get(uintptr_t, uintptr_t *);
    7266
    73 extern bool uspace_stack_trace_context_validate(stack_trace_context_t *);
    74 extern bool uspace_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
    75 extern bool uspace_return_address_get(stack_trace_context_t *, uintptr_t *);
     67extern bool uspace_frame_pointer_validate(uintptr_t);
     68extern bool uspace_frame_pointer_prev(uintptr_t, uintptr_t *);
     69extern bool uspace_return_address_get(uintptr_t, uintptr_t *);
    7670
    7771#endif

  • kernel/generic/src/debug/stacktrace.c

    r4d0f97d r24697c3  
    2727 */
    2828
    29 /** @addtogroup genericdebug
     29/** @addtogroup genericdebug 
    3030 * @{
    3131 */
    … …  
    4242
    4343void
    44 stack_trace_ctx(stack_trace_ops_t *ops, stack_trace_context_t *ctx)
     44stack_trace_fp_pc(stack_trace_ops_t *ops, uintptr_t fp, uintptr_t pc)
    4545{
    4646        int cnt = 0;
    4747        const char *symbol;
    4848        uintptr_t offset;
    49         uintptr_t fp;
    50         uintptr_t pc;
    5149       
    52         while (cnt++ < STACK_FRAMES_MAX &&
    53             ops->stack_trace_context_validate(ctx)) {
     50        while (cnt++ < STACK_FRAMES_MAX && ops->frame_pointer_validate(fp)) {
    5451                if (ops->symbol_resolve &&
    55                     ops->symbol_resolve(ctx->pc, &symbol, &offset)) {
     52                    ops->symbol_resolve(pc, &symbol, &offset)) {
    5653                        if (offset)
    57                                 printf("%p: %s+%" PRIp "()\n",
    58                                     ctx->fp, symbol, offset);
     54                                printf("%p: %s+%" PRIp "()\n", fp, symbol, offset);
    5955                        else
    60                                 printf("%p: %s()\n",
    61                                     ctx->fp, symbol);
     56                                printf("%p: %s()\n", fp, symbol);
    6257                } else {
    63                         printf("%p: %p()\n", ctx->fp, ctx->pc);
     58                        printf("%p: %p()\n", fp, pc);
    6459                }
    65                 if (!ops->return_address_get(ctx, &pc))
     60                if (!ops->return_address_get(fp, &pc))
    6661                        break;
    67                 if (!ops->frame_pointer_prev(ctx, &fp))
     62                if (!ops->frame_pointer_prev(fp, &fp))
    6863                        break;
    69                 ctx->fp = fp;
    70                 ctx->pc = pc;
    7164        }
    7265}
    … …  
    7467void stack_trace(void)
    7568{
    76         stack_trace_context_t ctx = {
    77                 .fp = frame_pointer_get(),
    78                 .pc = program_counter_get(),
    79                 .istate = NULL
    80         };
    81 
    82         stack_trace_ctx(&kst_ops, &ctx);
     69        stack_trace_fp_pc(&kst_ops, frame_pointer_get(), program_counter_get());
    8370
    8471        /*
    … …  
    9178void stack_trace_istate(istate_t *istate)
    9279{
    93         stack_trace_context_t ctx = {
    94                 .fp = istate_get_fp(istate),
    95                 .pc = istate_get_pc(istate),
    96                 .istate = istate
    97         };
    98        
    9980        if (istate_from_uspace(istate))
    100                 stack_trace_ctx(&ust_ops, &ctx);
     81                stack_trace_fp_pc(&ust_ops, istate_get_fp(istate),
     82                    istate_get_pc(istate));
    10183        else
    102                 stack_trace_ctx(&kst_ops, &ctx);
     84                stack_trace_fp_pc(&kst_ops, istate_get_fp(istate),
     85                    istate_get_pc(istate));
    10386}
    10487
    105 static bool
    106 kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
     88static bool kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
    10789{
    10890        return (symtab_name_lookup(addr, sp, op) == 0);
    … …  
    11092
    11193stack_trace_ops_t kst_ops = {
    112         .stack_trace_context_validate = kernel_stack_trace_context_validate,
     94        .frame_pointer_validate = kernel_frame_pointer_validate,
    11395        .frame_pointer_prev = kernel_frame_pointer_prev,
    11496        .return_address_get = kernel_return_address_get,
    … …  
    11799
    118100stack_trace_ops_t ust_ops = {
    119         .stack_trace_context_validate = uspace_stack_trace_context_validate,
     101        .frame_pointer_validate = uspace_frame_pointer_validate,
    120102        .frame_pointer_prev = uspace_frame_pointer_prev,
    121103        .return_address_get = uspace_return_address_get,
Note: See TracChangeset for help on using the changeset viewer.