static void __stp_dwarf_stack_user_print(struct pt_regs *regs, int verbose,
int levels, struct unwind_context *uwcontext,
struct uretprobe_instance *ri, int uregs_valid)
{
struct unwind_frame_info *info = &uwcontext->info;
arch_unw_init_frame_info(info, regs, ! uregs_valid);
while (levels) {
int ret = unwind(uwcontext, 1);
#ifdef STAPCONF_UPROBE_GET_PC
unsigned long maybe_pc = 0;
if (ri) {
maybe_pc = uprobe_get_pc(ri, UNW_PC(info),
UNW_SP(info));
if (!maybe_pc)
printk("SYSTEMTAP ERROR: uprobe_get_return returned 0\n");
else
UNW_PC(info) = maybe_pc;
}
#endif
dbug_unwind(1, "ret=%d PC=%lx SP=%lx\n", ret, UNW_PC(info), UNW_SP(info));
if (ret == 0 && _stp_valid_pc_addr(UNW_PC(info), current)) {
_stp_print_addr(UNW_PC(info), verbose, current);
levels--;
continue;
}
/* If an error happened or the PC becomes invalid, then
* we are done, _stp_stack_print_fallback is only for
* kernel space. */
return;
}
}
static void __stp_dwarf_stack_kernel_print(struct pt_regs *regs, int verbose,
int levels, struct unwind_context *uwcontext)
{
struct unwind_frame_info *info = &uwcontext->info;
arch_unw_init_frame_info(info, regs, 0);
while (levels) {
int ret = unwind(uwcontext, 0);
dbug_unwind(1, "ret=%d PC=%lx SP=%lx\n", ret, UNW_PC(info), UNW_SP(info));
if (ret == 0 && _stp_valid_pc_addr(UNW_PC(info), NULL)) {
_stp_print_addr(UNW_PC(info), verbose, NULL);
levels--;
if (UNW_PC(info) != _stp_kretprobe_trampoline)
continue;
}
/* If an error happened or we hit a kretprobe trampoline,
* and the current pc frame address is still valid kernel
* address use fallback backtrace, unless user task backtrace.
* FIXME: is there a way to unwind across kretprobe
* trampolines? PR9999. */
if ((ret < 0 || UNW_PC(info) == _stp_kretprobe_trampoline))
_stp_stack_print_fallback(UNW_SP(info),
verbose, levels, 0);
return;
}
}
static void __stp_stack_print(struct pt_regs *regs, int verbose, int levels,
struct task_struct *tsk,
struct uretprobe_instance *ri, int uregs_valid)
{
#ifdef STP_USE_DWARF_UNWINDER
int start_levels = levels;
// FIXME: large stack allocation
struct unwind_frame_info info;
int sanitize = tsk && ! uregs_valid;
arch_unw_init_frame_info(&info, regs, sanitize);
while (levels && (tsk || !arch_unw_user_mode(&info))) {
int ret = unwind(&info, tsk);
#ifdef STAPCONF_UPROBE_GET_PC
unsigned long maybe_pc = 0;
if (ri) {
maybe_pc = uprobe_get_pc(ri, UNW_PC(&info),
UNW_SP(&info));
if (!maybe_pc)
printk("SYSTEMTAP ERROR: uprobe_get_return returned 0\n");
else
UNW_PC(&info) = maybe_pc;
}
#endif
dbug_unwind(1, "ret=%d PC=%lx SP=%lx\n", ret, UNW_PC(&info), UNW_SP(&info));
if (ret == 0) {
_stp_print_addr(UNW_PC(&info), verbose, tsk);
levels--;
if (UNW_PC(&info) != _stp_kretprobe_trampoline)
continue;
}
/* If an error happened or we hit a kretprobe trampoline,
* use fallback backtrace, unless user task backtrace.
* FIXME: is there a way to unwind across kretprobe
* trampolines? PR9999. */
if ((ret < 0
|| UNW_PC(&info) == _stp_kretprobe_trampoline)
&& ! (tsk || arch_unw_user_mode(&info)))
_stp_stack_print_fallback(UNW_SP(&info), verbose, levels);
return;
}
#else /* ! STP_USE_DWARF_UNWINDER */
_stp_stack_print_fallback(REG_SP(regs), verbose, levels);
#endif
}
int
dwarf_print_stack_entry(struct bt_info *bt, int level)
{
unsigned long offset;
struct syment *sp;
char *name;
struct unwind_frame_info *frame;
frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
UNW_SP(frame) = bt->stkptr;
UNW_PC(frame) = bt->instptr;
sp = value_search(UNW_PC(frame), &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp, "unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame));
goto bailout;
}
/*
* If offset is zero, it means we have crossed over to the next
* function. Recalculate by adjusting the text address
*/
if (!offset) {
sp = value_search(UNW_PC(frame) - 1, &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp,
"unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame)-1);
goto bailout;
}
}
name = sp->name;
fprintf(fp, " #%d [%016lx] %s at %016lx \n", level, UNW_SP(frame), name, UNW_PC(frame));
bailout:
FREEBUF(frame);
return level;
}
void
dwarf_debug(struct bt_info *bt)
{
struct unwind_frame_info *frame;
ulong bp;
int is_ehframe = (!st->dwarf_debug_frame_size && st->dwarf_eh_frame_size);
if (!bt->hp->eip) {
dump_local_unwind_tables();
return;
}
if (!(kt->flags & DWARF_UNWIND_CAPABLE)) {
error(INFO, "not DWARF capable\n");
return;
}
frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
/*
* XXX: This only works for the first PC/SP pair seen in a normal
* backtrace, so it's not particularly helpful. Ideally it should
* be capable to take any PC/SP pair in a stack, but it appears to
* related to the rbp value.
*/
UNW_PC(frame) = bt->hp->eip;
UNW_SP(frame) = bt->hp->esp;
readmem(UNW_SP(frame), KVADDR, &bp,
sizeof(unsigned long), "reading bp", FAULT_ON_ERROR);
frame->regs.rbp = bp; /* fixme for x86 */
unwind(frame, is_ehframe);
fprintf(fp, "frame size: %lx (%lx)\n",
(ulong)UNW_SP(frame), (ulong)UNW_SP(frame) - bt->hp->esp);
FREEBUF(frame);
}
int try_stack_unwind(struct task_struct *task, struct pt_regs *regs,
unsigned long **stack, unsigned long *bp,
const struct stacktrace_ops *ops, void *data)
{
#ifdef CONFIG_STACK_UNWIND
int unw_ret = 0;
struct unwind_frame_info info;
if (call_trace < 0)
return 0;
if (regs) {
if (unwind_init_frame_info(&info, task, regs) == 0)
unw_ret = dump_trace_unwind(&info, ops, data);
} else if (task == current)
unw_ret = unwind_init_running(&info, dump_trace_unwind, ops, data);
#ifdef CONFIG_SMP
else if (task->on_cpu)
/* nothing */;
#endif
else if (unwind_init_blocked(&info, task) == 0)
unw_ret = dump_trace_unwind(&info, ops, data);
if (unw_ret > 0) {
if (call_trace == 1 && !arch_unw_user_mode(&info)) {
ops->warning_symbol(data, "DWARF2 unwinder stuck at %s\n",
UNW_PC(&info));
if (UNW_SP(&info) >= PAGE_OFFSET) {
ops->warning(data, "Leftover inexact backtrace:\n");
*stack = (void *)UNW_SP(&info);
*bp = UNW_FP(&info);
return 0;
}
} else if (call_trace >= 1)
return -1;
ops->warning(data, "Full inexact backtrace again:\n");
} else
ops->warning(data, "Inexact backtrace:\n");
#endif
return 0;
}
static int asmlinkage dump_trace_unwind(struct unwind_frame_info *info,
const struct stacktrace_ops *ops,
void *data)
{
int n = 0;
#ifdef CONFIG_STACK_UNWIND
unsigned long sp = UNW_SP(info);
if (arch_unw_user_mode(info))
return -1;
while (unwind(info) == 0 && UNW_PC(info)) {
n++;
ops->address(data, UNW_PC(info), 1);
if (arch_unw_user_mode(info))
break;
if ((sp & ~(PAGE_SIZE - 1)) == (UNW_SP(info) & ~(PAGE_SIZE - 1))
&& sp > UNW_SP(info))
break;
sp = UNW_SP(info);
}
#endif
return n;
}
static unsigned long _stp_stack_unwind_one_user(struct context *c, unsigned depth)
{
struct pt_regs *regs = NULL;
int uregs_valid = 0;
struct uretprobe_instance *ri = NULL;
struct unwind_frame_info *info = NULL;
int ret;
#ifdef STAPCONF_UPROBE_GET_PC
unsigned long maybe_pc;
#endif
if (c->probe_type == stp_probe_type_uretprobe)
ri = c->ips.ri;
#ifdef STAPCONF_UPROBE_GET_PC
else if (c->probe_type == stp_probe_type_uprobe)
ri = GET_PC_URETPROBE_NONE;
#endif
/* XXX: The computation that gives this is cached, so calling
* _stp_get_uregs multiple times is okay... probably. */
regs = _stp_get_uregs(c);
uregs_valid = c->full_uregs_p;
if (! current->mm || ! regs)
return 0; // no user backtrace at this probe point
if (depth == 0) { /* Start by fetching the current PC. */
dbug_unwind(1, "STARTING user unwind\n");
#ifdef STAPCONF_UPROBE_GET_PC
if (c->probe_type == stp_probe_type_uretprobe && ri) {
return ri->ret_addr;
} else {
return REG_IP(regs);
}
#else
return REG_IP(regs);
#endif
}
#ifdef STP_USE_DWARF_UNWINDER
info = &c->uwcontext_user.info;
dbug_unwind(1, "CONTINUING user unwind to depth %d\n", depth);
if (depth == 1) { /* need to clear uregs & set up uwcontext->info */
if (c->uregs == &c->uwcontext_user.info.regs) {
dbug_unwind(1, "clearing uregs\n");
/* Unwinder needs the reg state, clear uregs ref. */
c->uregs = NULL;
c->full_uregs_p = 0;
}
arch_unw_init_frame_info(info, regs, 0);
}
ret = unwind(&c->uwcontext_user, 1);
#ifdef STAPCONF_UPROBE_GET_PC
maybe_pc = 0;
if (ri) {
maybe_pc = uprobe_get_pc(ri, UNW_PC(info), UNW_SP(info));
if (!maybe_pc)
printk("SYSTEMTAP ERROR: uprobe_get_return returned 0\n");
else
UNW_PC(info) = maybe_pc;
}
#endif
dbug_unwind(1, "ret=%d PC=%llx SP=%llx\n", ret,
(unsigned long long) UNW_PC(info), (unsigned long long) UNW_SP(info));
/* check if unwind hit an error */
if (ret || ! _stp_valid_pc_addr(UNW_PC(info), current)) {
return 0;
}
return UNW_PC(info);
#else
/* User stack traces only supported for arches with dwarf unwinder. */
return 0;
#endif
}
static void _stp_stack_kernel_print(struct context *c, int sym_flags)
{
unsigned n, remaining;
unsigned long l;
/* print the current address */
if (c->probe_type == stp_probe_type_kretprobe && c->ips.krp.pi
&& (sym_flags & _STP_SYM_FULL) == _STP_SYM_FULL) {
_stp_print("Returning from: ");
_stp_print_addr((unsigned long)_stp_probe_addr_r(c->ips.krp.pi),
sym_flags, NULL);
_stp_print("Returning to : ");
}
_stp_print_addr(_stp_stack_kernel_get(c, 0), sym_flags, NULL);
#ifdef STP_USE_DWARF_UNWINDER
for (n = 1; n < MAXBACKTRACE; n++) {
l = _stp_stack_kernel_get(c, n);
if (l == 0) {
remaining = MAXBACKTRACE - n;
_stp_stack_print_fallback(UNW_SP(&c->uwcontext_kernel.info),
sym_flags, remaining, 0);
break;
} else {
_stp_print_addr(l, sym_flags, NULL);
}
}
#else
if (! c->kregs) {
/* This is a fatal block for _stp_stack_kernel_get,
* but when printing a backtrace we can use this
* inexact fallback.
*
* When compiled with frame pointers we can do
* a pretty good guess at the stack value,
* otherwise let dump_stack guess it
* (and skip some framework frames). */
#if defined(STAPCONF_KERNEL_STACKTRACE) || defined(STAPCONF_KERNEL_STACKTRACE_NO_BP)
unsigned long sp;
int skip;
#ifdef CONFIG_FRAME_POINTER
sp = *(unsigned long *) __builtin_frame_address (0);
skip = 1; /* Skip just this frame. */
#else
sp = 0;
skip = 5; /* yes, that many framework frames. */
#endif
_stp_stack_print_fallback(sp, sym_flags,
MAXBACKTRACE, skip);
#else
if (sym_flags & _STP_SYM_SYMBOL)
_stp_printf("<no kernel backtrace at %s>\n",
c->probe_point);
else
_stp_print("\n");
#endif
return;
}
else
/* Arch specific fallback for kernel backtraces. */
__stp_stack_print(c->kregs, sym_flags, MAXBACKTRACE);
#endif
}
static unsigned long _stp_stack_unwind_one_kernel(struct context *c, unsigned depth)
{
struct pt_regs *regs = NULL;
struct unwind_frame_info *info = NULL;
int ret;
if (depth == 0) { /* Start by fetching the current PC. */
dbug_unwind(1, "STARTING kernel unwind\n");
if (! c->kregs) {
/* Even the current PC is unknown; so we have
* absolutely no data at any depth.
*
* Note that unlike _stp_stack_kernel_print(),
* we can't fall back to calling dump_trace()
* to obtain the backtrace -- since that
* returns a string, which we would have to
* tokenize. Callers that want to use the
* dump_trace() fallback should call
* _stp_stack_kernel_print() and do their own
* tokenization of the result. */
#if defined (__i386__) || defined (__x86_64__)
arch_unw_init_frame_info(&c->uwcontext_kernel.info, NULL, 0);
return UNW_PC(&c->uwcontext_kernel.info);
#else
return 0;
#endif
} else if (c->probe_type == stp_probe_type_kretprobe
&& c->ips.krp.pi) {
return (unsigned long)_stp_ret_addr_r(c->ips.krp.pi);
} else {
return REG_IP(c->kregs);
}
}
#ifdef STP_USE_DWARF_UNWINDER
/* Otherwise, use the DWARF unwinder to unwind one step. */
regs = c->kregs;
info = &c->uwcontext_kernel.info;
dbug_unwind(1, "CONTINUING kernel unwind to depth %d\n", depth);
if (depth == 1) {
/* First step of actual DWARF unwind;
need to clear uregs& set up uwcontext->info. */
if (c->uregs == &c->uwcontext_kernel.info.regs) {
dbug_unwind(1, "clearing uregs\n");
/* Unwinder needs the reg state, clear uregs ref. */
c->uregs = NULL;
c->full_uregs_p = 0;
}
arch_unw_init_frame_info(info, regs, 0);
}
ret = unwind(&c->uwcontext_kernel, 0);
dbug_unwind(1, "ret=%d PC=%llx SP=%llx\n", ret,
(unsigned long long) UNW_PC(info),
(unsigned long long) UNW_SP(info));
/* check if unwind hit an error */
if (ret || ! _stp_valid_pc_addr(UNW_PC(info), NULL)) {
return 0;
}
return UNW_PC(info);
#else
return 0;
#endif
}
/** Gets user space registers when available, also sets context
* full_uregs_p if appropriate. Should be used instead of accessing
* context uregs field directly when (full) uregs are needed from
* kernel context.
*/
static struct pt_regs *_stp_get_uregs(struct context *c)
{
/* When the probe occurred in user context uregs are always complete. */
if (c->uregs && c->user_mode_p)
c->full_uregs_p = 1;
else if (c->uregs == NULL)
{
dbug_unwind(1, "computing uregs\n");
/* First try simple recovery through task_pt_regs,
on some platforms that already provides complete uregs. */
c->uregs = _stp_current_pt_regs();
if (c->uregs && _stp_task_pt_regs_valid(current, c->uregs))
c->full_uregs_p = 1;
/* Sadly powerpc does support the dwarf unwinder, but doesn't have enough
CFI in the kernel to recover fully to user space. */
#if defined(STP_USE_DWARF_UNWINDER) && !defined (__powerpc__)
else if (c->uregs != NULL && c->kregs != NULL && !c->user_mode_p)
{
struct unwind_frame_info *info = &c->uwcontext_kernel.info;
int ret = 0;
int levels;
/* We might be lucky and this probe already ran the kernel
unwind to end up in the user regs. */
if (UNW_PC(info) == REG_IP(c->uregs))
{
levels = 0;
dbug_unwind(1, "feeling lucky, info pc == uregs pc\n");
}
else
{
/* Try to recover the uregs by unwinding from the the kernel
probe location. */
levels = MAXBACKTRACE;
arch_unw_init_frame_info(info, c->kregs, 0);
dbug_unwind(1, "Trying to recover... searching for 0x%llx\n",
(unsigned long long) REG_IP(c->uregs));
/* Mark the kernel unwind cache as invalid
(uwcache_kernel.depth is no longer consistent with
the actual current depth of the unwind).
We don't save PCs in the cache at this point because
this kernel unwind procedure does not fetch the top
level PC, so uwcache_kernel.pc[0] would be left
unpopulated. We would have to either fetch the
current PC here, or specially represent this state of
the cache, something we don't bother with at this
stage.
XXX: this can create (tolerable amounts of) inefficiency
if the probe intersperses user and kernel unwind calls,
since the other unwind code can clear uregs, triggering
a redundant unwind the next time we need them. */
dbug_unwind(1, "clearing kernel unwind cache\n");
c->uwcache_kernel.state = uwcache_uninitialized;
}
while (levels > 0 && ret == 0 && UNW_PC(info) != REG_IP(c->uregs))
{
levels--;
ret = unwind(&c->uwcontext_kernel, 0);
dbug_unwind(1, "unwind levels: %d, ret: %d, pc=0x%llx\n",
levels, ret, (unsigned long long) UNW_PC(info));
}
/* Have we arrived where we think user space currently is? */
if (ret == 0 && UNW_PC(info) == REG_IP(c->uregs))
{
/* Note we need to clear this state again when the unwinder
has been rerun. See __stp_stack_print invocation below. */
UNW_SP(info) = REG_SP(c->uregs); /* Fix up user stack */
c->uregs = &info->regs;
c->full_uregs_p = 1;
dbug_unwind(1, "recovered with pc=0x%llx sp=0x%llx\n",
(unsigned long long) UNW_PC(info),
(unsigned long long) UNW_SP(info));
}
else
dbug_unwind(1, "failed to recover user reg state\n");
}
#endif
}
return c->uregs;
}
/* Unwind to previous to frame. Returns 0 if successful, negative
* number in case of an error. */
int
unwind(struct unwind_frame_info *frame, int is_ehframe)
{
#define FRAME_REG(r, t) (((t *)frame)[reg_info[r].offs])
const u32 *fde = NULL, *cie = NULL;
const u8 *ptr = NULL, *end = NULL;
unsigned long startLoc = 0, endLoc = 0, cfa;
unsigned i;
signed ptrType = -1;
uleb128_t retAddrReg = 0;
// struct unwind_table *table;
void *unwind_table;
struct local_unwind_table *table;
struct unwind_state state;
u64 reg_ptr = 0;
if (UNW_PC(frame) == 0)
return -EINVAL;
if ((table = find_table(UNW_PC(frame)))) {
// unsigned long tableSize = unwind_table_size;
unsigned long tableSize = table->size;
unwind_table = table->address;
for (fde = unwind_table;
tableSize > sizeof(*fde) && tableSize - sizeof(*fde) >= *fde;
tableSize -= sizeof(*fde) + *fde,
fde += 1 + *fde / sizeof(*fde)) {
if (!*fde || (*fde & (sizeof(*fde) - 1)))
break;
if (is_ehframe && !fde[1])
continue; /* this is a CIE */
else if (fde[1] == 0xffffffff)
continue; /* this is a CIE */
if ((fde[1] & (sizeof(*fde) - 1))
|| fde[1] > (unsigned long)(fde + 1)
- (unsigned long)unwind_table)
continue; /* this is not a valid FDE */
if (is_ehframe)
cie = fde + 1 - fde[1] / sizeof(*fde);
else
cie = unwind_table + fde[1];
if (*cie <= sizeof(*cie) + 4
|| *cie >= fde[1] - sizeof(*fde)
|| (*cie & (sizeof(*cie) - 1))
|| (cie[1] != 0xffffffff && cie[1])
|| (ptrType = fde_pointer_type(cie)) < 0) {
cie = NULL; /* this is not a (valid) CIE */
continue;
}
ptr = (const u8 *)(fde + 2);
startLoc = read_pointer(&ptr,
(const u8 *)(fde + 1) + *fde,
ptrType);
endLoc = startLoc
+ read_pointer(&ptr,
(const u8 *)(fde + 1) + *fde,
ptrType & DW_EH_PE_indirect
? ptrType
: ptrType & (DW_EH_PE_FORM|DW_EH_PE_signed));
if (UNW_PC(frame) >= startLoc && UNW_PC(frame) < endLoc)
break;
cie = NULL;
}
}
if (cie != NULL) {
memset(&state, 0, sizeof(state));
state.cieEnd = ptr; /* keep here temporarily */
ptr = (const u8 *)(cie + 2);
end = (const u8 *)(cie + 1) + *cie;
if ((state.version = *ptr) != 1)
cie = NULL; /* unsupported version */
else if (*++ptr) {
/* check if augmentation size is first (and thus present) */
if (*ptr == 'z') {
/* check for ignorable (or already handled)
* nul-terminated augmentation string */
while (++ptr < end && *ptr)
if (strchr("LPR", *ptr) == NULL)
break;
}
if (ptr >= end || *ptr)
cie = NULL;
}
++ptr;
}
if (cie != NULL) {
/* get code aligment factor */
state.codeAlign = get_uleb128(&ptr, end);
/* get data aligment factor */
state.dataAlign = get_sleb128(&ptr, end);
if (state.codeAlign == 0 || state.dataAlign == 0 || ptr >= end)
cie = NULL;
else {
retAddrReg = state.version <= 1 ? *ptr++ : get_uleb128(&ptr, end);
/* skip augmentation */
if (((const char *)(cie + 2))[1] == 'z')
ptr += get_uleb128(&ptr, end);
if (ptr > end
|| retAddrReg >= ARRAY_SIZE(reg_info)
|| REG_INVALID(retAddrReg)
|| reg_info[retAddrReg].width != sizeof(unsigned long))
cie = NULL;
}
}
if (cie != NULL) {
state.cieStart = ptr;
ptr = state.cieEnd;
state.cieEnd = end;
end = (const u8 *)(fde + 1) + *fde;
/* skip augmentation */
if (((const char *)(cie + 2))[1] == 'z') {
uleb128_t augSize = get_uleb128(&ptr, end);
if ((ptr += augSize) > end)
fde = NULL;
}
}
if (cie == NULL || fde == NULL)
return -ENXIO;
state.org = startLoc;
memcpy(&state.cfa, &badCFA, sizeof(state.cfa));
/* process instructions */
if (!processCFI(ptr, end, UNW_PC(frame), ptrType, &state)
|| state.loc > endLoc
|| state.regs[retAddrReg].where == Nowhere
|| state.cfa.reg >= ARRAY_SIZE(reg_info)
|| reg_info[state.cfa.reg].width != sizeof(unsigned long)
|| state.cfa.offs % sizeof(unsigned long)) {
return -EIO;
}
/* update frame */
cfa = FRAME_REG(state.cfa.reg, unsigned long) + state.cfa.offs;
startLoc = min((unsigned long)UNW_SP(frame), cfa);
endLoc = max((unsigned long)UNW_SP(frame), cfa);
if (STACK_LIMIT(startLoc) != STACK_LIMIT(endLoc)) {
startLoc = min(STACK_LIMIT(cfa), cfa);
endLoc = max(STACK_LIMIT(cfa), cfa);
}
#ifndef CONFIG_64BIT
# define CASES CASE(8); CASE(16); CASE(32)
#else
# define CASES CASE(8); CASE(16); CASE(32); CASE(64)
#endif
for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
if (REG_INVALID(i)) {
if (state.regs[i].where == Nowhere)
continue;
return -EIO;
}
switch(state.regs[i].where) {
default:
break;
case Register:
if (state.regs[i].value >= ARRAY_SIZE(reg_info)
|| REG_INVALID(state.regs[i].value)
|| reg_info[i].width > reg_info[state.regs[i].value].width){
return -EIO;
}
switch(reg_info[state.regs[i].value].width) {
#define CASE(n) \
case sizeof(u##n): \
state.regs[i].value = FRAME_REG(state.regs[i].value, \
const u##n); \
break
CASES;
#undef CASE
default:
return -EIO;
}
break;
}
}
for (i = 0; i < ARRAY_SIZE(state.regs); ++i) {
if (REG_INVALID(i))
continue;
switch(state.regs[i].where) {
case Nowhere:
if (reg_info[i].width != sizeof(UNW_SP(frame))
|| &FRAME_REG(i, __typeof__(UNW_SP(frame)))
!= &UNW_SP(frame))
continue;
UNW_SP(frame) = cfa;
break;
case Register:
switch(reg_info[i].width) {
#define CASE(n) case sizeof(u##n): \
FRAME_REG(i, u##n) = state.regs[i].value; \
break
CASES;
#undef CASE
default:
return -EIO;
}
break;
case Value:
if (reg_info[i].width != sizeof(unsigned long)){
return -EIO;}
FRAME_REG(i, unsigned long) = cfa + state.regs[i].value
* state.dataAlign;
break;
case Memory: {
unsigned long addr = cfa + state.regs[i].value
* state.dataAlign;
if ((state.regs[i].value * state.dataAlign)
% sizeof(unsigned long)
|| addr < startLoc
|| addr + sizeof(unsigned long) < addr
|| addr + sizeof(unsigned long) > endLoc){
return -EIO;}
switch(reg_info[i].width) {
#define CASE(n) case sizeof(u##n): \
readmem(addr, KVADDR, ®_ptr,sizeof(u##n), "register", RETURN_ON_ERROR|QUIET); \
FRAME_REG(i, u##n) = (u##n)reg_ptr;\
break
CASES;
#undef CASE
default:
return -EIO;
}
}
break;
}
}
return 0;
#undef CASES
#undef FRAME_REG
}
int
dwarf_backtrace(struct bt_info *bt, int level, ulong stacktop)
{
unsigned long bp, offset;
struct syment *sp;
char *name;
struct unwind_frame_info *frame;
int is_ehframe = (!st->dwarf_debug_frame_size && st->dwarf_eh_frame_size);
frame = (struct unwind_frame_info *)GETBUF(sizeof(struct unwind_frame_info));
// frame->regs.rsp = bt->stkptr;
// frame->regs.rip = bt->instptr;
UNW_SP(frame) = bt->stkptr;
UNW_PC(frame) = bt->instptr;
/* read rbp from stack for non active tasks */
if (!(bt->flags & BT_DUMPFILE_SEARCH) && !bt->bptr) {
// readmem(frame->regs.rsp, KVADDR, &bp,
readmem(UNW_SP(frame), KVADDR, &bp,
sizeof(unsigned long), "reading bp", FAULT_ON_ERROR);
frame->regs.rbp = bp; /* fixme for x86 */
}
sp = value_search(UNW_PC(frame), &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp, "unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame));
goto bailout;
}
/*
* If offset is zero, it means we have crossed over to the next
* function. Recalculate by adjusting the text address
*/
if (!offset) {
sp = value_search(UNW_PC(frame) - 1, &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp,
"unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame)-1);
goto bailout;
}
}
name = sp->name;
fprintf(fp, " #%d [%016lx] %s at %016lx \n", level, UNW_SP(frame), name, UNW_PC(frame));
if (CRASHDEBUG(2))
fprintf(fp, " < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame),
UNW_PC(frame), frame->regs.rbp);
while ((UNW_SP(frame) < stacktop)
&& !unwind(frame, is_ehframe) && UNW_PC(frame)) {
/* To prevent rip pushed on IRQ stack being reported both
* both on the IRQ and process stacks
*/
if ((bt->flags & BT_IRQSTACK) && (UNW_SP(frame) >= stacktop - 16))
break;
level++;
sp = value_search(UNW_PC(frame), &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp,
"unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame));
break;
}
/*
* If offset is zero, it means we have crossed over to the next
* function. Recalculate by adjusting the text address
*/
if (!offset) {
sp = value_search(UNW_PC(frame) - 1, &offset);
if (!sp) {
if (CRASHDEBUG(1))
fprintf(fp,
"unwind: cannot find symbol for PC: %lx\n",
UNW_PC(frame)-1);
goto bailout;
}
}
name = sp->name;
fprintf(fp, "%s#%d [%016lx] %s at %016lx \n", level < 10 ? " " : "",
level, UNW_SP(frame), name, UNW_PC(frame));
if (CRASHDEBUG(2))
fprintf(fp, " < SP: %lx PC: %lx FP: %lx >\n", UNW_SP(frame),
UNW_PC(frame), frame->regs.rbp);
}
bailout:
FREEBUF(frame);
return ++level;
}
/** Gets user space registers when available, also sets context probe_flags
* _STP_PROBE_STATE_FULL_UREGS if appropriate. Should be used instead of
* accessing context uregs field directly when (full) uregs are needed
* from kernel context.
*/
static struct pt_regs *_stp_get_uregs(struct context *c)
{
/* When the probe occurred in user context uregs are always complete. */
if (c->uregs && c->probe_flags & _STP_PROBE_STATE_USER_MODE)
c->probe_flags |= _STP_PROBE_STATE_FULL_UREGS;
else if (c->uregs == NULL)
{
/* First try simple recovery through task_pt_regs,
on some platforms that already provides complete uregs. */
c->uregs = _stp_current_pt_regs();
if (c->uregs && _stp_task_pt_regs_valid(current, c->uregs))
c->probe_flags |= _STP_PROBE_STATE_FULL_UREGS;
/* Sadly powerpc does support the dwarf unwinder, but doesn't have enough
CFI in the kernel to recover fully to user space. */
#if defined(STP_USE_DWARF_UNWINDER) && !defined (__powerpc__)
else if (c->uregs != NULL && c->kregs != NULL
&& ! (c->probe_flags & _STP_PROBE_STATE_USER_MODE))
{
struct unwind_frame_info *info = &c->uwcontext.info;
int ret = 0;
int levels;
/* We might be lucky and this probe already ran the kernel
unwind to end up in the user regs. */
if (UNW_PC(info) == REG_IP(c->uregs))
{
levels = 0;
dbug_unwind(1, "feeling lucky, info pc == uregs pc\n");
}
else
{
/* Try to recover the uregs by unwinding from the the kernel
probe location. */
levels = MAXBACKTRACE;
arch_unw_init_frame_info(info, c->kregs, 0);
dbug_unwind(1, "Trying to recover... searching for 0x%lx\n",
REG_IP(c->uregs));
}
while (levels > 0 && ret == 0 && UNW_PC(info) != REG_IP(c->uregs))
{
levels--;
ret = unwind(&c->uwcontext, 0);
dbug_unwind(1, "unwind levels: %d, ret: %d, pc=0x%lx\n",
levels, ret, UNW_PC(info));
}
/* Have we arrived where we think user space currently is? */
if (ret == 0 && UNW_PC(info) == REG_IP(c->uregs))
{
/* Note we need to clear this state again when the unwinder
has been rerun. See __stp_stack_print invocation below. */
UNW_SP(info) = REG_SP(c->uregs); /* Fix up user stack */
c->uregs = &info->regs;
c->probe_flags |= _STP_PROBE_STATE_FULL_UREGS;
dbug_unwind(1, "recovered with pc=0x%lx sp=0x%lx\n",
UNW_PC(info), UNW_SP(info));
}
else
dbug_unwind(1, "failed to recover user reg state\n");
}
#endif
}
return c->uregs;
}