Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset aa0d227 in mainline


Ignore:
Timestamp:
2010-07-16T10:11:41Z (12 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial
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:
13 edited

Legend:

Unmodified
Added
Removed
  • kernel/arch/abs32le/src/debug/stacktrace.c

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

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

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

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

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

    r4003861 raa0d227  
    6868extern bpinfo_t breakpoints[BKPOINTS_MAX];
    6969
     70extern bool is_jump(unative_t);
     71
    7072extern void debugger_init(void);
    7173extern void debugger_bpoint(istate_t *);
  • kernel/arch/mips32/src/debug/stacktrace.c

    r4003861 raa0d227  
    3636#include <syscall/copy.h>
    3737#include <typedefs.h>
    38 
    39 bool kernel_frame_pointer_validate(uintptr_t fp)
     38#include <arch/debugger.h>
     39#include <print.h>
     40
     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
     95extern char ktext_start;
     96extern char ktext_end;
     97
     98static bool
     99scan(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
     206bool 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
     213bool kernel_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
     214{
     215        return scan(ctx, prev, NULL);
     216}
     217
     218bool kernel_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
     219{
     220        return scan(ctx, NULL, ra);
     221}
     222
     223bool uspace_stack_trace_context_validate(stack_trace_context_t *ctx)
    40224{
    41225        return false;
    42226}
    43227
    44 bool kernel_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
     228bool uspace_frame_pointer_prev(stack_trace_context_t *ctx, uintptr_t *prev)
    45229{
    46230        return false;
    47231}
    48232
    49 bool kernel_return_address_get(uintptr_t fp, uintptr_t *ra)
     233bool uspace_return_address_get(stack_trace_context_t *ctx, uintptr_t *ra)
    50234{
    51235        return false;
    52236}
    53237
    54 bool uspace_frame_pointer_validate(uintptr_t fp)
    55 {
    56         return false;
    57 }
    58 
    59 bool uspace_frame_pointer_prev(uintptr_t fp, uintptr_t *prev)
    60 {
    61         return false;
    62 }
    63 
    64 bool uspace_return_address_get(uintptr_t fp, uintptr_t *ra)
    65 {
    66         return false;
    67 }
    68 
    69238/** @}
    70239 */
  • kernel/arch/mips32/src/debug/stacktrace_asm.S

    r4003861 raa0d227  
    3737frame_pointer_get:
    3838        j $ra
    39         xor $v0, $v0
     39        move $v0, $sp
    4040
    4141program_counter_get:
    4242        j $ra
    43         xor $v0, $v0
     43        move $v0, $ra
  • kernel/arch/mips32/src/debugger.c

    r4003861 raa0d227  
    134134 *
    135135 */
    136 static bool is_jump(unative_t instr)
     136bool is_jump(unative_t instr)
    137137{
    138138        unsigned int i;
  • kernel/arch/ppc32/src/debug/stacktrace.c

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

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

    r4003861 raa0d227  
    4242
    4343typedef struct {
    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 *);
     44        uintptr_t fp;
     45        uintptr_t pc;
     46        struct istate *istate;
     47} stack_trace_context_t;
     48
     49typedef 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 *);
    4753        bool (* symbol_resolve)(uintptr_t, const char **, uintptr_t *);
    4854} stack_trace_ops_t;
     
    5359extern void stack_trace(void);
    5460extern void stack_trace_istate(struct istate *);
    55 extern void stack_trace_fp_pc(stack_trace_ops_t *, uintptr_t, uintptr_t);
     61extern void stack_trace_ctx(stack_trace_ops_t *, stack_trace_context_t *);
    5662
    5763/*
     
    6167extern uintptr_t program_counter_get(void);
    6268
    63 extern bool kernel_frame_pointer_validate(uintptr_t);
    64 extern bool kernel_frame_pointer_prev(uintptr_t, uintptr_t *);
    65 extern bool kernel_return_address_get(uintptr_t, uintptr_t *);
     69extern bool kernel_stack_trace_context_validate(stack_trace_context_t *);
     70extern bool kernel_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
     71extern bool kernel_return_address_get(stack_trace_context_t *, uintptr_t *);
    6672
    67 extern bool uspace_frame_pointer_validate(uintptr_t);
    68 extern bool uspace_frame_pointer_prev(uintptr_t, uintptr_t *);
    69 extern bool uspace_return_address_get(uintptr_t, uintptr_t *);
     73extern bool uspace_stack_trace_context_validate(stack_trace_context_t *);
     74extern bool uspace_frame_pointer_prev(stack_trace_context_t *, uintptr_t *);
     75extern bool uspace_return_address_get(stack_trace_context_t *, uintptr_t *);
    7076
    7177#endif
  • kernel/generic/src/debug/stacktrace.c

    r4003861 raa0d227  
    2727 */
    2828
    29 /** @addtogroup genericdebug 
     29/** @addtogroup genericdebug
    3030 * @{
    3131 */
     
    4242
    4343void
    44 stack_trace_fp_pc(stack_trace_ops_t *ops, uintptr_t fp, uintptr_t pc)
     44stack_trace_ctx(stack_trace_ops_t *ops, stack_trace_context_t *ctx)
    4545{
    4646        int cnt = 0;
    4747        const char *symbol;
    4848        uintptr_t offset;
     49        uintptr_t fp;
     50        uintptr_t pc;
    4951       
    50         while (cnt++ < STACK_FRAMES_MAX && ops->frame_pointer_validate(fp)) {
     52        while (cnt++ < STACK_FRAMES_MAX &&
     53            ops->stack_trace_context_validate(ctx)) {
    5154                if (ops->symbol_resolve &&
    52                     ops->symbol_resolve(pc, &symbol, &offset)) {
     55                    ops->symbol_resolve(ctx->pc, &symbol, &offset)) {
    5356                        if (offset)
    54                                 printf("%p: %s+%" PRIp "()\n", fp, symbol, offset);
     57                                printf("%p: %s+%" PRIp "()\n",
     58                                    ctx->fp, symbol, offset);
    5559                        else
    56                                 printf("%p: %s()\n", fp, symbol);
     60                                printf("%p: %s()\n",
     61                                    ctx->fp, symbol);
    5762                } else {
    58                         printf("%p: %p()\n", fp, pc);
     63                        printf("%p: %p()\n", ctx->fp, ctx->pc);
    5964                }
    60                 if (!ops->return_address_get(fp, &pc))
     65                if (!ops->return_address_get(ctx, &pc))
    6166                        break;
    62                 if (!ops->frame_pointer_prev(fp, &fp))
     67                if (!ops->frame_pointer_prev(ctx, &fp))
    6368                        break;
     69                ctx->fp = fp;
     70                ctx->pc = pc;
    6471        }
    6572}
     
    6774void stack_trace(void)
    6875{
    69         stack_trace_fp_pc(&kst_ops, frame_pointer_get(), program_counter_get());
     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);
    7083
    7184        /*
     
    7891void stack_trace_istate(istate_t *istate)
    7992{
     93        stack_trace_context_t ctx = {
     94                .fp = istate_get_fp(istate),
     95                .pc = istate_get_pc(istate),
     96                .istate = istate
     97        };
     98       
    8099        if (istate_from_uspace(istate))
    81                 stack_trace_fp_pc(&ust_ops, istate_get_fp(istate),
    82                     istate_get_pc(istate));
     100                stack_trace_ctx(&ust_ops, &ctx);
    83101        else
    84                 stack_trace_fp_pc(&kst_ops, istate_get_fp(istate),
    85                     istate_get_pc(istate));
     102                stack_trace_ctx(&kst_ops, &ctx);
    86103}
    87104
    88 static bool kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
     105static bool
     106kernel_symbol_resolve(uintptr_t addr, const char **sp, uintptr_t *op)
    89107{
    90108        return (symtab_name_lookup(addr, sp, op) == 0);
     
    92110
    93111stack_trace_ops_t kst_ops = {
    94         .frame_pointer_validate = kernel_frame_pointer_validate,
     112        .stack_trace_context_validate = kernel_stack_trace_context_validate,
    95113        .frame_pointer_prev = kernel_frame_pointer_prev,
    96114        .return_address_get = kernel_return_address_get,
     
    99117
    100118stack_trace_ops_t ust_ops = {
    101         .frame_pointer_validate = uspace_frame_pointer_validate,
     119        .stack_trace_context_validate = uspace_stack_trace_context_validate,
    102120        .frame_pointer_prev = uspace_frame_pointer_prev,
    103121        .return_address_get = uspace_return_address_get,
Note: See TracChangeset for help on using the changeset viewer.