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   */
28  static struct list_head unwinder_list;
29  static 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   */
49  static struct unwinder *curr_unwinder = &stack_reader;
50  
51  static struct list_head unwinder_list = {
52  	.next = &stack_reader.list,
53  	.prev = &stack_reader.list,
54  };
55  
56  static 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   */
select_unwinder(void)66  static 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   */
unwinder_enqueue(struct unwinder * ops)83  static 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   */
unwinder_register(struct unwinder * u)111  int 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  
125  int 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   */
unwind_stack(struct task_struct * task,struct pt_regs * regs,unsigned long * sp,const struct stacktrace_ops * ops,void * data)132  void 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  }
165  EXPORT_SYMBOL_GPL(unwind_stack);
166