1 // SPDX-License-Identifier: GPL-2.0
2 // error-inject.c: Function-level error injection table
3 #include <linux/error-injection.h>
4 #include <linux/debugfs.h>
5 #include <linux/kallsyms.h>
6 #include <linux/kprobes.h>
7 #include <linux/module.h>
8 #include <linux/mutex.h>
9 #include <linux/list.h>
10 #include <linux/slab.h>
11 #include <asm/sections.h>
12
13 /* Whitelist of symbols that can be overridden for error injection. */
14 static LIST_HEAD(error_injection_list);
15 static DEFINE_MUTEX(ei_mutex);
16 struct ei_entry {
17 struct list_head list;
18 unsigned long start_addr;
19 unsigned long end_addr;
20 int etype;
21 void *priv;
22 };
23
24 bool within_error_injection_list(unsigned long addr)
25 {
26 struct ei_entry *ent;
27 bool ret = false;
28
29 mutex_lock(&ei_mutex);
30 list_for_each_entry(ent, &error_injection_list, list) {
31 if (addr >= ent->start_addr && addr < ent->end_addr) {
32 ret = true;
33 break;
34 }
35 }
36 mutex_unlock(&ei_mutex);
37 return ret;
38 }
39
40 int get_injectable_error_type(unsigned long addr)
41 {
42 struct ei_entry *ent;
43 int ei_type = -EINVAL;
44
45 mutex_lock(&ei_mutex);
46 list_for_each_entry(ent, &error_injection_list, list) {
47 if (addr >= ent->start_addr && addr < ent->end_addr) {
48 ei_type = ent->etype;
49 break;
50 }
51 }
52 mutex_unlock(&ei_mutex);
53
54 return ei_type;
55 }
56
57 /*
58 * Lookup and populate the error_injection_list.
59 *
60 * For safety reasons we only allow certain functions to be overridden with
61 * bpf_error_injection, so we need to populate the list of the symbols that have
62 * been marked as safe for overriding.
63 */
64 static void populate_error_injection_list(struct error_injection_entry *start,
65 struct error_injection_entry *end,
66 void *priv)
67 {
68 struct error_injection_entry *iter;
69 struct ei_entry *ent;
70 unsigned long entry, offset = 0, size = 0;
71
72 mutex_lock(&ei_mutex);
73 for (iter = start; iter < end; iter++) {
74 entry = (unsigned long)dereference_symbol_descriptor((void *)iter->addr);
75
76 if (!kernel_text_address(entry) ||
77 !kallsyms_lookup_size_offset(entry, &size, &offset)) {
78 pr_err("Failed to find error inject entry at %p\n",
79 (void *)entry);
80 continue;
81 }
82
83 ent = kmalloc(sizeof(*ent), GFP_KERNEL);
84 if (!ent)
85 break;
86 ent->start_addr = entry;
87 ent->end_addr = entry + size;
88 ent->etype = iter->etype;
89 ent->priv = priv;
90 INIT_LIST_HEAD(&ent->list);
91 list_add_tail(&ent->list, &error_injection_list);
92 }
93 mutex_unlock(&ei_mutex);
94 }
95
96 /* Markers of the _error_inject_whitelist section */
97 extern struct error_injection_entry __start_error_injection_whitelist[];
98 extern struct error_injection_entry __stop_error_injection_whitelist[];
99
100 static void __init populate_kernel_ei_list(void)
101 {
102 populate_error_injection_list(__start_error_injection_whitelist,
103 __stop_error_injection_whitelist,
104 NULL);
105 }
106
107 #ifdef CONFIG_MODULES
108 static void module_load_ei_list(struct module *mod)
109 {
110 if (!mod->num_ei_funcs)
111 return;
112
113 populate_error_injection_list(mod->ei_funcs,
114 mod->ei_funcs + mod->num_ei_funcs, mod);
115 }
116
117 static void module_unload_ei_list(struct module *mod)
118 {
119 struct ei_entry *ent, *n;
120
121 if (!mod->num_ei_funcs)
122 return;
123
124 mutex_lock(&ei_mutex);
125 list_for_each_entry_safe(ent, n, &error_injection_list, list) {
126 if (ent->priv == mod) {
127 list_del_init(&ent->list);
128 kfree(ent);
129 }
130 }
131 mutex_unlock(&ei_mutex);
132 }
133
134 /* Module notifier call back, checking error injection table on the module */
135 static int ei_module_callback(struct notifier_block *nb,
136 unsigned long val, void *data)
137 {
138 struct module *mod = data;
139
140 if (val == MODULE_STATE_COMING)
141 module_load_ei_list(mod);
142 else if (val == MODULE_STATE_GOING)
143 module_unload_ei_list(mod);
144
145 return NOTIFY_DONE;
146 }
147
148 static struct notifier_block ei_module_nb = {
149 .notifier_call = ei_module_callback,
150 .priority = 0
151 };
152
153 static __init int module_ei_init(void)
154 {
155 return register_module_notifier(&ei_module_nb);
156 }
157 #else /* !CONFIG_MODULES */
158 #define module_ei_init() (0)
159 #endif
160
161 /*
162 * error_injection/whitelist -- shows which functions can be overridden for
163 * error injection.
164 */
165 static void *ei_seq_start(struct seq_file *m, loff_t *pos)
166 {
167 mutex_lock(&ei_mutex);
168 return seq_list_start(&error_injection_list, *pos);
169 }
170
171 static void ei_seq_stop(struct seq_file *m, void *v)
172 {
173 mutex_unlock(&ei_mutex);
174 }
175
176 static void *ei_seq_next(struct seq_file *m, void *v, loff_t *pos)
177 {
178 return seq_list_next(v, &error_injection_list, pos);
179 }
180
181 static const char *error_type_string(int etype)
182 {
183 switch (etype) {
184 case EI_ETYPE_NULL:
185 return "NULL";
186 case EI_ETYPE_ERRNO:
187 return "ERRNO";
188 case EI_ETYPE_ERRNO_NULL:
189 return "ERRNO_NULL";
190 case EI_ETYPE_TRUE:
191 return "TRUE";
192 default:
193 return "(unknown)";
194 }
195 }
196
197 static int ei_seq_show(struct seq_file *m, void *v)
198 {
199 struct ei_entry *ent = list_entry(v, struct ei_entry, list);
200
201 seq_printf(m, "%ps\t%s\n", (void *)ent->start_addr,
202 error_type_string(ent->etype));
203 return 0;
204 }
205
206 static const struct seq_operations ei_sops = {
207 .start = ei_seq_start,
208 .next = ei_seq_next,
209 .stop = ei_seq_stop,
210 .show = ei_seq_show,
211 };
212
213 DEFINE_SEQ_ATTRIBUTE(ei);
214
215 static int __init ei_debugfs_init(void)
216 {
217 struct dentry *dir, *file;
218
219 dir = debugfs_create_dir("error_injection", NULL);
220
221 file = debugfs_create_file("list", 0444, dir, NULL, &ei_fops);
222 if (!file) {
223 debugfs_remove(dir);
224 return -ENOMEM;
225 }
226
227 return 0;
228 }
229
230 static int __init init_error_injection(void)
231 {
232 populate_kernel_ei_list();
233
234 if (!module_ei_init())
235 ei_debugfs_init();
236
237 return 0;
238 }
239 late_initcall(init_error_injection);
240
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.