Blame view

lib/fault-inject.c 7.81 KB
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
1
2
3
4
5
6
7
  #include <linux/kernel.h>
  #include <linux/init.h>
  #include <linux/random.h>
  #include <linux/stat.h>
  #include <linux/types.h>
  #include <linux/fs.h>
  #include <linux/module.h>
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
8
  #include <linux/interrupt.h>
329409aed   Akinobu Mita   [PATCH] fault inj...
9
10
11
  #include <linux/unwind.h>
  #include <linux/stacktrace.h>
  #include <linux/kallsyms.h>
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
  #include <linux/fault-inject.h>
  
  /*
   * setup_fault_attr() is a helper function for various __setup handlers, so it
   * returns 0 on error, because that is what __setup handlers do.
   */
  int __init setup_fault_attr(struct fault_attr *attr, char *str)
  {
  	unsigned long probability;
  	unsigned long interval;
  	int times;
  	int space;
  
  	/* "<interval>,<probability>,<space>,<times>" */
  	if (sscanf(str, "%lu,%lu,%d,%d",
  			&interval, &probability, &space, &times) < 4) {
  		printk(KERN_WARNING
  			"FAULT_INJECTION: failed to parse arguments
  ");
  		return 0;
  	}
  
  	attr->probability = probability;
  	attr->interval = interval;
  	atomic_set(&attr->times, times);
  	atomic_set(&attr->space, space);
  
  	return 1;
  }
  
  static void fail_dump(struct fault_attr *attr)
  {
  	if (attr->verbose > 0)
  		printk(KERN_NOTICE "FAULT_INJECTION: forcing a failure
  ");
  	if (attr->verbose > 1)
  		dump_stack();
  }
  
  #define atomic_dec_not_zero(v)		atomic_add_unless((v), -1, 0)
08b3df2d1   Don Mullis   [PATCH] fault-inj...
52
  static bool fail_task(struct fault_attr *attr, struct task_struct *task)
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
53
54
55
  {
  	return !in_interrupt() && task->make_it_fail;
  }
a124c28ef   Don Mullis   [PATCH] fault-inj...
56
  #define MAX_STACK_TRACE_DEPTH 32
1df49008f   Akinobu Mita   [PATCH] fault inj...
57
  #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
329409aed   Akinobu Mita   [PATCH] fault inj...
58

08b3df2d1   Don Mullis   [PATCH] fault-inj...
59
  static bool fail_stacktrace(struct fault_attr *attr)
329409aed   Akinobu Mita   [PATCH] fault inj...
60
61
62
63
64
65
66
67
68
69
70
71
  {
  	struct stack_trace trace;
  	int depth = attr->stacktrace_depth;
  	unsigned long entries[MAX_STACK_TRACE_DEPTH];
  	int n;
  	bool found = (attr->require_start == 0 && attr->require_end == ULONG_MAX);
  
  	if (depth == 0)
  		return found;
  
  	trace.nr_entries = 0;
  	trace.entries = entries;
a124c28ef   Don Mullis   [PATCH] fault-inj...
72
  	trace.max_entries = depth;
329409aed   Akinobu Mita   [PATCH] fault inj...
73
  	trace.skip = 1;
329409aed   Akinobu Mita   [PATCH] fault inj...
74

ab1b6f03a   Christoph Hellwig   simplify the stac...
75
  	save_stack_trace(&trace);
329409aed   Akinobu Mita   [PATCH] fault inj...
76
77
78
  	for (n = 0; n < trace.nr_entries; n++) {
  		if (attr->reject_start <= entries[n] &&
  			       entries[n] < attr->reject_end)
08b3df2d1   Don Mullis   [PATCH] fault-inj...
79
  			return false;
329409aed   Akinobu Mita   [PATCH] fault inj...
80
81
  		if (attr->require_start <= entries[n] &&
  			       entries[n] < attr->require_end)
08b3df2d1   Don Mullis   [PATCH] fault-inj...
82
  			found = true;
329409aed   Akinobu Mita   [PATCH] fault inj...
83
84
85
86
87
  	}
  	return found;
  }
  
  #else
08b3df2d1   Don Mullis   [PATCH] fault-inj...
88
  static inline bool fail_stacktrace(struct fault_attr *attr)
329409aed   Akinobu Mita   [PATCH] fault inj...
89
  {
1df49008f   Akinobu Mita   [PATCH] fault inj...
90
  	return true;
329409aed   Akinobu Mita   [PATCH] fault inj...
91
  }
1df49008f   Akinobu Mita   [PATCH] fault inj...
92
  #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
329409aed   Akinobu Mita   [PATCH] fault inj...
93

6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
94
95
96
97
  /*
   * This code is stolen from failmalloc-1.0
   * http://www.nongnu.org/failmalloc/
   */
08b3df2d1   Don Mullis   [PATCH] fault-inj...
98
  bool should_fail(struct fault_attr *attr, ssize_t size)
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
99
  {
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
100
  	if (attr->task_filter && !fail_task(attr, current))
08b3df2d1   Don Mullis   [PATCH] fault-inj...
101
  		return false;
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
102

6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
103
  	if (atomic_read(&attr->times) == 0)
08b3df2d1   Don Mullis   [PATCH] fault-inj...
104
  		return false;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
105
106
107
  
  	if (atomic_read(&attr->space) > size) {
  		atomic_sub(size, &attr->space);
08b3df2d1   Don Mullis   [PATCH] fault-inj...
108
  		return false;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
109
110
111
112
113
  	}
  
  	if (attr->interval > 1) {
  		attr->count++;
  		if (attr->count % attr->interval)
08b3df2d1   Don Mullis   [PATCH] fault-inj...
114
  			return false;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
115
  	}
f1729c28a   Don Mullis   [PATCH] fault-inj...
116
117
  	if (attr->probability <= random32() % 100)
  		return false;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
118

f1729c28a   Don Mullis   [PATCH] fault-inj...
119
120
  	if (!fail_stacktrace(attr))
  		return false;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
121

6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
122
123
124
125
  	fail_dump(attr);
  
  	if (atomic_read(&attr->times) != -1)
  		atomic_dec_not_zero(&attr->times);
08b3df2d1   Don Mullis   [PATCH] fault-inj...
126
  	return true;
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
127
128
129
130
131
132
133
134
  }
  
  #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
  
  static void debugfs_ul_set(void *data, u64 val)
  {
  	*(unsigned long *)data = val;
  }
6ddb23c78   Stephen Rothwell   fault_inject: sil...
135
  #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
a124c28ef   Don Mullis   [PATCH] fault-inj...
136
137
138
139
140
141
  static void debugfs_ul_set_MAX_STACK_TRACE_DEPTH(void *data, u64 val)
  {
  	*(unsigned long *)data =
  		val < MAX_STACK_TRACE_DEPTH ?
  		val : MAX_STACK_TRACE_DEPTH;
  }
6ddb23c78   Stephen Rothwell   fault_inject: sil...
142
  #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
a124c28ef   Don Mullis   [PATCH] fault-inj...
143

6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
144
145
146
147
148
149
150
151
152
153
154
155
156
  static u64 debugfs_ul_get(void *data)
  {
  	return *(unsigned long *)data;
  }
  
  DEFINE_SIMPLE_ATTRIBUTE(fops_ul, debugfs_ul_get, debugfs_ul_set, "%llu
  ");
  
  static struct dentry *debugfs_create_ul(const char *name, mode_t mode,
  				struct dentry *parent, unsigned long *value)
  {
  	return debugfs_create_file(name, mode, parent, value, &fops_ul);
  }
6ddb23c78   Stephen Rothwell   fault_inject: sil...
157
  #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
a124c28ef   Don Mullis   [PATCH] fault-inj...
158
159
160
161
162
163
164
165
166
167
168
  DEFINE_SIMPLE_ATTRIBUTE(fops_ul_MAX_STACK_TRACE_DEPTH, debugfs_ul_get,
  			debugfs_ul_set_MAX_STACK_TRACE_DEPTH, "%llu
  ");
  
  static struct dentry *debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
  	const char *name, mode_t mode,
  	struct dentry *parent, unsigned long *value)
  {
  	return debugfs_create_file(name, mode, parent, value,
  				   &fops_ul_MAX_STACK_TRACE_DEPTH);
  }
6ddb23c78   Stephen Rothwell   fault_inject: sil...
169
  #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
a124c28ef   Don Mullis   [PATCH] fault-inj...
170

6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
  static void debugfs_atomic_t_set(void *data, u64 val)
  {
  	atomic_set((atomic_t *)data, val);
  }
  
  static u64 debugfs_atomic_t_get(void *data)
  {
  	return atomic_read((atomic_t *)data);
  }
  
  DEFINE_SIMPLE_ATTRIBUTE(fops_atomic_t, debugfs_atomic_t_get,
  			debugfs_atomic_t_set, "%lld
  ");
  
  static struct dentry *debugfs_create_atomic_t(const char *name, mode_t mode,
  				struct dentry *parent, atomic_t *value)
  {
  	return debugfs_create_file(name, mode, parent, value, &fops_atomic_t);
  }
  
  void cleanup_fault_attr_dentries(struct fault_attr *attr)
  {
  	debugfs_remove(attr->dentries.probability_file);
  	attr->dentries.probability_file = NULL;
  
  	debugfs_remove(attr->dentries.interval_file);
  	attr->dentries.interval_file = NULL;
  
  	debugfs_remove(attr->dentries.times_file);
  	attr->dentries.times_file = NULL;
  
  	debugfs_remove(attr->dentries.space_file);
  	attr->dentries.space_file = NULL;
  
  	debugfs_remove(attr->dentries.verbose_file);
  	attr->dentries.verbose_file = NULL;
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
207
208
  	debugfs_remove(attr->dentries.task_filter_file);
  	attr->dentries.task_filter_file = NULL;
1df49008f   Akinobu Mita   [PATCH] fault inj...
209
  #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
329409aed   Akinobu Mita   [PATCH] fault inj...
210
211
212
213
214
215
216
217
218
219
220
221
222
223
  	debugfs_remove(attr->dentries.stacktrace_depth_file);
  	attr->dentries.stacktrace_depth_file = NULL;
  
  	debugfs_remove(attr->dentries.require_start_file);
  	attr->dentries.require_start_file = NULL;
  
  	debugfs_remove(attr->dentries.require_end_file);
  	attr->dentries.require_end_file = NULL;
  
  	debugfs_remove(attr->dentries.reject_start_file);
  	attr->dentries.reject_start_file = NULL;
  
  	debugfs_remove(attr->dentries.reject_end_file);
  	attr->dentries.reject_end_file = NULL;
1df49008f   Akinobu Mita   [PATCH] fault inj...
224
  #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
  	if (attr->dentries.dir)
  		WARN_ON(!simple_empty(attr->dentries.dir));
  
  	debugfs_remove(attr->dentries.dir);
  	attr->dentries.dir = NULL;
  }
  
  int init_fault_attr_dentries(struct fault_attr *attr, const char *name)
  {
  	mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
  	struct dentry *dir;
  
  	memset(&attr->dentries, 0, sizeof(attr->dentries));
  
  	dir = debugfs_create_dir(name, NULL);
  	if (!dir)
  		goto fail;
  	attr->dentries.dir = dir;
  
  	attr->dentries.probability_file =
  		debugfs_create_ul("probability", mode, dir, &attr->probability);
  
  	attr->dentries.interval_file =
  		debugfs_create_ul("interval", mode, dir, &attr->interval);
  
  	attr->dentries.times_file =
  		debugfs_create_atomic_t("times", mode, dir, &attr->times);
  
  	attr->dentries.space_file =
  		debugfs_create_atomic_t("space", mode, dir, &attr->space);
  
  	attr->dentries.verbose_file =
  		debugfs_create_ul("verbose", mode, dir, &attr->verbose);
f4f154fd9   Akinobu Mita   [PATCH] fault inj...
258
259
  	attr->dentries.task_filter_file = debugfs_create_bool("task-filter",
  						mode, dir, &attr->task_filter);
1df49008f   Akinobu Mita   [PATCH] fault inj...
260
261
262
263
264
265
  	if (!attr->dentries.probability_file || !attr->dentries.interval_file ||
  	    !attr->dentries.times_file || !attr->dentries.space_file ||
  	    !attr->dentries.verbose_file || !attr->dentries.task_filter_file)
  		goto fail;
  
  #ifdef CONFIG_FAULT_INJECTION_STACKTRACE_FILTER
329409aed   Akinobu Mita   [PATCH] fault inj...
266
  	attr->dentries.stacktrace_depth_file =
a124c28ef   Don Mullis   [PATCH] fault-inj...
267
268
  		debugfs_create_ul_MAX_STACK_TRACE_DEPTH(
  			"stacktrace-depth", mode, dir, &attr->stacktrace_depth);
329409aed   Akinobu Mita   [PATCH] fault inj...
269
270
271
272
273
274
275
276
277
278
279
280
  
  	attr->dentries.require_start_file =
  		debugfs_create_ul("require-start", mode, dir, &attr->require_start);
  
  	attr->dentries.require_end_file =
  		debugfs_create_ul("require-end", mode, dir, &attr->require_end);
  
  	attr->dentries.reject_start_file =
  		debugfs_create_ul("reject-start", mode, dir, &attr->reject_start);
  
  	attr->dentries.reject_end_file =
  		debugfs_create_ul("reject-end", mode, dir, &attr->reject_end);
1df49008f   Akinobu Mita   [PATCH] fault inj...
281
282
283
284
285
  	if (!attr->dentries.stacktrace_depth_file ||
  	    !attr->dentries.require_start_file ||
  	    !attr->dentries.require_end_file ||
  	    !attr->dentries.reject_start_file ||
  	    !attr->dentries.reject_end_file)
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
286
  		goto fail;
1df49008f   Akinobu Mita   [PATCH] fault inj...
287
  #endif /* CONFIG_FAULT_INJECTION_STACKTRACE_FILTER */
6ff1cb355   Akinobu Mita   [PATCH] fault-inj...
288
289
290
291
292
293
294
  	return 0;
  fail:
  	cleanup_fault_attr_dentries(attr);
  	return -ENOMEM;
  }
  
  #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */