mtd: spi-nor: Add an SPDX tag to spi-nor.{c,h}
[linux-2.6-microblaze.git] / kernel / fail_function.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * fail_function.c: Function-based error injection
4  */
5 #include <linux/error-injection.h>
6 #include <linux/debugfs.h>
7 #include <linux/fault-inject.h>
8 #include <linux/kallsyms.h>
9 #include <linux/kprobes.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/slab.h>
13 #include <linux/uaccess.h>
14
15 static int fei_kprobe_handler(struct kprobe *kp, struct pt_regs *regs);
16
17 static void fei_post_handler(struct kprobe *kp, struct pt_regs *regs,
18                              unsigned long flags)
19 {
20         /*
21          * A dummy post handler is required to prohibit optimizing, because
22          * jump optimization does not support execution path overriding.
23          */
24 }
25
26 struct fei_attr {
27         struct list_head list;
28         struct kprobe kp;
29         unsigned long retval;
30 };
31 static DEFINE_MUTEX(fei_lock);
32 static LIST_HEAD(fei_attr_list);
33 static DECLARE_FAULT_ATTR(fei_fault_attr);
34 static struct dentry *fei_debugfs_dir;
35
36 static unsigned long adjust_error_retval(unsigned long addr, unsigned long retv)
37 {
38         switch (get_injectable_error_type(addr)) {
39         case EI_ETYPE_NULL:
40                 if (retv != 0)
41                         return 0;
42                 break;
43         case EI_ETYPE_ERRNO:
44                 if (retv < (unsigned long)-MAX_ERRNO)
45                         return (unsigned long)-EINVAL;
46                 break;
47         case EI_ETYPE_ERRNO_NULL:
48                 if (retv != 0 && retv < (unsigned long)-MAX_ERRNO)
49                         return (unsigned long)-EINVAL;
50                 break;
51         }
52
53         return retv;
54 }
55
56 static struct fei_attr *fei_attr_new(const char *sym, unsigned long addr)
57 {
58         struct fei_attr *attr;
59
60         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
61         if (attr) {
62                 attr->kp.symbol_name = kstrdup(sym, GFP_KERNEL);
63                 if (!attr->kp.symbol_name) {
64                         kfree(attr);
65                         return NULL;
66                 }
67                 attr->kp.pre_handler = fei_kprobe_handler;
68                 attr->kp.post_handler = fei_post_handler;
69                 attr->retval = adjust_error_retval(addr, 0);
70                 INIT_LIST_HEAD(&attr->list);
71         }
72         return attr;
73 }
74
75 static void fei_attr_free(struct fei_attr *attr)
76 {
77         if (attr) {
78                 kfree(attr->kp.symbol_name);
79                 kfree(attr);
80         }
81 }
82
83 static struct fei_attr *fei_attr_lookup(const char *sym)
84 {
85         struct fei_attr *attr;
86
87         list_for_each_entry(attr, &fei_attr_list, list) {
88                 if (!strcmp(attr->kp.symbol_name, sym))
89                         return attr;
90         }
91
92         return NULL;
93 }
94
95 static bool fei_attr_is_valid(struct fei_attr *_attr)
96 {
97         struct fei_attr *attr;
98
99         list_for_each_entry(attr, &fei_attr_list, list) {
100                 if (attr == _attr)
101                         return true;
102         }
103
104         return false;
105 }
106
107 static int fei_retval_set(void *data, u64 val)
108 {
109         struct fei_attr *attr = data;
110         unsigned long retv = (unsigned long)val;
111         int err = 0;
112
113         mutex_lock(&fei_lock);
114         /*
115          * Since this operation can be done after retval file is removed,
116          * It is safer to check the attr is still valid before accessing
117          * its member.
118          */
119         if (!fei_attr_is_valid(attr)) {
120                 err = -ENOENT;
121                 goto out;
122         }
123
124         if (attr->kp.addr) {
125                 if (adjust_error_retval((unsigned long)attr->kp.addr,
126                                         val) != retv)
127                         err = -EINVAL;
128         }
129         if (!err)
130                 attr->retval = val;
131 out:
132         mutex_unlock(&fei_lock);
133
134         return err;
135 }
136
137 static int fei_retval_get(void *data, u64 *val)
138 {
139         struct fei_attr *attr = data;
140         int err = 0;
141
142         mutex_lock(&fei_lock);
143         /* Here we also validate @attr to ensure it still exists. */
144         if (!fei_attr_is_valid(attr))
145                 err = -ENOENT;
146         else
147                 *val = attr->retval;
148         mutex_unlock(&fei_lock);
149
150         return err;
151 }
152 DEFINE_DEBUGFS_ATTRIBUTE(fei_retval_ops, fei_retval_get, fei_retval_set,
153                          "%llx\n");
154
155 static int fei_debugfs_add_attr(struct fei_attr *attr)
156 {
157         struct dentry *dir;
158
159         dir = debugfs_create_dir(attr->kp.symbol_name, fei_debugfs_dir);
160         if (!dir)
161                 return -ENOMEM;
162
163         if (!debugfs_create_file("retval", 0600, dir, attr, &fei_retval_ops)) {
164                 debugfs_remove_recursive(dir);
165                 return -ENOMEM;
166         }
167
168         return 0;
169 }
170
171 static void fei_debugfs_remove_attr(struct fei_attr *attr)
172 {
173         struct dentry *dir;
174
175         dir = debugfs_lookup(attr->kp.symbol_name, fei_debugfs_dir);
176         debugfs_remove_recursive(dir);
177 }
178
179 static int fei_kprobe_handler(struct kprobe *kp, struct pt_regs *regs)
180 {
181         struct fei_attr *attr = container_of(kp, struct fei_attr, kp);
182
183         if (should_fail(&fei_fault_attr, 1)) {
184                 regs_set_return_value(regs, attr->retval);
185                 override_function_with_return(regs);
186                 return 1;
187         }
188
189         return 0;
190 }
191 NOKPROBE_SYMBOL(fei_kprobe_handler)
192
193 static void *fei_seq_start(struct seq_file *m, loff_t *pos)
194 {
195         mutex_lock(&fei_lock);
196         return seq_list_start(&fei_attr_list, *pos);
197 }
198
199 static void fei_seq_stop(struct seq_file *m, void *v)
200 {
201         mutex_unlock(&fei_lock);
202 }
203
204 static void *fei_seq_next(struct seq_file *m, void *v, loff_t *pos)
205 {
206         return seq_list_next(v, &fei_attr_list, pos);
207 }
208
209 static int fei_seq_show(struct seq_file *m, void *v)
210 {
211         struct fei_attr *attr = list_entry(v, struct fei_attr, list);
212
213         seq_printf(m, "%pf\n", attr->kp.addr);
214         return 0;
215 }
216
217 static const struct seq_operations fei_seq_ops = {
218         .start  = fei_seq_start,
219         .next   = fei_seq_next,
220         .stop   = fei_seq_stop,
221         .show   = fei_seq_show,
222 };
223
224 static int fei_open(struct inode *inode, struct file *file)
225 {
226         return seq_open(file, &fei_seq_ops);
227 }
228
229 static void fei_attr_remove(struct fei_attr *attr)
230 {
231         fei_debugfs_remove_attr(attr);
232         unregister_kprobe(&attr->kp);
233         list_del(&attr->list);
234         fei_attr_free(attr);
235 }
236
237 static void fei_attr_remove_all(void)
238 {
239         struct fei_attr *attr, *n;
240
241         list_for_each_entry_safe(attr, n, &fei_attr_list, list) {
242                 fei_attr_remove(attr);
243         }
244 }
245
246 static ssize_t fei_write(struct file *file, const char __user *buffer,
247                          size_t count, loff_t *ppos)
248 {
249         struct fei_attr *attr;
250         unsigned long addr;
251         char *buf, *sym;
252         int ret;
253
254         /* cut off if it is too long */
255         if (count > KSYM_NAME_LEN)
256                 count = KSYM_NAME_LEN;
257         buf = kmalloc(count + 1, GFP_KERNEL);
258         if (!buf)
259                 return -ENOMEM;
260
261         if (copy_from_user(buf, buffer, count)) {
262                 ret = -EFAULT;
263                 goto out;
264         }
265         buf[count] = '\0';
266         sym = strstrip(buf);
267
268         mutex_lock(&fei_lock);
269
270         /* Writing just spaces will remove all injection points */
271         if (sym[0] == '\0') {
272                 fei_attr_remove_all();
273                 ret = count;
274                 goto out;
275         }
276         /* Writing !function will remove one injection point */
277         if (sym[0] == '!') {
278                 attr = fei_attr_lookup(sym + 1);
279                 if (!attr) {
280                         ret = -ENOENT;
281                         goto out;
282                 }
283                 fei_attr_remove(attr);
284                 ret = count;
285                 goto out;
286         }
287
288         addr = kallsyms_lookup_name(sym);
289         if (!addr) {
290                 ret = -EINVAL;
291                 goto out;
292         }
293         if (!within_error_injection_list(addr)) {
294                 ret = -ERANGE;
295                 goto out;
296         }
297         if (fei_attr_lookup(sym)) {
298                 ret = -EBUSY;
299                 goto out;
300         }
301         attr = fei_attr_new(sym, addr);
302         if (!attr) {
303                 ret = -ENOMEM;
304                 goto out;
305         }
306
307         ret = register_kprobe(&attr->kp);
308         if (!ret)
309                 ret = fei_debugfs_add_attr(attr);
310         if (ret < 0)
311                 fei_attr_remove(attr);
312         else {
313                 list_add_tail(&attr->list, &fei_attr_list);
314                 ret = count;
315         }
316 out:
317         kfree(buf);
318         mutex_unlock(&fei_lock);
319         return ret;
320 }
321
322 static const struct file_operations fei_ops = {
323         .open =         fei_open,
324         .read =         seq_read,
325         .write =        fei_write,
326         .llseek =       seq_lseek,
327         .release =      seq_release,
328 };
329
330 static int __init fei_debugfs_init(void)
331 {
332         struct dentry *dir;
333
334         dir = fault_create_debugfs_attr("fail_function", NULL,
335                                         &fei_fault_attr);
336         if (IS_ERR(dir))
337                 return PTR_ERR(dir);
338
339         /* injectable attribute is just a symlink of error_inject/list */
340         if (!debugfs_create_symlink("injectable", dir,
341                                     "../error_injection/list"))
342                 goto error;
343
344         if (!debugfs_create_file("inject", 0600, dir, NULL, &fei_ops))
345                 goto error;
346
347         fei_debugfs_dir = dir;
348
349         return 0;
350 error:
351         debugfs_remove_recursive(dir);
352         return -ENOMEM;
353 }
354
355 late_initcall(fei_debugfs_init);