forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
165 lines
4.2 KiB
165 lines
4.2 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* Copyright (C) 2009 Matt Fleming |
|
* |
|
* Based, in part, on kernel/time/clocksource.c. |
|
* |
|
* This file provides arbitration code for stack unwinders. |
|
* |
|
* Multiple stack unwinders can be available on a system, usually with |
|
* the most accurate unwinder being the currently active one. |
|
*/ |
|
#include <linux/errno.h> |
|
#include <linux/list.h> |
|
#include <linux/spinlock.h> |
|
#include <linux/module.h> |
|
#include <asm/unwinder.h> |
|
#include <linux/atomic.h> |
|
|
|
/* |
|
* This is the most basic stack unwinder an architecture can |
|
* provide. For architectures without reliable frame pointers, e.g. |
|
* RISC CPUs, it can be implemented by looking through the stack for |
|
* addresses that lie within the kernel text section. |
|
* |
|
* Other CPUs, e.g. x86, can use their frame pointer register to |
|
* construct more accurate stack traces. |
|
*/ |
|
static struct list_head unwinder_list; |
|
static struct unwinder stack_reader = { |
|
.name = "stack-reader", |
|
.dump = stack_reader_dump, |
|
.rating = 50, |
|
.list = { |
|
.next = &unwinder_list, |
|
.prev = &unwinder_list, |
|
}, |
|
}; |
|
|
|
/* |
|
* "curr_unwinder" points to the stack unwinder currently in use. This |
|
* is the unwinder with the highest rating. |
|
* |
|
* "unwinder_list" is a linked-list of all available unwinders, sorted |
|
* by rating. |
|
* |
|
* All modifications of "curr_unwinder" and "unwinder_list" must be |
|
* performed whilst holding "unwinder_lock". |
|
*/ |
|
static struct unwinder *curr_unwinder = &stack_reader; |
|
|
|
static struct list_head unwinder_list = { |
|
.next = &stack_reader.list, |
|
.prev = &stack_reader.list, |
|
}; |
|
|
|
static DEFINE_SPINLOCK(unwinder_lock); |
|
|
|
/** |
|
* select_unwinder - Select the best registered stack unwinder. |
|
* |
|
* Private function. Must hold unwinder_lock when called. |
|
* |
|
* Select the stack unwinder with the best rating. This is useful for |
|
* setting up curr_unwinder. |
|
*/ |
|
static struct unwinder *select_unwinder(void) |
|
{ |
|
struct unwinder *best; |
|
|
|
if (list_empty(&unwinder_list)) |
|
return NULL; |
|
|
|
best = list_entry(unwinder_list.next, struct unwinder, list); |
|
if (best == curr_unwinder) |
|
return NULL; |
|
|
|
return best; |
|
} |
|
|
|
/* |
|
* Enqueue the stack unwinder sorted by rating. |
|
*/ |
|
static int unwinder_enqueue(struct unwinder *ops) |
|
{ |
|
struct list_head *tmp, *entry = &unwinder_list; |
|
|
|
list_for_each(tmp, &unwinder_list) { |
|
struct unwinder *o; |
|
|
|
o = list_entry(tmp, struct unwinder, list); |
|
if (o == ops) |
|
return -EBUSY; |
|
/* Keep track of the place, where to insert */ |
|
if (o->rating >= ops->rating) |
|
entry = tmp; |
|
} |
|
list_add(&ops->list, entry); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* unwinder_register - Used to install new stack unwinder |
|
* @u: unwinder to be registered |
|
* |
|
* Install the new stack unwinder on the unwinder list, which is sorted |
|
* by rating. |
|
* |
|
* Returns -EBUSY if registration fails, zero otherwise. |
|
*/ |
|
int unwinder_register(struct unwinder *u) |
|
{ |
|
unsigned long flags; |
|
int ret; |
|
|
|
spin_lock_irqsave(&unwinder_lock, flags); |
|
ret = unwinder_enqueue(u); |
|
if (!ret) |
|
curr_unwinder = select_unwinder(); |
|
spin_unlock_irqrestore(&unwinder_lock, flags); |
|
|
|
return ret; |
|
} |
|
|
|
int unwinder_faulted = 0; |
|
|
|
/* |
|
* Unwind the call stack and pass information to the stacktrace_ops |
|
* functions. Also handle the case where we need to switch to a new |
|
* stack dumper because the current one faulted unexpectedly. |
|
*/ |
|
void unwind_stack(struct task_struct *task, struct pt_regs *regs, |
|
unsigned long *sp, const struct stacktrace_ops *ops, |
|
void *data) |
|
{ |
|
unsigned long flags; |
|
|
|
/* |
|
* The problem with unwinders with high ratings is that they are |
|
* inherently more complicated than the simple ones with lower |
|
* ratings. We are therefore more likely to fault in the |
|
* complicated ones, e.g. hitting BUG()s. If we fault in the |
|
* code for the current stack unwinder we try to downgrade to |
|
* one with a lower rating. |
|
* |
|
* Hopefully this will give us a semi-reliable stacktrace so we |
|
* can diagnose why curr_unwinder->dump() faulted. |
|
*/ |
|
if (unwinder_faulted) { |
|
spin_lock_irqsave(&unwinder_lock, flags); |
|
|
|
/* Make sure no one beat us to changing the unwinder */ |
|
if (unwinder_faulted && !list_is_singular(&unwinder_list)) { |
|
list_del(&curr_unwinder->list); |
|
curr_unwinder = select_unwinder(); |
|
|
|
unwinder_faulted = 0; |
|
} |
|
|
|
spin_unlock_irqrestore(&unwinder_lock, flags); |
|
} |
|
|
|
curr_unwinder->dump(task, regs, sp, ops, data); |
|
} |
|
EXPORT_SYMBOL_GPL(unwind_stack);
|
|
|