fault-inject.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. #include <linux/kernel.h>
  3. #include <linux/init.h>
  4. #include <linux/random.h>
  5. #include <linux/sched.h>
  6. #include <linux/stat.h>
  7. #include <linux/types.h>
  8. #include <linux/fs.h>
  9. #include <linux/export.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/stacktrace.h>
  12. #include <linux/fault-inject.h>
  13. /*
  14. * setup_fault_attr() is a helper function for various __setup handlers, so it
  15. * returns 0 on error, because that is what __setup handlers do.
  16. */
  17. int setup_fault_attr(struct fault_attr *attr, char *str)
  18. {
  19. unsigned long probability;
  20. unsigned long interval;
  21. int times;
  22. int space;
  23. /* "<interval>,<probability>,<space>,<times>" */
  24. if (sscanf(str, "%lu,%lu,%d,%d",
  25. &interval, &probability, &space, &times) < 4) {
  26. printk(KERN_WARNING
  27. "FAULT_INJECTION: failed to parse arguments\n");
  28. return 0;
  29. }
  30. attr->probability = probability;
  31. attr->interval = interval;
  32. atomic_set(&attr->times, times);
  33. atomic_set(&attr->space, space);
  34. return 1;
  35. }
  36. EXPORT_SYMBOL_GPL(setup_fault_attr);
  37. static void fail_dump(struct fault_attr *attr)
  38. {
  39. if (attr->verbose > 0 && __ratelimit(&attr->ratelimit_state)) {
  40. printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure.\n"
  41. "name %pd, interval %lu, probability %lu, "
  42. "space %d, times %d\n", attr->dname,
  43. attr->interval, attr->probability,
  44. atomic_read(&attr->space),
  45. atomic_read(&attr->times));
  46. if (attr->verbose > 1)
  47. dump_stack();
  48. }
  49. }
  50. #define atomic_dec_not_zero(v) atomic_add_unless((v), -1, 0)
  51. static bool fail_task(struct fault_attr *attr, struct task_struct *task)
  52. {
  53. return in_task() && task->make_it_fail;
  54. }
  55. #define MAX_STACK_TRACE_DEPTH 32
  56. #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
  57. static bool fail_stacktrace(struct fault_attr *attr)
  58. {
  59. int depth = attr->stacktrace_depth;
  60. unsigned long entries[MAX_STACK_TRACE_DEPTH];
  61. int n, nr_entries;
  62. bool found = (attr->require_start == 0 && attr->require_end == ULONG_MAX);
  63. if (depth == 0)
  64. return found;
  65. nr_entries = stack_trace_save(entries, depth, 1);
  66. for (n = 0; n < nr_entries; n++) {
  67. if (attr->reject_start <= entries[n] &&
  68. entries[n] < attr->reject_end)
  69. return false;
  70. if (attr->require_start <= entries[n] &&
  71. entries[n] < attr->require_end)
  72. found = true;
  73. }
  74. return found;
  75. }
  76. #else
  77. static inline bool fail_stacktrace(struct fault_attr *attr)
  78. {
  79. return true;
  80. }
  81. #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
  82. /*
  83. * This code is stolen from failmalloc-1.0
  84. * http://www.nongnu.org/failmalloc/
  85. */
  86. bool should_fail(struct fault_attr *attr, ssize_t size)
  87. {
  88. if (in_task()) {
  89. unsigned int fail_nth = READ_ONCE(current->fail_nth);
  90. if (fail_nth) {
  91. fail_nth--;
  92. WRITE_ONCE(current->fail_nth, fail_nth);
  93. if (!fail_nth)
  94. goto fail;
  95. return false;
  96. }
  97. }
  98. /* No need to check any other properties if the probability is 0 */
  99. if (attr->probability == 0)
  100. return false;
  101. if (attr->task_filter && !fail_task(attr, current))
  102. return false;
  103. if (atomic_read(&attr->times) == 0)
  104. return false;
  105. if (atomic_read(&attr->space) > size) {
  106. atomic_sub(size, &attr->space);
  107. return false;
  108. }
  109. if (attr->interval > 1) {
  110. attr->count++;
  111. if (attr->count % attr->interval)
  112. return false;
  113. }
  114. if (attr->probability <= prandom_u32() % 100)
  115. return false;
  116. if (!fail_stacktrace(attr))
  117. return false;
  118. fail:
  119. fail_dump(attr);
  120. if (atomic_read(&attr->times) != -1)
  121. atomic_dec_not_zero(&attr->times);
  122. return true;
  123. }
  124. EXPORT_SYMBOL_GPL(should_fail);
  125. #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
  126. static int debugfs_ul_set(void *data, u64 val)
  127. {
  128. *(unsigned long *)data = val;
  129. return 0;
  130. }
  131. static int debugfs_ul_get(void *data, u64 *val)
  132. {
  133. *val = *(unsigned long *)data;
  134. return 0;
  135. }
  136. DEFINE_SIMPLE_ATTRIBUTE(fops_ul, debugfs_ul_get, debugfs_ul_set, "%llu\n");
  137. static void debugfs_create_ul(const char *name, umode_t mode,
  138. struct dentry *parent, unsigned long *value)
  139. {
  140. debugfs_create_file(name, mode, parent, value, &fops_ul);
  141. }
  142. #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
  143. static int debugfs_stacktrace_depth_set(void *data, u64 val)
  144. {
  145. *(unsigned long *)data =
  146. min_t(unsigned long, val, MAX_STACK_TRACE_DEPTH);
  147. return 0;
  148. }
  149. DEFINE_SIMPLE_ATTRIBUTE(fops_stacktrace_depth, debugfs_ul_get,
  150. debugfs_stacktrace_depth_set, "%llu\n");
  151. static void debugfs_create_stacktrace_depth(const char *name, umode_t mode,
  152. struct dentry *parent,
  153. unsigned long *value)
  154. {
  155. debugfs_create_file(name, mode, parent, value, &fops_stacktrace_depth);
  156. }
  157. #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
  158. struct dentry *fault_create_debugfs_attr(const char *name,
  159. struct dentry *parent, struct fault_attr *attr)
  160. {
  161. umode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
  162. struct dentry *dir;
  163. dir = debugfs_create_dir(name, parent);
  164. if (IS_ERR(dir))
  165. return dir;
  166. debugfs_create_ul("probability", mode, dir, &attr->probability);
  167. debugfs_create_ul("interval", mode, dir, &attr->interval);
  168. debugfs_create_atomic_t("times", mode, dir, &attr->times);
  169. debugfs_create_atomic_t("space", mode, dir, &attr->space);
  170. debugfs_create_ul("verbose", mode, dir, &attr->verbose);
  171. debugfs_create_u32("verbose_ratelimit_interval_ms", mode, dir,
  172. &attr->ratelimit_state.interval);
  173. debugfs_create_u32("verbose_ratelimit_burst", mode, dir,
  174. &attr->ratelimit_state.burst);
  175. debugfs_create_bool("task-filter", mode, dir, &attr->task_filter);
  176. #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
  177. debugfs_create_stacktrace_depth("stacktrace-depth", mode, dir,
  178. &attr->stacktrace_depth);
  179. debugfs_create_ul("require-start", mode, dir, &attr->require_start);
  180. debugfs_create_ul("require-end", mode, dir, &attr->require_end);
  181. debugfs_create_ul("reject-start", mode, dir, &attr->reject_start);
  182. debugfs_create_ul("reject-end", mode, dir, &attr->reject_end);
  183. #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
  184. attr->dname = dget(dir);
  185. return dir;
  186. }
  187. EXPORT_SYMBOL_GPL(fault_create_debugfs_attr);
  188. #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */