mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
5.5 KiB
245 lines
5.5 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
// error-inject.c: Function-level error injection table |
|
#include <linux/error-injection.h> |
|
#include <linux/debugfs.h> |
|
#include <linux/kallsyms.h> |
|
#include <linux/kprobes.h> |
|
#include <linux/module.h> |
|
#include <linux/mutex.h> |
|
#include <linux/list.h> |
|
#include <linux/slab.h> |
|
#include <asm/sections.h> |
|
|
|
/* Whitelist of symbols that can be overridden for error injection. */ |
|
static LIST_HEAD(error_injection_list); |
|
static DEFINE_MUTEX(ei_mutex); |
|
struct ei_entry { |
|
struct list_head list; |
|
unsigned long start_addr; |
|
unsigned long end_addr; |
|
int etype; |
|
void *priv; |
|
}; |
|
|
|
bool within_error_injection_list(unsigned long addr) |
|
{ |
|
struct ei_entry *ent; |
|
bool ret = false; |
|
|
|
mutex_lock(&ei_mutex); |
|
list_for_each_entry(ent, &error_injection_list, list) { |
|
if (addr >= ent->start_addr && addr < ent->end_addr) { |
|
ret = true; |
|
break; |
|
} |
|
} |
|
mutex_unlock(&ei_mutex); |
|
return ret; |
|
} |
|
|
|
int get_injectable_error_type(unsigned long addr) |
|
{ |
|
struct ei_entry *ent; |
|
|
|
list_for_each_entry(ent, &error_injection_list, list) { |
|
if (addr >= ent->start_addr && addr < ent->end_addr) |
|
return ent->etype; |
|
} |
|
return EI_ETYPE_NONE; |
|
} |
|
|
|
/* |
|
* Lookup and populate the error_injection_list. |
|
* |
|
* For safety reasons we only allow certain functions to be overridden with |
|
* bpf_error_injection, so we need to populate the list of the symbols that have |
|
* been marked as safe for overriding. |
|
*/ |
|
static void populate_error_injection_list(struct error_injection_entry *start, |
|
struct error_injection_entry *end, |
|
void *priv) |
|
{ |
|
struct error_injection_entry *iter; |
|
struct ei_entry *ent; |
|
unsigned long entry, offset = 0, size = 0; |
|
|
|
mutex_lock(&ei_mutex); |
|
for (iter = start; iter < end; iter++) { |
|
entry = (unsigned long)dereference_symbol_descriptor((void *)iter->addr); |
|
|
|
if (!kernel_text_address(entry) || |
|
!kallsyms_lookup_size_offset(entry, &size, &offset)) { |
|
pr_err("Failed to find error inject entry at %p\n", |
|
(void *)entry); |
|
continue; |
|
} |
|
|
|
ent = kmalloc(sizeof(*ent), GFP_KERNEL); |
|
if (!ent) |
|
break; |
|
ent->start_addr = entry; |
|
ent->end_addr = entry + size; |
|
ent->etype = iter->etype; |
|
ent->priv = priv; |
|
INIT_LIST_HEAD(&ent->list); |
|
list_add_tail(&ent->list, &error_injection_list); |
|
} |
|
mutex_unlock(&ei_mutex); |
|
} |
|
|
|
/* Markers of the _error_inject_whitelist section */ |
|
extern struct error_injection_entry __start_error_injection_whitelist[]; |
|
extern struct error_injection_entry __stop_error_injection_whitelist[]; |
|
|
|
static void __init populate_kernel_ei_list(void) |
|
{ |
|
populate_error_injection_list(__start_error_injection_whitelist, |
|
__stop_error_injection_whitelist, |
|
NULL); |
|
} |
|
|
|
#ifdef CONFIG_MODULES |
|
static void module_load_ei_list(struct module *mod) |
|
{ |
|
if (!mod->num_ei_funcs) |
|
return; |
|
|
|
populate_error_injection_list(mod->ei_funcs, |
|
mod->ei_funcs + mod->num_ei_funcs, mod); |
|
} |
|
|
|
static void module_unload_ei_list(struct module *mod) |
|
{ |
|
struct ei_entry *ent, *n; |
|
|
|
if (!mod->num_ei_funcs) |
|
return; |
|
|
|
mutex_lock(&ei_mutex); |
|
list_for_each_entry_safe(ent, n, &error_injection_list, list) { |
|
if (ent->priv == mod) { |
|
list_del_init(&ent->list); |
|
kfree(ent); |
|
} |
|
} |
|
mutex_unlock(&ei_mutex); |
|
} |
|
|
|
/* Module notifier call back, checking error injection table on the module */ |
|
static int ei_module_callback(struct notifier_block *nb, |
|
unsigned long val, void *data) |
|
{ |
|
struct module *mod = data; |
|
|
|
if (val == MODULE_STATE_COMING) |
|
module_load_ei_list(mod); |
|
else if (val == MODULE_STATE_GOING) |
|
module_unload_ei_list(mod); |
|
|
|
return NOTIFY_DONE; |
|
} |
|
|
|
static struct notifier_block ei_module_nb = { |
|
.notifier_call = ei_module_callback, |
|
.priority = 0 |
|
}; |
|
|
|
static __init int module_ei_init(void) |
|
{ |
|
return register_module_notifier(&ei_module_nb); |
|
} |
|
#else /* !CONFIG_MODULES */ |
|
#define module_ei_init() (0) |
|
#endif |
|
|
|
/* |
|
* error_injection/whitelist -- shows which functions can be overridden for |
|
* error injection. |
|
*/ |
|
static void *ei_seq_start(struct seq_file *m, loff_t *pos) |
|
{ |
|
mutex_lock(&ei_mutex); |
|
return seq_list_start(&error_injection_list, *pos); |
|
} |
|
|
|
static void ei_seq_stop(struct seq_file *m, void *v) |
|
{ |
|
mutex_unlock(&ei_mutex); |
|
} |
|
|
|
static void *ei_seq_next(struct seq_file *m, void *v, loff_t *pos) |
|
{ |
|
return seq_list_next(v, &error_injection_list, pos); |
|
} |
|
|
|
static const char *error_type_string(int etype) |
|
{ |
|
switch (etype) { |
|
case EI_ETYPE_NULL: |
|
return "NULL"; |
|
case EI_ETYPE_ERRNO: |
|
return "ERRNO"; |
|
case EI_ETYPE_ERRNO_NULL: |
|
return "ERRNO_NULL"; |
|
case EI_ETYPE_TRUE: |
|
return "TRUE"; |
|
default: |
|
return "(unknown)"; |
|
} |
|
} |
|
|
|
static int ei_seq_show(struct seq_file *m, void *v) |
|
{ |
|
struct ei_entry *ent = list_entry(v, struct ei_entry, list); |
|
|
|
seq_printf(m, "%ps\t%s\n", (void *)ent->start_addr, |
|
error_type_string(ent->etype)); |
|
return 0; |
|
} |
|
|
|
static const struct seq_operations ei_seq_ops = { |
|
.start = ei_seq_start, |
|
.next = ei_seq_next, |
|
.stop = ei_seq_stop, |
|
.show = ei_seq_show, |
|
}; |
|
|
|
static int ei_open(struct inode *inode, struct file *filp) |
|
{ |
|
return seq_open(filp, &ei_seq_ops); |
|
} |
|
|
|
static const struct file_operations debugfs_ei_ops = { |
|
.open = ei_open, |
|
.read = seq_read, |
|
.llseek = seq_lseek, |
|
.release = seq_release, |
|
}; |
|
|
|
static int __init ei_debugfs_init(void) |
|
{ |
|
struct dentry *dir, *file; |
|
|
|
dir = debugfs_create_dir("error_injection", NULL); |
|
if (!dir) |
|
return -ENOMEM; |
|
|
|
file = debugfs_create_file("list", 0444, dir, NULL, &debugfs_ei_ops); |
|
if (!file) { |
|
debugfs_remove(dir); |
|
return -ENOMEM; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int __init init_error_injection(void) |
|
{ |
|
populate_kernel_ei_list(); |
|
|
|
if (!module_ei_init()) |
|
ei_debugfs_init(); |
|
|
|
return 0; |
|
} |
|
late_initcall(init_error_injection);
|
|
|