Commit | Line | Data |
---|---|---|
540adea3 MH |
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> | |
f2ec8d9a | 11 | #include <asm/sections.h> |
540adea3 MH |
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; | |
663faf9f | 20 | int etype; |
540adea3 MH |
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 | ||
663faf9f MH |
40 | int get_injectable_error_type(unsigned long addr) |
41 | { | |
42 | struct ei_entry *ent; | |
6338bb05 | 43 | int ei_type = -EINVAL; |
663faf9f | 44 | |
86e5908e | 45 | mutex_lock(&ei_mutex); |
663faf9f | 46 | list_for_each_entry(ent, &error_injection_list, list) { |
86e5908e | 47 | if (addr >= ent->start_addr && addr < ent->end_addr) { |
48 | ei_type = ent->etype; | |
49 | break; | |
50 | } | |
663faf9f | 51 | } |
86e5908e | 52 | mutex_unlock(&ei_mutex); |
53 | ||
54 | return ei_type; | |
663faf9f MH |
55 | } |
56 | ||
540adea3 MH |
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 | */ | |
663faf9f MH |
64 | static void populate_error_injection_list(struct error_injection_entry *start, |
65 | struct error_injection_entry *end, | |
66 | void *priv) | |
540adea3 | 67 | { |
663faf9f | 68 | struct error_injection_entry *iter; |
540adea3 MH |
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++) { | |
f2ec8d9a | 74 | entry = (unsigned long)dereference_symbol_descriptor((void *)iter->addr); |
540adea3 MH |
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; | |
663faf9f | 88 | ent->etype = iter->etype; |
540adea3 MH |
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 */ | |
663faf9f MH |
97 | extern struct error_injection_entry __start_error_injection_whitelist[]; |
98 | extern struct error_injection_entry __stop_error_injection_whitelist[]; | |
540adea3 MH |
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 | ||
663faf9f MH |
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"; | |
537cd894 BP |
190 | case EI_ETYPE_TRUE: |
191 | return "TRUE"; | |
663faf9f MH |
192 | default: |
193 | return "(unknown)"; | |
194 | } | |
195 | } | |
196 | ||
540adea3 MH |
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 | ||
d75f773c | 201 | seq_printf(m, "%ps\t%s\n", (void *)ent->start_addr, |
663faf9f | 202 | error_type_string(ent->etype)); |
540adea3 MH |
203 | return 0; |
204 | } | |
205 | ||
00c9d563 | 206 | static const struct seq_operations ei_sops = { |
540adea3 MH |
207 | .start = ei_seq_start, |
208 | .next = ei_seq_next, | |
209 | .stop = ei_seq_stop, | |
210 | .show = ei_seq_show, | |
211 | }; | |
212 | ||
00c9d563 | 213 | DEFINE_SEQ_ATTRIBUTE(ei); |
540adea3 MH |
214 | |
215 | static int __init ei_debugfs_init(void) | |
216 | { | |
217 | struct dentry *dir, *file; | |
218 | ||
219 | dir = debugfs_create_dir("error_injection", NULL); | |
540adea3 | 220 | |
00c9d563 | 221 | file = debugfs_create_file("list", 0444, dir, NULL, &ei_fops); |
540adea3 MH |
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); |