fail_function.c 7.0 KB

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