cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

unwinder.c (4331B)

      1// SPDX-License-Identifier: GPL-2.0
      2/*
      3 * Copyright (C) 2009  Matt Fleming
      4 *
      5 * Based, in part, on kernel/time/clocksource.c.
      6 *
      7 * This file provides arbitration code for stack unwinders.
      8 *
      9 * Multiple stack unwinders can be available on a system, usually with
     10 * the most accurate unwinder being the currently active one.
     11 */
     12#include <linux/errno.h>
     13#include <linux/list.h>
     14#include <linux/spinlock.h>
     15#include <linux/module.h>
     16#include <asm/unwinder.h>
     17#include <linux/atomic.h>
     18
     19/*
     20 * This is the most basic stack unwinder an architecture can
     21 * provide. For architectures without reliable frame pointers, e.g.
     22 * RISC CPUs, it can be implemented by looking through the stack for
     23 * addresses that lie within the kernel text section.
     24 *
     25 * Other CPUs, e.g. x86, can use their frame pointer register to
     26 * construct more accurate stack traces.
     27 */
     28static struct list_head unwinder_list;
     29static struct unwinder stack_reader = {
     30	.name = "stack-reader",
     31	.dump = stack_reader_dump,
     32	.rating = 50,
     33	.list = {
     34		.next = &unwinder_list,
     35		.prev = &unwinder_list,
     36	},
     37};
     38
     39/*
     40 * "curr_unwinder" points to the stack unwinder currently in use. This
     41 * is the unwinder with the highest rating.
     42 *
     43 * "unwinder_list" is a linked-list of all available unwinders, sorted
     44 * by rating.
     45 *
     46 * All modifications of "curr_unwinder" and "unwinder_list" must be
     47 * performed whilst holding "unwinder_lock".
     48 */
     49static struct unwinder *curr_unwinder = &stack_reader;
     50
     51static struct list_head unwinder_list = {
     52	.next = &stack_reader.list,
     53	.prev = &stack_reader.list,
     54};
     55
     56static DEFINE_SPINLOCK(unwinder_lock);
     57
     58/**
     59 * select_unwinder - Select the best registered stack unwinder.
     60 *
     61 * Private function. Must hold unwinder_lock when called.
     62 *
     63 * Select the stack unwinder with the best rating. This is useful for
     64 * setting up curr_unwinder.
     65 */
     66static struct unwinder *select_unwinder(void)
     67{
     68	struct unwinder *best;
     69
     70	if (list_empty(&unwinder_list))
     71		return NULL;
     72
     73	best = list_entry(unwinder_list.next, struct unwinder, list);
     74	if (best == curr_unwinder)
     75		return NULL;
     76
     77	return best;
     78}
     79
     80/*
     81 * Enqueue the stack unwinder sorted by rating.
     82 */
     83static int unwinder_enqueue(struct unwinder *ops)
     84{
     85	struct list_head *tmp, *entry = &unwinder_list;
     86
     87	list_for_each(tmp, &unwinder_list) {
     88		struct unwinder *o;
     89
     90		o = list_entry(tmp, struct unwinder, list);
     91		if (o == ops)
     92			return -EBUSY;
     93		/* Keep track of the place, where to insert */
     94		if (o->rating >= ops->rating)
     95			entry = tmp;
     96	}
     97	list_add(&ops->list, entry);
     98
     99	return 0;
    100}
    101
    102/**
    103 * unwinder_register - Used to install new stack unwinder
    104 * @u: unwinder to be registered
    105 *
    106 * Install the new stack unwinder on the unwinder list, which is sorted
    107 * by rating.
    108 *
    109 * Returns -EBUSY if registration fails, zero otherwise.
    110 */
    111int unwinder_register(struct unwinder *u)
    112{
    113	unsigned long flags;
    114	int ret;
    115
    116	spin_lock_irqsave(&unwinder_lock, flags);
    117	ret = unwinder_enqueue(u);
    118	if (!ret)
    119		curr_unwinder = select_unwinder();
    120	spin_unlock_irqrestore(&unwinder_lock, flags);
    121
    122	return ret;
    123}
    124
    125int unwinder_faulted = 0;
    126
    127/*
    128 * Unwind the call stack and pass information to the stacktrace_ops
    129 * functions. Also handle the case where we need to switch to a new
    130 * stack dumper because the current one faulted unexpectedly.
    131 */
    132void unwind_stack(struct task_struct *task, struct pt_regs *regs,
    133		  unsigned long *sp, const struct stacktrace_ops *ops,
    134		  void *data)
    135{
    136	unsigned long flags;
    137
    138	/*
    139	 * The problem with unwinders with high ratings is that they are
    140	 * inherently more complicated than the simple ones with lower
    141	 * ratings. We are therefore more likely to fault in the
    142	 * complicated ones, e.g. hitting BUG()s. If we fault in the
    143	 * code for the current stack unwinder we try to downgrade to
    144	 * one with a lower rating.
    145	 *
    146	 * Hopefully this will give us a semi-reliable stacktrace so we
    147	 * can diagnose why curr_unwinder->dump() faulted.
    148	 */
    149	if (unwinder_faulted) {
    150		spin_lock_irqsave(&unwinder_lock, flags);
    151
    152		/* Make sure no one beat us to changing the unwinder */
    153		if (unwinder_faulted && !list_is_singular(&unwinder_list)) {
    154			list_del(&curr_unwinder->list);
    155			curr_unwinder = select_unwinder();
    156
    157			unwinder_faulted = 0;
    158		}
    159
    160		spin_unlock_irqrestore(&unwinder_lock, flags);
    161	}
    162
    163	curr_unwinder->dump(task, regs, sp, ops, data);
    164}
    165EXPORT_SYMBOL_GPL(unwind_stack);