LXR linux/arch/sh/kernel/unwinder.c

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