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(lock: &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(lock: &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(ptr: (void *)iter->addr); |
75 | |
76 | if (!kernel_text_address(addr: entry) || |
77 | !kallsyms_lookup_size_offset(addr: entry, symbolsize: &size, offset: &offset)) { |
78 | pr_err("Failed to find error inject entry at %p\n" , |
79 | (void *)entry); |
80 | continue; |
81 | } |
82 | |
83 | ent = kmalloc(size: 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(list: &ent->list); |
91 | list_add_tail(new: &ent->list, head: &error_injection_list); |
92 | } |
93 | mutex_unlock(lock: &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: __start_error_injection_whitelist, |
103 | end: __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(start: mod->ei_funcs, |
114 | end: mod->ei_funcs + mod->num_ei_funcs, priv: 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(entry: &ent->list); |
128 | kfree(objp: ent); |
129 | } |
130 | } |
131 | mutex_unlock(lock: &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(nb: &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(head: &error_injection_list, pos: *pos); |
169 | } |
170 | |
171 | static void ei_seq_stop(struct seq_file *m, void *v) |
172 | { |
173 | mutex_unlock(lock: &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, head: &error_injection_list, ppos: 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, fmt: "%ps\t%s\n" , (void *)ent->start_addr, |
202 | error_type_string(etype: 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(name: "error_injection" , NULL); |
220 | |
221 | file = debugfs_create_file(name: "list" , mode: 0444, parent: dir, NULL, fops: &ei_fops); |
222 | if (!file) { |
223 | debugfs_remove(dentry: 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 | |