1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * Linux Kernel Dump Test Module for testing kernel crashes conditions:
4 * induces system failures at predefined crashpoints and under predefined
5 * operational conditions in order to evaluate the reliability of kernel
6 * sanity checking and crash dumps obtained using different dumping
7 * solutions.
8 *
9 * Copyright (C) IBM Corporation, 2006
10 *
11 * Author: Ankita Garg <ankita@in.ibm.com>
12 *
13 * It is adapted from the Linux Kernel Dump Test Tool by
14 * Fernando Luis Vazquez Cao <http://lkdtt.sourceforge.net>
15 *
16 * Debugfs support added by Simon Kagstrom <simon.kagstrom@netinsight.net>
17 *
18 * See Documentation/fault-injection/provoke-crashes.rst for instructions
19 */
20#include "lkdtm.h"
21#include <linux/fs.h>
22#include <linux/module.h>
23#include <linux/buffer_head.h>
24#include <linux/kprobes.h>
25#include <linux/list.h>
26#include <linux/init.h>
27#include <linux/slab.h>
28#include <linux/debugfs.h>
29
30#define DEFAULT_COUNT 10
31
32static int lkdtm_debugfs_open(struct inode *inode, struct file *file);
33static ssize_t lkdtm_debugfs_read(struct file *f, char __user *user_buf,
34		size_t count, loff_t *off);
35static ssize_t direct_entry(struct file *f, const char __user *user_buf,
36			    size_t count, loff_t *off);
37
38#ifdef CONFIG_KPROBES
39static int lkdtm_kprobe_handler(struct kprobe *kp, struct pt_regs *regs);
40static ssize_t lkdtm_debugfs_entry(struct file *f,
41				   const char __user *user_buf,
42				   size_t count, loff_t *off);
43# define CRASHPOINT_KPROBE(_symbol)				\
44		.kprobe = {					\
45			.symbol_name = (_symbol),		\
46			.pre_handler = lkdtm_kprobe_handler,	\
47		},
48# define CRASHPOINT_WRITE(_symbol)				\
49		(_symbol) ? lkdtm_debugfs_entry : direct_entry
50#else
51# define CRASHPOINT_KPROBE(_symbol)
52# define CRASHPOINT_WRITE(_symbol)		direct_entry
53#endif
54
55/* Crash points */
56struct crashpoint {
57	const char *name;
58	const struct file_operations fops;
59	struct kprobe kprobe;
60};
61
62#define CRASHPOINT(_name, _symbol)				\
63	{							\
64		.name = _name,					\
65		.fops = {					\
66			.read	= lkdtm_debugfs_read,		\
67			.llseek	= generic_file_llseek,		\
68			.open	= lkdtm_debugfs_open,		\
69			.write	= CRASHPOINT_WRITE(_symbol)	\
70		},						\
71		CRASHPOINT_KPROBE(_symbol)			\
72	}
73
74/* Define the possible places where we can trigger a crash point. */
75static struct crashpoint crashpoints[] = {
76	CRASHPOINT("DIRECT",		 NULL),
77#ifdef CONFIG_KPROBES
78	CRASHPOINT("INT_HARDWARE_ENTRY", "do_IRQ"),
79	CRASHPOINT("INT_HW_IRQ_EN",	 "handle_irq_event"),
80	CRASHPOINT("INT_TASKLET_ENTRY",	 "tasklet_action"),
81	CRASHPOINT("FS_DEVRW",		 "ll_rw_block"),
82	CRASHPOINT("MEM_SWAPOUT",	 "shrink_inactive_list"),
83	CRASHPOINT("TIMERADD",		 "hrtimer_start"),
84	CRASHPOINT("SCSI_QUEUE_RQ",	 "scsi_queue_rq"),
85	CRASHPOINT("IDE_CORE_CP",	 "generic_ide_ioctl"),
86#endif
87};
88
89
90/* Crash types. */
91struct crashtype {
92	const char *name;
93	void (*func)(void);
94};
95
96#define CRASHTYPE(_name)			\
97	{					\
98		.name = __stringify(_name),	\
99		.func = lkdtm_ ## _name,	\
100	}
101
102/* Define the possible types of crashes that can be triggered. */
103static const struct crashtype crashtypes[] = {
104	CRASHTYPE(PANIC),
105	CRASHTYPE(BUG),
106	CRASHTYPE(WARNING),
107	CRASHTYPE(WARNING_MESSAGE),
108	CRASHTYPE(EXCEPTION),
109	CRASHTYPE(LOOP),
110	CRASHTYPE(EXHAUST_STACK),
111	CRASHTYPE(CORRUPT_STACK),
112	CRASHTYPE(CORRUPT_STACK_STRONG),
113	CRASHTYPE(CORRUPT_LIST_ADD),
114	CRASHTYPE(CORRUPT_LIST_DEL),
115	CRASHTYPE(STACK_GUARD_PAGE_LEADING),
116	CRASHTYPE(STACK_GUARD_PAGE_TRAILING),
117	CRASHTYPE(UNSET_SMEP),
118	CRASHTYPE(CORRUPT_PAC),
119	CRASHTYPE(UNALIGNED_LOAD_STORE_WRITE),
120	CRASHTYPE(OVERWRITE_ALLOCATION),
121	CRASHTYPE(WRITE_AFTER_FREE),
122	CRASHTYPE(READ_AFTER_FREE),
123	CRASHTYPE(WRITE_BUDDY_AFTER_FREE),
124	CRASHTYPE(READ_BUDDY_AFTER_FREE),
125	CRASHTYPE(SLAB_FREE_DOUBLE),
126	CRASHTYPE(SLAB_FREE_CROSS),
127	CRASHTYPE(SLAB_FREE_PAGE),
128	CRASHTYPE(SOFTLOCKUP),
129	CRASHTYPE(HARDLOCKUP),
130	CRASHTYPE(SPINLOCKUP),
131	CRASHTYPE(HUNG_TASK),
132	CRASHTYPE(OVERFLOW_SIGNED),
133	CRASHTYPE(OVERFLOW_UNSIGNED),
134	CRASHTYPE(ARRAY_BOUNDS),
135	CRASHTYPE(EXEC_DATA),
136	CRASHTYPE(EXEC_STACK),
137	CRASHTYPE(EXEC_KMALLOC),
138	CRASHTYPE(EXEC_VMALLOC),
139	CRASHTYPE(EXEC_RODATA),
140	CRASHTYPE(EXEC_USERSPACE),
141	CRASHTYPE(EXEC_NULL),
142	CRASHTYPE(ACCESS_USERSPACE),
143	CRASHTYPE(ACCESS_NULL),
144	CRASHTYPE(WRITE_RO),
145	CRASHTYPE(WRITE_RO_AFTER_INIT),
146	CRASHTYPE(WRITE_KERN),
147	CRASHTYPE(REFCOUNT_INC_OVERFLOW),
148	CRASHTYPE(REFCOUNT_ADD_OVERFLOW),
149	CRASHTYPE(REFCOUNT_INC_NOT_ZERO_OVERFLOW),
150	CRASHTYPE(REFCOUNT_ADD_NOT_ZERO_OVERFLOW),
151	CRASHTYPE(REFCOUNT_DEC_ZERO),
152	CRASHTYPE(REFCOUNT_DEC_NEGATIVE),
153	CRASHTYPE(REFCOUNT_DEC_AND_TEST_NEGATIVE),
154	CRASHTYPE(REFCOUNT_SUB_AND_TEST_NEGATIVE),
155	CRASHTYPE(REFCOUNT_INC_ZERO),
156	CRASHTYPE(REFCOUNT_ADD_ZERO),
157	CRASHTYPE(REFCOUNT_INC_SATURATED),
158	CRASHTYPE(REFCOUNT_DEC_SATURATED),
159	CRASHTYPE(REFCOUNT_ADD_SATURATED),
160	CRASHTYPE(REFCOUNT_INC_NOT_ZERO_SATURATED),
161	CRASHTYPE(REFCOUNT_ADD_NOT_ZERO_SATURATED),
162	CRASHTYPE(REFCOUNT_DEC_AND_TEST_SATURATED),
163	CRASHTYPE(REFCOUNT_SUB_AND_TEST_SATURATED),
164	CRASHTYPE(REFCOUNT_TIMING),
165	CRASHTYPE(ATOMIC_TIMING),
166	CRASHTYPE(USERCOPY_HEAP_SIZE_TO),
167	CRASHTYPE(USERCOPY_HEAP_SIZE_FROM),
168	CRASHTYPE(USERCOPY_HEAP_WHITELIST_TO),
169	CRASHTYPE(USERCOPY_HEAP_WHITELIST_FROM),
170	CRASHTYPE(USERCOPY_STACK_FRAME_TO),
171	CRASHTYPE(USERCOPY_STACK_FRAME_FROM),
172	CRASHTYPE(USERCOPY_STACK_BEYOND),
173	CRASHTYPE(USERCOPY_KERNEL),
174	CRASHTYPE(STACKLEAK_ERASING),
175	CRASHTYPE(CFI_FORWARD_PROTO),
176	CRASHTYPE(DOUBLE_FAULT),
177};
178
179
180/* Global kprobe entry and crashtype. */
181static struct kprobe *lkdtm_kprobe;
182static struct crashpoint *lkdtm_crashpoint;
183static const struct crashtype *lkdtm_crashtype;
184
185/* Module parameters */
186static int recur_count = -1;
187module_param(recur_count, int, 0644);
188MODULE_PARM_DESC(recur_count, " Recursion level for the stack overflow test");
189
190static char* cpoint_name;
191module_param(cpoint_name, charp, 0444);
192MODULE_PARM_DESC(cpoint_name, " Crash Point, where kernel is to be crashed");
193
194static char* cpoint_type;
195module_param(cpoint_type, charp, 0444);
196MODULE_PARM_DESC(cpoint_type, " Crash Point Type, action to be taken on "\
197				"hitting the crash point");
198
199static int cpoint_count = DEFAULT_COUNT;
200module_param(cpoint_count, int, 0644);
201MODULE_PARM_DESC(cpoint_count, " Crash Point Count, number of times the "\
202				"crash point is to be hit to trigger action");
203
204
205/* Return the crashtype number or NULL if the name is invalid */
206static const struct crashtype *find_crashtype(const char *name)
207{
208	int i;
209
210	for (i = 0; i < ARRAY_SIZE(crashtypes); i++) {
211		if (!strcmp(name, crashtypes[i].name))
212			return &crashtypes[i];
213	}
214
215	return NULL;
216}
217
218/*
219 * This is forced noinline just so it distinctly shows up in the stackdump
220 * which makes validation of expected lkdtm crashes easier.
221 */
222static noinline void lkdtm_do_action(const struct crashtype *crashtype)
223{
224	if (WARN_ON(!crashtype || !crashtype->func))
225		return;
226	crashtype->func();
227}
228
229static int lkdtm_register_cpoint(struct crashpoint *crashpoint,
230				 const struct crashtype *crashtype)
231{
232	int ret;
233
234	/* If this doesn't have a symbol, just call immediately. */
235	if (!crashpoint->kprobe.symbol_name) {
236		lkdtm_do_action(crashtype);
237		return 0;
238	}
239
240	if (lkdtm_kprobe != NULL)
241		unregister_kprobe(lkdtm_kprobe);
242
243	lkdtm_crashpoint = crashpoint;
244	lkdtm_crashtype = crashtype;
245	lkdtm_kprobe = &crashpoint->kprobe;
246	ret = register_kprobe(lkdtm_kprobe);
247	if (ret < 0) {
248		pr_info("Couldn't register kprobe %s\n",
249			crashpoint->kprobe.symbol_name);
250		lkdtm_kprobe = NULL;
251		lkdtm_crashpoint = NULL;
252		lkdtm_crashtype = NULL;
253	}
254
255	return ret;
256}
257
258#ifdef CONFIG_KPROBES
259/* Global crash counter and spinlock. */
260static int crash_count = DEFAULT_COUNT;
261static DEFINE_SPINLOCK(crash_count_lock);
262
263/* Called by kprobe entry points. */
264static int lkdtm_kprobe_handler(struct kprobe *kp, struct pt_regs *regs)
265{
266	unsigned long flags;
267	bool do_it = false;
268
269	if (WARN_ON(!lkdtm_crashpoint || !lkdtm_crashtype))
270		return 0;
271
272	spin_lock_irqsave(&crash_count_lock, flags);
273	crash_count--;
274	pr_info("Crash point %s of type %s hit, trigger in %d rounds\n",
275		lkdtm_crashpoint->name, lkdtm_crashtype->name, crash_count);
276
277	if (crash_count == 0) {
278		do_it = true;
279		crash_count = cpoint_count;
280	}
281	spin_unlock_irqrestore(&crash_count_lock, flags);
282
283	if (do_it)
284		lkdtm_do_action(lkdtm_crashtype);
285
286	return 0;
287}
288
289static ssize_t lkdtm_debugfs_entry(struct file *f,
290				   const char __user *user_buf,
291				   size_t count, loff_t *off)
292{
293	struct crashpoint *crashpoint = file_inode(f)->i_private;
294	const struct crashtype *crashtype = NULL;
295	char *buf;
296	int err;
297
298	if (count >= PAGE_SIZE)
299		return -EINVAL;
300
301	buf = (char *)__get_free_page(GFP_KERNEL);
302	if (!buf)
303		return -ENOMEM;
304	if (copy_from_user(buf, user_buf, count)) {
305		free_page((unsigned long) buf);
306		return -EFAULT;
307	}
308	/* NULL-terminate and remove enter */
309	buf[count] = '\0';
310	strim(buf);
311
312	crashtype = find_crashtype(buf);
313	free_page((unsigned long)buf);
314
315	if (!crashtype)
316		return -EINVAL;
317
318	err = lkdtm_register_cpoint(crashpoint, crashtype);
319	if (err < 0)
320		return err;
321
322	*off += count;
323
324	return count;
325}
326#endif
327
328/* Generic read callback that just prints out the available crash types */
329static ssize_t lkdtm_debugfs_read(struct file *f, char __user *user_buf,
330		size_t count, loff_t *off)
331{
332	char *buf;
333	int i, n, out;
334
335	buf = (char *)__get_free_page(GFP_KERNEL);
336	if (buf == NULL)
337		return -ENOMEM;
338
339	n = scnprintf(buf, PAGE_SIZE, "Available crash types:\n");
340	for (i = 0; i < ARRAY_SIZE(crashtypes); i++) {
341		n += scnprintf(buf + n, PAGE_SIZE - n, "%s\n",
342			      crashtypes[i].name);
343	}
344	buf[n] = '\0';
345
346	out = simple_read_from_buffer(user_buf, count, off,
347				      buf, n);
348	free_page((unsigned long) buf);
349
350	return out;
351}
352
353static int lkdtm_debugfs_open(struct inode *inode, struct file *file)
354{
355	return 0;
356}
357
358/* Special entry to just crash directly. Available without KPROBEs */
359static ssize_t direct_entry(struct file *f, const char __user *user_buf,
360		size_t count, loff_t *off)
361{
362	const struct crashtype *crashtype;
363	char *buf;
364
365	if (count >= PAGE_SIZE)
366		return -EINVAL;
367	if (count < 1)
368		return -EINVAL;
369
370	buf = (char *)__get_free_page(GFP_KERNEL);
371	if (!buf)
372		return -ENOMEM;
373	if (copy_from_user(buf, user_buf, count)) {
374		free_page((unsigned long) buf);
375		return -EFAULT;
376	}
377	/* NULL-terminate and remove enter */
378	buf[count] = '\0';
379	strim(buf);
380
381	crashtype = find_crashtype(buf);
382	free_page((unsigned long) buf);
383	if (!crashtype)
384		return -EINVAL;
385
386	pr_info("Performing direct entry %s\n", crashtype->name);
387	lkdtm_do_action(crashtype);
388	*off += count;
389
390	return count;
391}
392
393static struct dentry *lkdtm_debugfs_root;
394
395static int __init lkdtm_module_init(void)
396{
397	struct crashpoint *crashpoint = NULL;
398	const struct crashtype *crashtype = NULL;
399	int ret;
400	int i;
401
402	/* Neither or both of these need to be set */
403	if ((cpoint_type || cpoint_name) && !(cpoint_type && cpoint_name)) {
404		pr_err("Need both cpoint_type and cpoint_name or neither\n");
405		return -EINVAL;
406	}
407
408	if (cpoint_type) {
409		crashtype = find_crashtype(cpoint_type);
410		if (!crashtype) {
411			pr_err("Unknown crashtype '%s'\n", cpoint_type);
412			return -EINVAL;
413		}
414	}
415
416	if (cpoint_name) {
417		for (i = 0; i < ARRAY_SIZE(crashpoints); i++) {
418			if (!strcmp(cpoint_name, crashpoints[i].name))
419				crashpoint = &crashpoints[i];
420		}
421
422		/* Refuse unknown crashpoints. */
423		if (!crashpoint) {
424			pr_err("Invalid crashpoint %s\n", cpoint_name);
425			return -EINVAL;
426		}
427	}
428
429#ifdef CONFIG_KPROBES
430	/* Set crash count. */
431	crash_count = cpoint_count;
432#endif
433
434	/* Handle test-specific initialization. */
435	lkdtm_bugs_init(&recur_count);
436	lkdtm_perms_init();
437	lkdtm_usercopy_init();
438	lkdtm_heap_init();
439
440	/* Register debugfs interface */
441	lkdtm_debugfs_root = debugfs_create_dir("provoke-crash", NULL);
442
443	/* Install debugfs trigger files. */
444	for (i = 0; i < ARRAY_SIZE(crashpoints); i++) {
445		struct crashpoint *cur = &crashpoints[i];
446
447		debugfs_create_file(cur->name, 0644, lkdtm_debugfs_root, cur,
448				    &cur->fops);
449	}
450
451	/* Install crashpoint if one was selected. */
452	if (crashpoint) {
453		ret = lkdtm_register_cpoint(crashpoint, crashtype);
454		if (ret < 0) {
455			pr_info("Invalid crashpoint %s\n", crashpoint->name);
456			goto out_err;
457		}
458		pr_info("Crash point %s of type %s registered\n",
459			crashpoint->name, cpoint_type);
460	} else {
461		pr_info("No crash points registered, enable through debugfs\n");
462	}
463
464	return 0;
465
466out_err:
467	debugfs_remove_recursive(lkdtm_debugfs_root);
468	return ret;
469}
470
471static void __exit lkdtm_module_exit(void)
472{
473	debugfs_remove_recursive(lkdtm_debugfs_root);
474
475	/* Handle test-specific clean-up. */
476	lkdtm_heap_exit();
477	lkdtm_usercopy_exit();
478
479	if (lkdtm_kprobe != NULL)
480		unregister_kprobe(lkdtm_kprobe);
481
482	pr_info("Crash point unregistered\n");
483}
484
485module_init(lkdtm_module_init);
486module_exit(lkdtm_module_exit);
487
488MODULE_LICENSE("GPL");
489MODULE_DESCRIPTION("Kernel crash testing module");
490