882a2a724e
Debugging shows a large number of unaligned access traps in the unwinder code. Code analysis reveals a number of issues with this code: - handle_interruption is passed twice through dereference_kernel_function_descriptor() - ret_from_kernel_thread, syscall_exit, intr_return, _switch_to_ret, and _call_on_stack are passed through dereference_kernel_function_descriptor() even though they are not declared as function pointers. To fix the problems, drop one of the calls to dereference_kernel_function_descriptor() for handle_interruption, and compare the other pointers directly. Fixes:6414b30b39
("parisc: unwind: Avoid missing prototype warning for handle_interruption()") Fixes:8e0ba125c2
("parisc/unwind: fix unwinder when CONFIG_64BIT is enabled") Cc: Helge Deller <deller@gmx.de> Cc: Sven Schnelle <svens@stackframe.org> Cc: John David Anglin <dave.anglin@bell.net> Cc: Charlie Jenkins <charlie@rivosinc.com> Cc: David Laight <David.Laight@ACULAB.COM> Signed-off-by: Guenter Roeck <linux@roeck-us.net> Signed-off-by: Helge Deller <deller@gmx.de>
490 lines
12 KiB
C
490 lines
12 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Kernel unwinding support
|
|
*
|
|
* (c) 2002-2004 Randolph Chung <tausq@debian.org>
|
|
*
|
|
* Derived partially from the IA64 implementation. The PA-RISC
|
|
* Runtime Architecture Document is also a useful reference to
|
|
* understand what is happening here
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/init.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/sort.h>
|
|
#include <linux/sched/task_stack.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
#include <asm/assembly.h>
|
|
#include <asm/asm-offsets.h>
|
|
#include <asm/ptrace.h>
|
|
|
|
#include <asm/unwind.h>
|
|
#include <asm/switch_to.h>
|
|
#include <asm/sections.h>
|
|
#include <asm/ftrace.h>
|
|
|
|
/* #define DEBUG 1 */
|
|
#ifdef DEBUG
|
|
#define dbg(x...) pr_debug(x)
|
|
#else
|
|
#define dbg(x...) do { } while (0)
|
|
#endif
|
|
|
|
#define KERNEL_START (KERNEL_BINARY_TEXT_START)
|
|
|
|
extern struct unwind_table_entry __start___unwind[];
|
|
extern struct unwind_table_entry __stop___unwind[];
|
|
|
|
static DEFINE_SPINLOCK(unwind_lock);
|
|
/*
|
|
* the kernel unwind block is not dynamically allocated so that
|
|
* we can call unwind_init as early in the bootup process as
|
|
* possible (before the slab allocator is initialized)
|
|
*/
|
|
static struct unwind_table kernel_unwind_table __ro_after_init;
|
|
static LIST_HEAD(unwind_tables);
|
|
|
|
static inline const struct unwind_table_entry *
|
|
find_unwind_entry_in_table(const struct unwind_table *table, unsigned long addr)
|
|
{
|
|
const struct unwind_table_entry *e = NULL;
|
|
unsigned long lo, hi, mid;
|
|
|
|
lo = 0;
|
|
hi = table->length - 1;
|
|
|
|
while (lo <= hi) {
|
|
mid = (hi - lo) / 2 + lo;
|
|
e = &table->table[mid];
|
|
if (addr < e->region_start)
|
|
hi = mid - 1;
|
|
else if (addr > e->region_end)
|
|
lo = mid + 1;
|
|
else
|
|
return e;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static const struct unwind_table_entry *
|
|
find_unwind_entry(unsigned long addr)
|
|
{
|
|
struct unwind_table *table;
|
|
const struct unwind_table_entry *e = NULL;
|
|
|
|
if (addr >= kernel_unwind_table.start &&
|
|
addr <= kernel_unwind_table.end)
|
|
e = find_unwind_entry_in_table(&kernel_unwind_table, addr);
|
|
else {
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&unwind_lock, flags);
|
|
list_for_each_entry(table, &unwind_tables, list) {
|
|
if (addr >= table->start &&
|
|
addr <= table->end)
|
|
e = find_unwind_entry_in_table(table, addr);
|
|
if (e) {
|
|
/* Move-to-front to exploit common traces */
|
|
list_move(&table->list, &unwind_tables);
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(&unwind_lock, flags);
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
static void
|
|
unwind_table_init(struct unwind_table *table, const char *name,
|
|
unsigned long base_addr, unsigned long gp,
|
|
void *table_start, void *table_end)
|
|
{
|
|
struct unwind_table_entry *start = table_start;
|
|
struct unwind_table_entry *end =
|
|
(struct unwind_table_entry *)table_end - 1;
|
|
|
|
table->name = name;
|
|
table->base_addr = base_addr;
|
|
table->gp = gp;
|
|
table->start = base_addr + start->region_start;
|
|
table->end = base_addr + end->region_end;
|
|
table->table = (struct unwind_table_entry *)table_start;
|
|
table->length = end - start + 1;
|
|
INIT_LIST_HEAD(&table->list);
|
|
|
|
for (; start <= end; start++) {
|
|
if (start < end &&
|
|
start->region_end > (start+1)->region_start) {
|
|
pr_warn("Out of order unwind entry! %px and %px\n",
|
|
start, start+1);
|
|
}
|
|
|
|
start->region_start += base_addr;
|
|
start->region_end += base_addr;
|
|
}
|
|
}
|
|
|
|
static int cmp_unwind_table_entry(const void *a, const void *b)
|
|
{
|
|
return ((const struct unwind_table_entry *)a)->region_start
|
|
- ((const struct unwind_table_entry *)b)->region_start;
|
|
}
|
|
|
|
static void
|
|
unwind_table_sort(struct unwind_table_entry *start,
|
|
struct unwind_table_entry *finish)
|
|
{
|
|
sort(start, finish - start, sizeof(struct unwind_table_entry),
|
|
cmp_unwind_table_entry, NULL);
|
|
}
|
|
|
|
struct unwind_table *
|
|
unwind_table_add(const char *name, unsigned long base_addr,
|
|
unsigned long gp,
|
|
void *start, void *end)
|
|
{
|
|
struct unwind_table *table;
|
|
unsigned long flags;
|
|
struct unwind_table_entry *s = (struct unwind_table_entry *)start;
|
|
struct unwind_table_entry *e = (struct unwind_table_entry *)end;
|
|
|
|
unwind_table_sort(s, e);
|
|
|
|
table = kmalloc(sizeof(struct unwind_table), GFP_USER);
|
|
if (table == NULL)
|
|
return NULL;
|
|
unwind_table_init(table, name, base_addr, gp, start, end);
|
|
spin_lock_irqsave(&unwind_lock, flags);
|
|
list_add_tail(&table->list, &unwind_tables);
|
|
spin_unlock_irqrestore(&unwind_lock, flags);
|
|
|
|
return table;
|
|
}
|
|
|
|
void unwind_table_remove(struct unwind_table *table)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&unwind_lock, flags);
|
|
list_del(&table->list);
|
|
spin_unlock_irqrestore(&unwind_lock, flags);
|
|
|
|
kfree(table);
|
|
}
|
|
|
|
/* Called from setup_arch to import the kernel unwind info */
|
|
int __init unwind_init(void)
|
|
{
|
|
long start __maybe_unused, stop __maybe_unused;
|
|
register unsigned long gp __asm__ ("r27");
|
|
|
|
start = (long)&__start___unwind[0];
|
|
stop = (long)&__stop___unwind[0];
|
|
|
|
dbg("unwind_init: start = 0x%lx, end = 0x%lx, entries = %lu\n",
|
|
start, stop,
|
|
(stop - start) / sizeof(struct unwind_table_entry));
|
|
|
|
unwind_table_init(&kernel_unwind_table, "kernel", KERNEL_START,
|
|
gp,
|
|
&__start___unwind[0], &__stop___unwind[0]);
|
|
#if 0
|
|
{
|
|
int i;
|
|
for (i = 0; i < 10; i++)
|
|
{
|
|
printk("region 0x%x-0x%x\n",
|
|
__start___unwind[i].region_start,
|
|
__start___unwind[i].region_end);
|
|
}
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static bool pc_is_kernel_fn(unsigned long pc, void *fn)
|
|
{
|
|
return (unsigned long)dereference_kernel_function_descriptor(fn) == pc;
|
|
}
|
|
|
|
static int unwind_special(struct unwind_frame_info *info, unsigned long pc, int frame_size)
|
|
{
|
|
/*
|
|
* We have to use void * instead of a function pointer, because
|
|
* function pointers aren't a pointer to the function on 64-bit.
|
|
* Make them const so the compiler knows they live in .text
|
|
* Note: We could use dereference_kernel_function_descriptor()
|
|
* instead but we want to keep it simple here.
|
|
*/
|
|
extern void * const ret_from_kernel_thread;
|
|
extern void * const syscall_exit;
|
|
extern void * const intr_return;
|
|
extern void * const _switch_to_ret;
|
|
#ifdef CONFIG_IRQSTACKS
|
|
extern void * const _call_on_stack;
|
|
#endif /* CONFIG_IRQSTACKS */
|
|
|
|
if (pc_is_kernel_fn(pc, handle_interruption)) {
|
|
struct pt_regs *regs = (struct pt_regs *)(info->sp - frame_size - PT_SZ_ALGN);
|
|
dbg("Unwinding through handle_interruption()\n");
|
|
info->prev_sp = regs->gr[30];
|
|
info->prev_ip = regs->iaoq[0];
|
|
return 1;
|
|
}
|
|
|
|
if (pc == (unsigned long)&ret_from_kernel_thread ||
|
|
pc == (unsigned long)&syscall_exit) {
|
|
info->prev_sp = info->prev_ip = 0;
|
|
return 1;
|
|
}
|
|
|
|
if (pc == (unsigned long)&intr_return) {
|
|
struct pt_regs *regs;
|
|
|
|
dbg("Found intr_return()\n");
|
|
regs = (struct pt_regs *)(info->sp - PT_SZ_ALGN);
|
|
info->prev_sp = regs->gr[30];
|
|
info->prev_ip = regs->iaoq[0];
|
|
info->rp = regs->gr[2];
|
|
return 1;
|
|
}
|
|
|
|
if (pc_is_kernel_fn(pc, _switch_to) ||
|
|
pc == (unsigned long)&_switch_to_ret) {
|
|
info->prev_sp = info->sp - CALLEE_SAVE_FRAME_SIZE;
|
|
info->prev_ip = *(unsigned long *)(info->prev_sp - RP_OFFSET);
|
|
return 1;
|
|
}
|
|
|
|
#ifdef CONFIG_IRQSTACKS
|
|
if (pc == (unsigned long)&_call_on_stack) {
|
|
info->prev_sp = *(unsigned long *)(info->sp - FRAME_SIZE - REG_SZ);
|
|
info->prev_ip = *(unsigned long *)(info->sp - FRAME_SIZE - RP_OFFSET);
|
|
return 1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static void unwind_frame_regs(struct unwind_frame_info *info)
|
|
{
|
|
const struct unwind_table_entry *e;
|
|
unsigned long npc;
|
|
unsigned int insn;
|
|
long frame_size = 0;
|
|
int looking_for_rp, rpoffset = 0;
|
|
|
|
e = find_unwind_entry(info->ip);
|
|
if (e == NULL) {
|
|
unsigned long sp;
|
|
|
|
dbg("Cannot find unwind entry for %pS; forced unwinding\n",
|
|
(void *) info->ip);
|
|
|
|
/* Since we are doing the unwinding blind, we don't know if
|
|
we are adjusting the stack correctly or extracting the rp
|
|
correctly. The rp is checked to see if it belongs to the
|
|
kernel text section, if not we assume we don't have a
|
|
correct stack frame and we continue to unwind the stack.
|
|
This is not quite correct, and will fail for loadable
|
|
modules. */
|
|
sp = info->sp & ~63;
|
|
do {
|
|
unsigned long tmp;
|
|
|
|
info->prev_sp = sp - 64;
|
|
info->prev_ip = 0;
|
|
|
|
/* Check if stack is inside kernel stack area */
|
|
if ((info->prev_sp - (unsigned long) task_stack_page(info->t))
|
|
>= THREAD_SIZE) {
|
|
info->prev_sp = 0;
|
|
break;
|
|
}
|
|
|
|
if (copy_from_kernel_nofault(&tmp,
|
|
(void *)info->prev_sp - RP_OFFSET, sizeof(tmp)))
|
|
break;
|
|
info->prev_ip = tmp;
|
|
sp = info->prev_sp;
|
|
} while (!kernel_text_address(info->prev_ip));
|
|
|
|
info->rp = 0;
|
|
|
|
dbg("analyzing func @ %lx with no unwind info, setting "
|
|
"prev_sp=%lx prev_ip=%lx\n", info->ip,
|
|
info->prev_sp, info->prev_ip);
|
|
} else {
|
|
dbg("e->start = 0x%x, e->end = 0x%x, Save_SP = %d, "
|
|
"Save_RP = %d, Millicode = %d size = %u\n",
|
|
e->region_start, e->region_end, e->Save_SP, e->Save_RP,
|
|
e->Millicode, e->Total_frame_size);
|
|
|
|
looking_for_rp = e->Save_RP;
|
|
|
|
for (npc = e->region_start;
|
|
(frame_size < (e->Total_frame_size << 3) ||
|
|
looking_for_rp) &&
|
|
npc < info->ip;
|
|
npc += 4) {
|
|
|
|
insn = *(unsigned int *)npc;
|
|
|
|
if ((insn & 0xffffc001) == 0x37de0000 ||
|
|
(insn & 0xffe00001) == 0x6fc00000) {
|
|
/* ldo X(sp), sp, or stwm X,D(sp) */
|
|
frame_size += (insn & 0x3fff) >> 1;
|
|
dbg("analyzing func @ %lx, insn=%08x @ "
|
|
"%lx, frame_size = %ld\n", info->ip,
|
|
insn, npc, frame_size);
|
|
} else if ((insn & 0xffe00009) == 0x73c00008) {
|
|
/* std,ma X,D(sp) */
|
|
frame_size += ((insn >> 4) & 0x3ff) << 3;
|
|
dbg("analyzing func @ %lx, insn=%08x @ "
|
|
"%lx, frame_size = %ld\n", info->ip,
|
|
insn, npc, frame_size);
|
|
} else if (insn == 0x6bc23fd9) {
|
|
/* stw rp,-20(sp) */
|
|
rpoffset = 20;
|
|
looking_for_rp = 0;
|
|
dbg("analyzing func @ %lx, insn=stw rp,"
|
|
"-20(sp) @ %lx\n", info->ip, npc);
|
|
} else if (insn == 0x0fc212c1) {
|
|
/* std rp,-16(sr0,sp) */
|
|
rpoffset = 16;
|
|
looking_for_rp = 0;
|
|
dbg("analyzing func @ %lx, insn=std rp,"
|
|
"-16(sp) @ %lx\n", info->ip, npc);
|
|
}
|
|
}
|
|
|
|
if (frame_size > e->Total_frame_size << 3)
|
|
frame_size = e->Total_frame_size << 3;
|
|
|
|
if (!unwind_special(info, e->region_start, frame_size)) {
|
|
info->prev_sp = info->sp - frame_size;
|
|
if (e->Millicode)
|
|
info->rp = info->r31;
|
|
else if (rpoffset)
|
|
info->rp = *(unsigned long *)(info->prev_sp - rpoffset);
|
|
info->prev_ip = info->rp;
|
|
info->rp = 0;
|
|
}
|
|
|
|
dbg("analyzing func @ %lx, setting prev_sp=%lx "
|
|
"prev_ip=%lx npc=%lx\n", info->ip, info->prev_sp,
|
|
info->prev_ip, npc);
|
|
}
|
|
}
|
|
|
|
void unwind_frame_init(struct unwind_frame_info *info, struct task_struct *t,
|
|
struct pt_regs *regs)
|
|
{
|
|
memset(info, 0, sizeof(struct unwind_frame_info));
|
|
info->t = t;
|
|
info->sp = regs->gr[30];
|
|
info->ip = regs->iaoq[0];
|
|
info->rp = regs->gr[2];
|
|
info->r31 = regs->gr[31];
|
|
|
|
dbg("(%d) Start unwind from sp=%08lx ip=%08lx\n",
|
|
t ? (int)t->pid : -1, info->sp, info->ip);
|
|
}
|
|
|
|
void unwind_frame_init_from_blocked_task(struct unwind_frame_info *info, struct task_struct *t)
|
|
{
|
|
struct pt_regs *r = &t->thread.regs;
|
|
struct pt_regs *r2;
|
|
|
|
r2 = kmalloc(sizeof(struct pt_regs), GFP_ATOMIC);
|
|
if (!r2)
|
|
return;
|
|
*r2 = *r;
|
|
r2->gr[30] = r->ksp;
|
|
r2->iaoq[0] = r->kpc;
|
|
unwind_frame_init(info, t, r2);
|
|
kfree(r2);
|
|
}
|
|
|
|
#define get_parisc_stackpointer() ({ \
|
|
unsigned long sp; \
|
|
__asm__("copy %%r30, %0" : "=r"(sp)); \
|
|
(sp); \
|
|
})
|
|
|
|
void unwind_frame_init_task(struct unwind_frame_info *info,
|
|
struct task_struct *task, struct pt_regs *regs)
|
|
{
|
|
task = task ? task : current;
|
|
|
|
if (task == current) {
|
|
struct pt_regs r;
|
|
|
|
if (!regs) {
|
|
memset(&r, 0, sizeof(r));
|
|
r.iaoq[0] = _THIS_IP_;
|
|
r.gr[2] = _RET_IP_;
|
|
r.gr[30] = get_parisc_stackpointer();
|
|
regs = &r;
|
|
}
|
|
unwind_frame_init(info, task, regs);
|
|
} else {
|
|
unwind_frame_init_from_blocked_task(info, task);
|
|
}
|
|
}
|
|
|
|
int unwind_once(struct unwind_frame_info *next_frame)
|
|
{
|
|
unwind_frame_regs(next_frame);
|
|
|
|
if (next_frame->prev_sp == 0 ||
|
|
next_frame->prev_ip == 0)
|
|
return -1;
|
|
|
|
next_frame->sp = next_frame->prev_sp;
|
|
next_frame->ip = next_frame->prev_ip;
|
|
next_frame->prev_sp = 0;
|
|
next_frame->prev_ip = 0;
|
|
|
|
dbg("(%d) Continue unwind to sp=%08lx ip=%08lx\n",
|
|
next_frame->t ? (int)next_frame->t->pid : -1,
|
|
next_frame->sp, next_frame->ip);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int unwind_to_user(struct unwind_frame_info *info)
|
|
{
|
|
int ret;
|
|
|
|
do {
|
|
ret = unwind_once(info);
|
|
} while (!ret && !(info->ip & 3));
|
|
|
|
return ret;
|
|
}
|
|
|
|
unsigned long return_address(unsigned int level)
|
|
{
|
|
struct unwind_frame_info info;
|
|
|
|
/* initialize unwind info */
|
|
unwind_frame_init_task(&info, current, NULL);
|
|
|
|
/* unwind stack */
|
|
level += 2;
|
|
do {
|
|
if (unwind_once(&info) < 0 || info.ip == 0)
|
|
return 0;
|
|
if (!kernel_text_address(info.ip))
|
|
return 0;
|
|
} while (info.ip && level--);
|
|
|
|
return info.ip;
|
|
}
|