xref: /openbmc/linux/kernel/extable.c (revision aa1d19f1)
1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /* Rewritten by Rusty Russell, on the backs of many others...
3     Copyright (C) 2001 Rusty Russell, 2002 Rusty Russell IBM.
4  
5  */
6  #include <linux/ftrace.h>
7  #include <linux/memory.h>
8  #include <linux/extable.h>
9  #include <linux/module.h>
10  #include <linux/mutex.h>
11  #include <linux/init.h>
12  #include <linux/kprobes.h>
13  #include <linux/filter.h>
14  
15  #include <asm/sections.h>
16  #include <linux/uaccess.h>
17  
18  /*
19   * mutex protecting text section modification (dynamic code patching).
20   * some users need to sleep (allocating memory...) while they hold this lock.
21   *
22   * Note: Also protects SMP-alternatives modification on x86.
23   *
24   * NOT exported to modules - patching kernel text is a really delicate matter.
25   */
26  DEFINE_MUTEX(text_mutex);
27  
28  extern struct exception_table_entry __start___ex_table[];
29  extern struct exception_table_entry __stop___ex_table[];
30  
31  /* Cleared by build time tools if the table is already sorted. */
32  u32 __initdata __visible main_extable_sort_needed = 1;
33  
34  /* Sort the kernel's built-in exception table */
35  void __init sort_main_extable(void)
36  {
37  	if (main_extable_sort_needed && __stop___ex_table > __start___ex_table) {
38  		pr_notice("Sorting __ex_table...\n");
39  		sort_extable(__start___ex_table, __stop___ex_table);
40  	}
41  }
42  
43  /* Given an address, look for it in the exception tables. */
44  const struct exception_table_entry *search_exception_tables(unsigned long addr)
45  {
46  	const struct exception_table_entry *e;
47  
48  	e = search_extable(__start___ex_table,
49  			   __stop___ex_table - __start___ex_table, addr);
50  	if (!e)
51  		e = search_module_extables(addr);
52  	return e;
53  }
54  
55  int init_kernel_text(unsigned long addr)
56  {
57  	if (addr >= (unsigned long)_sinittext &&
58  	    addr < (unsigned long)_einittext)
59  		return 1;
60  	return 0;
61  }
62  
63  int notrace core_kernel_text(unsigned long addr)
64  {
65  	if (addr >= (unsigned long)_stext &&
66  	    addr < (unsigned long)_etext)
67  		return 1;
68  
69  	if (system_state < SYSTEM_RUNNING &&
70  	    init_kernel_text(addr))
71  		return 1;
72  	return 0;
73  }
74  
75  /**
76   * core_kernel_data - tell if addr points to kernel data
77   * @addr: address to test
78   *
79   * Returns true if @addr passed in is from the core kernel data
80   * section.
81   *
82   * Note: On some archs it may return true for core RODATA, and false
83   *  for others. But will always be true for core RW data.
84   */
85  int core_kernel_data(unsigned long addr)
86  {
87  	if (addr >= (unsigned long)_sdata &&
88  	    addr < (unsigned long)_edata)
89  		return 1;
90  	return 0;
91  }
92  
93  int __kernel_text_address(unsigned long addr)
94  {
95  	if (kernel_text_address(addr))
96  		return 1;
97  	/*
98  	 * There might be init symbols in saved stacktraces.
99  	 * Give those symbols a chance to be printed in
100  	 * backtraces (such as lockdep traces).
101  	 *
102  	 * Since we are after the module-symbols check, there's
103  	 * no danger of address overlap:
104  	 */
105  	if (init_kernel_text(addr))
106  		return 1;
107  	return 0;
108  }
109  
110  int kernel_text_address(unsigned long addr)
111  {
112  	bool no_rcu;
113  	int ret = 1;
114  
115  	if (core_kernel_text(addr))
116  		return 1;
117  
118  	/*
119  	 * If a stack dump happens while RCU is not watching, then
120  	 * RCU needs to be notified that it requires to start
121  	 * watching again. This can happen either by tracing that
122  	 * triggers a stack trace, or a WARN() that happens during
123  	 * coming back from idle, or cpu on or offlining.
124  	 *
125  	 * is_module_text_address() as well as the kprobe slots
126  	 * and is_bpf_text_address() require RCU to be watching.
127  	 */
128  	no_rcu = !rcu_is_watching();
129  
130  	/* Treat this like an NMI as it can happen anywhere */
131  	if (no_rcu)
132  		rcu_nmi_enter();
133  
134  	if (is_module_text_address(addr))
135  		goto out;
136  	if (is_ftrace_trampoline(addr))
137  		goto out;
138  	if (is_kprobe_optinsn_slot(addr) || is_kprobe_insn_slot(addr))
139  		goto out;
140  	if (is_bpf_text_address(addr))
141  		goto out;
142  	ret = 0;
143  out:
144  	if (no_rcu)
145  		rcu_nmi_exit();
146  
147  	return ret;
148  }
149  
150  /*
151   * On some architectures (PPC64, IA64) function pointers
152   * are actually only tokens to some data that then holds the
153   * real function address. As a result, to find if a function
154   * pointer is part of the kernel text, we need to do some
155   * special dereferencing first.
156   */
157  int func_ptr_is_kernel_text(void *ptr)
158  {
159  	unsigned long addr;
160  	addr = (unsigned long) dereference_function_descriptor(ptr);
161  	if (core_kernel_text(addr))
162  		return 1;
163  	return is_module_text_address(addr);
164  }
165