1202 lines
29 KiB
C
1202 lines
29 KiB
C
|
/*
|
|||
|
|
* Copyright (c) 2019-2025 Allwinner Technology Co., Ltd. ALL rights reserved.
|
|||
|
|
*
|
|||
|
|
* Allwinner is a trademark of Allwinner Technology Co.,Ltd., registered in
|
|||
|
|
* the the People's Republic of China and other countries.
|
|||
|
|
* All Allwinner Technology Co.,Ltd. trademarks are used with permission.
|
|||
|
|
*
|
|||
|
|
* DISCLAIMER
|
|||
|
|
* THIRD PARTY LICENCES MAY BE REQUIRED TO IMPLEMENT THE SOLUTION/PRODUCT.
|
|||
|
|
* IF YOU NEED TO INTEGRATE THIRD PARTY’S TECHNOLOGY (SONY, DTS, DOLBY, AVS OR MPEGLA, ETC.)
|
|||
|
|
* IN ALLWINNERS’SDK OR PRODUCTS, YOU SHALL BE SOLELY RESPONSIBLE TO OBTAIN
|
|||
|
|
* ALL APPROPRIATELY REQUIRED THIRD PARTY LICENCES.
|
|||
|
|
* ALLWINNER SHALL HAVE NO WARRANTY, INDEMNITY OR OTHER OBLIGATIONS WITH RESPECT TO MATTERS
|
|||
|
|
* COVERED UNDER ANY REQUIRED THIRD PARTY LICENSE.
|
|||
|
|
* YOU ARE SOLELY RESPONSIBLE FOR YOUR USAGE OF THIRD PARTY’S TECHNOLOGY.
|
|||
|
|
*
|
|||
|
|
*
|
|||
|
|
* THIS SOFTWARE IS PROVIDED BY ALLWINNER"AS IS" AND TO THE MAXIMUM EXTENT
|
|||
|
|
* PERMITTED BY LAW, ALLWINNER EXPRESSLY DISCLAIMS ALL WARRANTIES OF ANY KIND,
|
|||
|
|
* WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING WITHOUT LIMITATION REGARDING
|
|||
|
|
* THE TITLE, NON-INFRINGEMENT, ACCURACY, CONDITION, COMPLETENESS, PERFORMANCE
|
|||
|
|
* OR MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
|
|||
|
|
* IN NO EVENT SHALL ALLWINNER BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|||
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|||
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|||
|
|
* LOSS OF USE, DATA, OR PROFITS, OR BUSINESS INTERRUPTION)
|
|||
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|||
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|||
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
|
|||
|
|
* OF THE POSSIBILITY OF SUCH DAMAGE.
|
|||
|
|
*/
|
|||
|
|
#include <stddef.h>
|
|||
|
|
#include <stdint.h>
|
|||
|
|
#include <string.h>
|
|||
|
|
#include <limits.h>
|
|||
|
|
#include <stdio.h>
|
|||
|
|
|
|||
|
|
#include <rtthread.h>
|
|||
|
|
#include <excep.h>
|
|||
|
|
|
|||
|
|
#include <backtrace.h>
|
|||
|
|
|
|||
|
|
#include <hal_thread.h>
|
|||
|
|
#include <hal_interrupt.h>
|
|||
|
|
|
|||
|
|
#ifdef CONFIG_KALLSYMS
|
|||
|
|
#include <kallsyms.h>
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
//#define BACKTRACE_DEBUG 1
|
|||
|
|
|
|||
|
|
#ifndef BACKTRACE_DEBUG
|
|||
|
|
#define backtrace_debug(fmt, ...)
|
|||
|
|
#else
|
|||
|
|
#define backtrace_debug(fmt, ...) \
|
|||
|
|
printf("[%s:%d]:"fmt, __func__, __LINE__, ##__VA_ARGS__)
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
#define BT_SCAN_MAX_LIMIT 0x2000
|
|||
|
|
#define BT_LEVEL_LIMIT 64
|
|||
|
|
|
|||
|
|
#define PC2ADDR(pc) ((char *)(((uintptr_t)(pc)) & 0xfffffffe))
|
|||
|
|
|
|||
|
|
#define IS_VALID_TEXT_ADDRESS(pc) backtrace_check_address((uintptr_t)(pc))
|
|||
|
|
|
|||
|
|
int32_t check_virtual_address(uintptr_t vaddr);
|
|||
|
|
|
|||
|
|
int backtrace_check_address(uintptr_t pc)
|
|||
|
|
{
|
|||
|
|
#ifdef CONFIG_SOC_SUN20IW1P1
|
|||
|
|
if (pc < (CONFIG_DRAM_PHYBASE + 64 * 1024))
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
if (pc > (0xFFFFFFFF))
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
return check_virtual_address(pc);
|
|||
|
|
#else
|
|||
|
|
if ((pc > CONFIG_DRAM_PHYBASE) && (pc < (CONFIG_DRAM_PHYBASE + CONFIG_DRAM_SIZE)))
|
|||
|
|
{
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
return 0;
|
|||
|
|
#endif
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#define insn_length(x) \
|
|||
|
|
(((x) & 0x03) < 0x03 ? 2 : \
|
|||
|
|
((x) & 0x1f) < 0x1f ? 4 : \
|
|||
|
|
((x) & 0x3f) < 0x3f ? 6 : \
|
|||
|
|
8)
|
|||
|
|
|
|||
|
|
#define BITS(x, high, low) ((x) & (((1<<((high)-(low)+1))-1) << (low)))
|
|||
|
|
#define BITS_SHIFT(x, high, low) (((x) >> (low)) & ((1<<((high)-(low)+1))-1))
|
|||
|
|
#define SIGN_EXTEND(val, topbit) (BIT(val, topbit) ? ((val) | (0xffffffff << (topbit))) : (val))
|
|||
|
|
|
|||
|
|
typedef struct
|
|||
|
|
{
|
|||
|
|
rt_thread_t task;
|
|||
|
|
} tcb_shadow_t;
|
|||
|
|
|
|||
|
|
typedef struct
|
|||
|
|
{
|
|||
|
|
switch_ctx_regs_t regs_ctx;
|
|||
|
|
} switch_context_t;
|
|||
|
|
|
|||
|
|
enum task_states
|
|||
|
|
{
|
|||
|
|
TASK_SUSPEND = 0,
|
|||
|
|
TASK_READY,
|
|||
|
|
TASK_INTERRUPTED,
|
|||
|
|
TASK_RUNNING,
|
|||
|
|
};
|
|||
|
|
|
|||
|
|
extern void ret_from_create_c(void);
|
|||
|
|
extern unsigned long riscv_cpu_handle_interrupt(unsigned long scause, unsigned long sepc, unsigned long stval, irq_regs_t *regs);
|
|||
|
|
|
|||
|
|
static void *get_task_stack_bottom(void *task)
|
|||
|
|
{
|
|||
|
|
return (void *)ret_from_create_c;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void *find_task(char *name)
|
|||
|
|
{
|
|||
|
|
return rt_thread_find(name);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int check_task_is_running(void *task)
|
|||
|
|
{
|
|||
|
|
rt_thread_t thread = (rt_thread_t)task;
|
|||
|
|
|
|||
|
|
if (thread == NULL)
|
|||
|
|
{
|
|||
|
|
return TASK_SUSPEND;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (thread == kthread_self() && hal_interrupt_get_nest() == 0)
|
|||
|
|
{
|
|||
|
|
return TASK_RUNNING;
|
|||
|
|
}
|
|||
|
|
else if (thread == kthread_self())
|
|||
|
|
{
|
|||
|
|
return TASK_INTERRUPTED;
|
|||
|
|
}
|
|||
|
|
else if (thread->stat == RT_THREAD_READY)
|
|||
|
|
{
|
|||
|
|
return TASK_READY;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
return TASK_SUSPEND;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* convert long to string
|
|||
|
|
*/
|
|||
|
|
static char *long2str(long num, char *str)
|
|||
|
|
{
|
|||
|
|
char index[] = "0123456789ABCDEF";
|
|||
|
|
unsigned long usnum = (unsigned long)num;
|
|||
|
|
|
|||
|
|
str[7] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[6] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[5] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[4] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[3] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[2] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[1] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
str[0] = index[usnum % 16];
|
|||
|
|
usnum /= 16;
|
|||
|
|
|
|||
|
|
return str;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void print_backtrace(print_function print_func, unsigned long addr)
|
|||
|
|
{
|
|||
|
|
char backtrace_output_buf[] = "backtrace : 0X ";
|
|||
|
|
#ifdef CONFIG_KALLSYMS
|
|||
|
|
char sym_buffer[KSYM_NAME_LEN];
|
|||
|
|
#endif
|
|||
|
|
if (print_func) {
|
|||
|
|
long2str(addr, &backtrace_output_buf[14]);
|
|||
|
|
print_func(backtrace_output_buf);
|
|||
|
|
#ifdef CONFIG_KALLSYMS
|
|||
|
|
sprint_symbol(sym_buffer, addr);
|
|||
|
|
print_func(" : %s", sym_buffer);
|
|||
|
|
#endif
|
|||
|
|
print_func("\r\n");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static void get_register_from_task_stack(void *context, char **PC, char **LR, long **SP)
|
|||
|
|
{
|
|||
|
|
switch_context_t *task_ctx;
|
|||
|
|
|
|||
|
|
task_ctx = (switch_context_t *)context;
|
|||
|
|
*PC = (char *)task_ctx->regs_ctx.ra;
|
|||
|
|
*LR = (char *)task_ctx->regs_ctx.ra;
|
|||
|
|
*SP = (long *)(task_ctx + 1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int find_lr_offset(char *LR, print_function print_func)
|
|||
|
|
{
|
|||
|
|
char *LR_fixed;
|
|||
|
|
unsigned short ins16;
|
|||
|
|
int offset = 4;
|
|||
|
|
#ifdef CONFIG_SOC_SUN20IW1
|
|||
|
|
unsigned long *irq_entry = (unsigned long *)&riscv_cpu_handle_interrupt;
|
|||
|
|
#else
|
|||
|
|
unsigned long *irq_entry = NULL;
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
irq_entry ++;
|
|||
|
|
LR_fixed = LR;
|
|||
|
|
/* meet irq_entry, it is irq handler exit address. */
|
|||
|
|
if (LR_fixed == PC2ADDR(irq_entry))
|
|||
|
|
{
|
|||
|
|
print_backtrace(print_func, (unsigned long)irq_entry);
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* meet ret_from_create_c, it is task exit function */
|
|||
|
|
if (LR_fixed == PC2ADDR(&ret_from_create_c))
|
|||
|
|
{
|
|||
|
|
print_backtrace(print_func, (unsigned long)&ret_from_create_c);
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(LR_fixed - 4) == 0)
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ins16 = *(unsigned short *)(LR_fixed - 4);
|
|||
|
|
offset = insn_length(ins16);
|
|||
|
|
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_backtrace(print_func, (unsigned long)LR_fixed - offset);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return offset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int riscv_ins32_get_push_lr_framesize(unsigned int inst, int *offset)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x\n", inst);
|
|||
|
|
|
|||
|
|
if ((inst & 0x01FFF07F) == 0x113023)
|
|||
|
|
{
|
|||
|
|
/* sd ra, (offset)sp */
|
|||
|
|
int immed = (inst & 0xF80);
|
|||
|
|
immed >>= 7;
|
|||
|
|
immed |= ((inst & 0xFE000000) >> 25) << 5;
|
|||
|
|
if (((immed >> 11) & 0x01) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
}
|
|||
|
|
*offset = immed / sizeof(long);
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0x000FFFFF) == 0x10113)
|
|||
|
|
{
|
|||
|
|
/* addi sp, sp, #imm */
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0x000FFFFF) == 0x1011B)
|
|||
|
|
{
|
|||
|
|
/* addiw sp, sp, #imm */
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_ins16_get_push_lr_framesize(unsigned short inst, int *offset)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x: ", inst);
|
|||
|
|
|
|||
|
|
if ((inst & 0xE07E) == 0xE006)
|
|||
|
|
{
|
|||
|
|
/* c.sdsp ra, (offset)sp */
|
|||
|
|
int immed_6_8 = (inst >> 7) & 0x07 ;
|
|||
|
|
int immed_3_5 = (inst >> 10) & 0x07 ;
|
|||
|
|
int immed = immed_6_8 << 6 | immed_3_5 << 3;
|
|||
|
|
*offset = immed / sizeof(long);
|
|||
|
|
backtrace_debug("immed=%d ", immed);
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xE07E) == 0xC006)
|
|||
|
|
{
|
|||
|
|
/* c.swsp ra, (offset)sp */
|
|||
|
|
int immed_6_7 = (inst >> 7) & 0x03 ;
|
|||
|
|
int immed_2_5 = (inst >> 9) & 0x0f ;
|
|||
|
|
int immed = immed_6_7 << 6 | immed_2_5 << 2;
|
|||
|
|
*offset = immed / sizeof(long);
|
|||
|
|
backtrace_debug("immed=%d ", immed);
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF83) == 0x6101)
|
|||
|
|
{
|
|||
|
|
/* c.addi16sp #imm */
|
|||
|
|
int immed_5 = (inst >> 2) & 0x01 ;
|
|||
|
|
int immed_7_8 = (inst >> 3) & 0x3 ;
|
|||
|
|
int immed_6 = (inst >> 5) & 0x1 ;
|
|||
|
|
int immed_4 = (inst >> 6) & 0x1 ;
|
|||
|
|
int immed_9 = (inst >> 12) & 0x1 ;
|
|||
|
|
int immed = immed_5 << 5 | immed_7_8 << 7 | immed_6 << 6 | immed_4 << 4 | immed_9 << 9;
|
|||
|
|
|
|||
|
|
backtrace_debug("immed=%d ", immed);
|
|||
|
|
|
|||
|
|
if ((immed >> 9) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3FF - immed + 1;
|
|||
|
|
ret = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x101)
|
|||
|
|
{
|
|||
|
|
/* c.addi sp, sp, #imm */
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F ;
|
|||
|
|
int immed_5 = (inst >> 12) & 0x1 ;
|
|||
|
|
int immed = immed_5 << 5 | immed_0_4;
|
|||
|
|
|
|||
|
|
backtrace_debug("immed=%d ", immed);
|
|||
|
|
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
ret = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x2101)
|
|||
|
|
{
|
|||
|
|
/* c.addiw sp, #imm */
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F ;
|
|||
|
|
int immed_5 = (inst >> 12) & 0x1 ;
|
|||
|
|
int immed = immed_5 << 5 | immed_0_4;
|
|||
|
|
|
|||
|
|
backtrace_debug("immed=%d ", immed);
|
|||
|
|
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
ret = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#if 0
|
|||
|
|
else if ((inst & 0xE01F) == 0x0)
|
|||
|
|
{
|
|||
|
|
/* c.addi4spn #imm */
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
backtrace_debug("ret = %d\n", ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_ins32_backtrace_return_pop(unsigned int inst)
|
|||
|
|
{
|
|||
|
|
backtrace_debug("inst:0x%x\n", inst);
|
|||
|
|
#if 0
|
|||
|
|
/* addi sp, sp, #imm */
|
|||
|
|
if ((inst & 0x000FFFFF) == 0x10113)
|
|||
|
|
{
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
}
|
|||
|
|
return immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
/* ret */
|
|||
|
|
if ((inst) == 0x00008067)
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_ins16_backtrace_return_pop(unsigned short inst)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
if ((inst) == 0x8082)
|
|||
|
|
{
|
|||
|
|
ret = 0;;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x, ret = %d\n", inst, ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int riscv_ins32_backtrace_stask_push(unsigned int inst)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
if ((inst & 0x000FFFFF) == 0x10113)
|
|||
|
|
{
|
|||
|
|
/* addi sp, sp, #imm */
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0x000FFFFF) == 0x1011B)
|
|||
|
|
{
|
|||
|
|
/* addiw sp, sp, #imm */
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x, ret = %d\n", inst, ret);
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
static int riscv_ins16_backtrace_stask_push(unsigned int inst)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
if ((inst & 0xEF83) == 0x6101)
|
|||
|
|
{
|
|||
|
|
/* c.addi16sp #imm */
|
|||
|
|
int immed_4 = (inst >> 6) & 0x01;
|
|||
|
|
int immed_5 = (inst >> 2) & 0x01;
|
|||
|
|
int immed_6 = (inst >> 5) & 0x01;
|
|||
|
|
int immed_7_8 = (inst >> 3) & 0x3;
|
|||
|
|
int immed_9 = (inst >> 12) & 0x1;
|
|||
|
|
int immed = (immed_4 << 4) | (immed_5 << 5) | (immed_6 << 6) | (immed_7_8 << 7) | (immed_9 << 9);
|
|||
|
|
if ((immed >> 9) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3FF - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x101)
|
|||
|
|
{
|
|||
|
|
/* c.addi sp, sp, #imm */
|
|||
|
|
int immed_5 = (inst >> 12) & 0x01;
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F;
|
|||
|
|
int immed = (immed_0_4) | (immed_5 << 5);
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x2101)
|
|||
|
|
{
|
|||
|
|
/* c.addiw sp, #imm */
|
|||
|
|
int immed_5 = (inst >> 12) & 0x01;
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F;
|
|||
|
|
int immed = (immed_0_4) | (immed_5 << 5);
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
#if 0
|
|||
|
|
else if ((inst & 0xE01F) == 0x0)
|
|||
|
|
{
|
|||
|
|
/* c.addi4spn #imm */
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
backtrace_debug("inst:0x%x, ret = %d\n", inst, ret);
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_ins32_backtrace_stack_pop(unsigned int inst)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
/* addi sp, sp, #imm */
|
|||
|
|
if ((inst & 0x000FFFFF) == 0x10113)
|
|||
|
|
{
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0x000FFFFF) == 0x1011B)
|
|||
|
|
{
|
|||
|
|
/* addiw sp, sp, #imm */
|
|||
|
|
int immed = BITS(inst, 31, 20);
|
|||
|
|
immed >>= 20;
|
|||
|
|
immed &= 0xFFF;
|
|||
|
|
if ((immed >> 11) != 0)
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
immed = 0xFFF - immed + 1;
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x\n", inst);
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_ins16_backtrace_stack_pop(unsigned short inst)
|
|||
|
|
{
|
|||
|
|
int ret = -1;
|
|||
|
|
|
|||
|
|
backtrace_debug("inst:0x%x\n", inst);
|
|||
|
|
|
|||
|
|
if ((inst & 0xEF83) == 0x6101)
|
|||
|
|
{
|
|||
|
|
/* c.addi16sp #imm */
|
|||
|
|
int immed_4 = (inst >> 6) & 0x01;
|
|||
|
|
int immed_5 = (inst >> 2) & 0x01;
|
|||
|
|
int immed_6 = (inst >> 5) & 0x01;
|
|||
|
|
int immed_7_8 = (inst >> 3) & 0x3;
|
|||
|
|
int immed_9 = (inst >> 12) & 0x1;
|
|||
|
|
int immed = (immed_4 << 4) | (immed_5 << 5) | (immed_6 << 6) | (immed_7_8 << 7) | (immed_9 << 9);
|
|||
|
|
if ((immed >> 9) != 0)
|
|||
|
|
{
|
|||
|
|
immed = 0x3FF - immed + 1;
|
|||
|
|
}
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x101)
|
|||
|
|
{
|
|||
|
|
/* c.addi sp, sp, #imm */
|
|||
|
|
int immed_5 = (inst >> 12) & 0x01;
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F;
|
|||
|
|
int immed = (immed_0_4) | (immed_5 << 5);
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
}
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
else if ((inst & 0xEF03) == 0x2101)
|
|||
|
|
{
|
|||
|
|
/* c.addiw sp, #imm */
|
|||
|
|
int immed_5 = (inst >> 12) & 0x01;
|
|||
|
|
int immed_0_4 = (inst >> 2) & 0x1F;
|
|||
|
|
int immed = (immed_0_4) | (immed_5 << 5);
|
|||
|
|
if ((immed >> 5) != 0)
|
|||
|
|
{
|
|||
|
|
ret = -1;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
immed = 0x3F - immed + 1;
|
|||
|
|
}
|
|||
|
|
ret = immed / sizeof(long);
|
|||
|
|
}
|
|||
|
|
#if 0
|
|||
|
|
else if ((inst & 0xE01F) == 0x0)
|
|||
|
|
{
|
|||
|
|
/* c.addi4spn #imm */
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
backtrace_debug("inst:0x%x\n", inst);
|
|||
|
|
|
|||
|
|
return ret;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_backtrace_from_stack(long **pSP, char **pPC, char **pLR,
|
|||
|
|
print_function print_func)
|
|||
|
|
{
|
|||
|
|
char *parse_addr = NULL;
|
|||
|
|
long *SP = *pSP;
|
|||
|
|
char *PC = *pPC;
|
|||
|
|
char *LR = *pLR;
|
|||
|
|
int i;
|
|||
|
|
int temp;
|
|||
|
|
int framesize = 0;
|
|||
|
|
int offset = 0;
|
|||
|
|
unsigned int ins32 = 0;
|
|||
|
|
unsigned short ins16 = 0;
|
|||
|
|
unsigned short ins16_h = 0;
|
|||
|
|
unsigned short ins16_l = 0;
|
|||
|
|
|
|||
|
|
if (SP == get_task_stack_bottom(NULL))
|
|||
|
|
{
|
|||
|
|
print_backtrace(print_func, (unsigned long)&ret_from_create_c);
|
|||
|
|
return 1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
#ifndef CONFIG_KALLSYMS
|
|||
|
|
for (i = 2; i < BT_SCAN_MAX_LIMIT; i += 2)
|
|||
|
|
{
|
|||
|
|
int result = 0;
|
|||
|
|
parse_addr = PC - i;
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_h = *(unsigned short *)parse_addr;
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr - 2) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_l = *(unsigned short *)(parse_addr - 2);
|
|||
|
|
|
|||
|
|
backtrace_debug("parse_addr = %p:", parse_addr);
|
|||
|
|
|
|||
|
|
if (insn_length(ins16_l) == 4)
|
|||
|
|
{
|
|||
|
|
ins32 = (ins16_h << 16) | ins16_l;
|
|||
|
|
result = riscv_ins32_get_push_lr_framesize(ins32, &offset);
|
|||
|
|
i += 2;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ins16 = ins16_h;
|
|||
|
|
result = riscv_ins16_get_push_lr_framesize(ins16, &offset);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (result >= 0)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
parse_addr = PC - i;
|
|||
|
|
|
|||
|
|
backtrace_debug("i = %d, parse_addr = %p, PC = %p, offset = %d\n", i, parse_addr, PC, offset);
|
|||
|
|
|
|||
|
|
if (i == BT_SCAN_MAX_LIMIT)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
#else
|
|||
|
|
if (!kallsyms_lookup_size_offset((unsigned long)PC, NULL, (unsigned long *)&offset)) {
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
parse_addr = (char *)((unsigned long)PC - offset);
|
|||
|
|
backtrace_debug("function boundary: %p for %p, offset = %d\n", parse_addr, PC, offset);
|
|||
|
|
offset = -1;
|
|||
|
|
for (i = 0; parse_addr + i < PC; i += 2)
|
|||
|
|
{
|
|||
|
|
int result = 0;
|
|||
|
|
char *parse = PC - i;
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_h = *(unsigned short *)parse;
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse- 2) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_l = *(unsigned short *)(parse - 2);
|
|||
|
|
|
|||
|
|
backtrace_debug("parse = %p:", parse);
|
|||
|
|
|
|||
|
|
if (insn_length(ins16_l) == 4)
|
|||
|
|
{
|
|||
|
|
ins32 = (ins16_h << 16) | ins16_l;
|
|||
|
|
result = riscv_ins32_get_push_lr_framesize(ins32, &offset);
|
|||
|
|
i += 2;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ins16 = ins16_h;
|
|||
|
|
result = riscv_ins16_get_push_lr_framesize(ins16, &offset);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (offset >= 0)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* PC maybe in leaf function, we directily use ra */
|
|||
|
|
backtrace_debug("parse_addr = %p, PC = %p, offset = %d\n", parse_addr, PC, offset);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
for (i = 0; parse_addr + i < PC; i += 2)
|
|||
|
|
{
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr + i) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_l = *(unsigned short *)(parse_addr + i);
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr + i + 2) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
ins16_h = *(unsigned short *)(parse_addr + i + 2);
|
|||
|
|
|
|||
|
|
if (insn_length(ins16_l) == 4 || ins16_l == 0)
|
|||
|
|
{
|
|||
|
|
ins32 = (ins16_h << 16) | ins16_l;
|
|||
|
|
temp = riscv_ins32_backtrace_stask_push(ins32);
|
|||
|
|
i += 2;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ins16 = ins16_l;
|
|||
|
|
temp = riscv_ins16_backtrace_stask_push(ins16);
|
|||
|
|
}
|
|||
|
|
if (temp >= 0)
|
|||
|
|
{
|
|||
|
|
framesize += temp;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("i = %d, framesize = %d, SP = %p\n", i, framesize, SP);
|
|||
|
|
|
|||
|
|
#ifdef CONFIG_KALLSYMS
|
|||
|
|
if (offset == -1 || framesize == 0) {
|
|||
|
|
LR = *pLR;
|
|||
|
|
offset = 0;
|
|||
|
|
goto leaf_func;
|
|||
|
|
}
|
|||
|
|
#endif
|
|||
|
|
if (!offset)
|
|||
|
|
{
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(SP + offset) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace : invalid lr\r\n");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
LR = (char *) * (SP + offset);
|
|||
|
|
#ifdef CONFIG_KALLSYMS
|
|||
|
|
leaf_func:
|
|||
|
|
#endif
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(LR) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace : invalid lr\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
*pSP = SP + framesize;
|
|||
|
|
offset = find_lr_offset(LR, print_func);
|
|||
|
|
*pPC = LR - offset;
|
|||
|
|
|
|||
|
|
backtrace_debug("*pSP = %p, offset = %d, *pPC = %p\n", *pSP, offset, *pPC);
|
|||
|
|
|
|||
|
|
return offset == 0 ? 1 : 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int riscv_backtrace_from_lr(long **pSP, char **pPC, char *LR,
|
|||
|
|
print_function print_func)
|
|||
|
|
{
|
|||
|
|
long *SP = *pSP;
|
|||
|
|
char *PC = *pPC;
|
|||
|
|
char *parse_addr = NULL;
|
|||
|
|
int i;
|
|||
|
|
int temp;
|
|||
|
|
int framesize = 0;
|
|||
|
|
int offset;
|
|||
|
|
int result = 0;
|
|||
|
|
unsigned int ins32 = 0;
|
|||
|
|
unsigned short ins16 = 0;
|
|||
|
|
unsigned short ins16_h = 0;
|
|||
|
|
unsigned short ins16_l = 0;
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(PC) == 0)
|
|||
|
|
{
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(LR) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace : invalid lr\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
offset = find_lr_offset(LR, print_func);
|
|||
|
|
PC = LR - offset;
|
|||
|
|
*pPC = PC;
|
|||
|
|
return offset == 0 ? 1 : 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (i = 0; i < BT_SCAN_MAX_LIMIT; i += 2)
|
|||
|
|
{
|
|||
|
|
parse_addr = PC + i;
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr + 2) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ins16_l = *(unsigned short *)parse_addr;
|
|||
|
|
ins16_h = *(unsigned short *)(parse_addr + 2);
|
|||
|
|
|
|||
|
|
if (insn_length(ins16_l) == 4 || ins16_l == 0)
|
|||
|
|
{
|
|||
|
|
ins32 = (ins16_h << 16) | ins16_l;
|
|||
|
|
result = riscv_ins32_backtrace_return_pop(ins32);
|
|||
|
|
i += 2;
|
|||
|
|
parse_addr -= 4;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ins16 = ins16_l;
|
|||
|
|
result = riscv_ins16_backtrace_return_pop(ins16);
|
|||
|
|
parse_addr -= 2;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (result >= 0)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("i = %d, parse_addr = %p, PC = %p, framesize = %d\n", i, parse_addr, PC, framesize);
|
|||
|
|
|
|||
|
|
framesize = result;
|
|||
|
|
|
|||
|
|
if (i == BT_SCAN_MAX_LIMIT)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("Backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
for (i = 0; parse_addr - i >= PC; i += 2)
|
|||
|
|
{
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr - i) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("Backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(parse_addr - i - 2) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("Backtrace fail!\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ins16_l = *(unsigned short *)(parse_addr - i - 2);
|
|||
|
|
ins16_h = *(unsigned short *)(parse_addr - i);
|
|||
|
|
|
|||
|
|
if (insn_length(ins16_l) == 4)
|
|||
|
|
{
|
|||
|
|
ins32 = (ins16_h << 16) | ins16_l;
|
|||
|
|
temp = riscv_ins32_backtrace_stack_pop(ins32);
|
|||
|
|
i += 2;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
ins16 = ins16_h;
|
|||
|
|
temp = riscv_ins16_backtrace_stack_pop(ins16);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (temp >= 0)
|
|||
|
|
{
|
|||
|
|
backtrace_debug("framesize add %d\n", temp);
|
|||
|
|
framesize += temp;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
backtrace_debug("i = %d, parse_addr = %p, PC = %p, SP = %p, framesize = %d\n", i, parse_addr, PC, SP, framesize);
|
|||
|
|
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(LR) == 0)
|
|||
|
|
{
|
|||
|
|
if (print_func != NULL)
|
|||
|
|
{
|
|||
|
|
print_func("backtrace : invalid lr\r\n");
|
|||
|
|
}
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
*pSP = SP + framesize;
|
|||
|
|
offset = find_lr_offset(LR, print_func);
|
|||
|
|
*pPC = LR - offset;
|
|||
|
|
|
|||
|
|
backtrace_debug("*pSP = %p, offset = %d, *pPC = %p\n", *pSP, offset, *pPC);
|
|||
|
|
|
|||
|
|
return offset == 0 ? 1 : 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int backtrace_from_stack(long **pSP, char **pPC, char **pLR,
|
|||
|
|
print_function print_func)
|
|||
|
|
{
|
|||
|
|
if (IS_VALID_TEXT_ADDRESS(*pPC) == 0)
|
|||
|
|
{
|
|||
|
|
return -1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return riscv_backtrace_from_stack(pSP, pPC, pLR, print_func);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
static int backtrace_from_lr(long **pSP, char **pPC, char *LR,
|
|||
|
|
print_function print_func)
|
|||
|
|
{
|
|||
|
|
return riscv_backtrace_from_lr(pSP, pPC, LR, print_func);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* _backtrace function
|
|||
|
|
* @taskname: the task need to get call stack
|
|||
|
|
* @output:the call stack output buffer
|
|||
|
|
* @size: the size of output
|
|||
|
|
* @offset:
|
|||
|
|
* @print_func: print function
|
|||
|
|
* @arg_cpsr: cpsr register value when use in exception mode
|
|||
|
|
* @arg_sp: sp register value when use in exception mode
|
|||
|
|
* @arg_pc: pc register value when use in exception mode
|
|||
|
|
* @arg_lr: lr register value when use in exception mode
|
|||
|
|
* @exception_mode: 0/1; 0:normal mode, 1:exception mode
|
|||
|
|
*/
|
|||
|
|
static int _backtrace(char *taskname, void *output[], int size, int offset, print_function print_func,
|
|||
|
|
unsigned long arg_cpsr,
|
|||
|
|
unsigned long arg_sp,
|
|||
|
|
unsigned long arg_pc,
|
|||
|
|
unsigned long arg_lr,
|
|||
|
|
unsigned long exception_mode)
|
|||
|
|
{
|
|||
|
|
char *PC = NULL;
|
|||
|
|
long *SP = NULL;
|
|||
|
|
char *saved_pc;
|
|||
|
|
long *saved_sp;
|
|||
|
|
unsigned long CPSR = 0;
|
|||
|
|
int level;
|
|||
|
|
int ret;
|
|||
|
|
tcb_shadow_t *task = NULL;
|
|||
|
|
char *LR = NULL;
|
|||
|
|
int check_self = 0;
|
|||
|
|
|
|||
|
|
if (output && size > 0)
|
|||
|
|
{
|
|||
|
|
memset(output, 0, size * sizeof(void *));
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (taskname)
|
|||
|
|
{
|
|||
|
|
task = find_task(taskname);
|
|||
|
|
if (task == NULL)
|
|||
|
|
{
|
|||
|
|
if (print_func)
|
|||
|
|
{
|
|||
|
|
print_func("Task not found : %s\n", taskname);
|
|||
|
|
}
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
get_register_from_task_stack(((rt_thread_t)task)->sp, &PC, &LR, &SP);
|
|||
|
|
if (check_task_is_running(task) == TASK_RUNNING ||
|
|||
|
|
check_task_is_running(task) == TASK_INTERRUPTED)
|
|||
|
|
{
|
|||
|
|
check_self = 1;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((taskname == NULL || check_self == 1) && exception_mode != 1)
|
|||
|
|
{
|
|||
|
|
__asm__ volatile("mv %0, sp\n" : "=r"(SP));
|
|||
|
|
__asm__ volatile("auipc %0, 0\n" : "=r"(PC));
|
|||
|
|
__asm__ volatile("mv %0, ra\n" : "=r"(LR));
|
|||
|
|
check_self = 1;
|
|||
|
|
}
|
|||
|
|
else if (exception_mode == 1)
|
|||
|
|
{
|
|||
|
|
LR = (char *)arg_lr;
|
|||
|
|
SP = (long *)arg_sp;
|
|||
|
|
PC = (char *)arg_pc;
|
|||
|
|
CPSR = arg_cpsr;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (SP == NULL)
|
|||
|
|
{
|
|||
|
|
return 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
ret = -1;
|
|||
|
|
level = 0;
|
|||
|
|
if (output)
|
|||
|
|
{
|
|||
|
|
if (level >= offset && level - offset < size)
|
|||
|
|
{
|
|||
|
|
output[level - offset] = PC;
|
|||
|
|
}
|
|||
|
|
if (level - offset >= size)
|
|||
|
|
{
|
|||
|
|
goto out;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
print_backtrace(print_func, (unsigned long)PC);
|
|||
|
|
|
|||
|
|
for (level = 1; level < BT_LEVEL_LIMIT; level++)
|
|||
|
|
{
|
|||
|
|
ret = backtrace_from_stack(&SP, &PC, &LR, print_func);
|
|||
|
|
if (ret != 0)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (output)
|
|||
|
|
{
|
|||
|
|
if (level >= offset && level - offset < size)
|
|||
|
|
{
|
|||
|
|
output[level - offset] = PC;
|
|||
|
|
}
|
|||
|
|
if (level - offset >= size)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if ((check_self == 0 || exception_mode == 1) && level == 1)
|
|||
|
|
{
|
|||
|
|
ret = backtrace_from_lr(&SP, &PC, LR, print_func);
|
|||
|
|
if (ret == 0)
|
|||
|
|
{
|
|||
|
|
for (; level < BT_LEVEL_LIMIT; level++)
|
|||
|
|
{
|
|||
|
|
ret = backtrace_from_stack(&SP, &PC, &LR, print_func);
|
|||
|
|
if (ret != 0)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
if (output)
|
|||
|
|
{
|
|||
|
|
if (level >= offset && level - offset < size)
|
|||
|
|
{
|
|||
|
|
output[level - offset] = PC;
|
|||
|
|
}
|
|||
|
|
if (level - offset >= size)
|
|||
|
|
{
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
out:
|
|||
|
|
return level - offset < 0 ? 0 : level - offset;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int arch_backtrace(char *taskname, void *trace[], int size, int offset, print_function print_func)
|
|||
|
|
{
|
|||
|
|
return _backtrace(taskname, trace, size, offset, print_func, 0, 0, 0, 0, 0);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
int arch_backtrace_exception(print_function print_func,
|
|||
|
|
unsigned long arg_cpsr,
|
|||
|
|
unsigned long arg_sp,
|
|||
|
|
unsigned long arg_pc,
|
|||
|
|
unsigned long arg_lr)
|
|||
|
|
{
|
|||
|
|
return _backtrace(NULL, NULL, 0, 0, print_func, arg_cpsr, arg_sp, arg_pc, arg_lr, 1);
|
|||
|
|
}
|