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

   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);
 166