~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/fail_function.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.12 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.55 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.136 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.191 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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, "%ps\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);
356 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp