[linux.git] / kernel / test_kprobes.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * test_kprobes.c - simple sanity test for *probes
 *
 * Copyright IBM Corp. 2008
 */

#define pr_fmt(fmt) "Kprobe smoke test: " fmt

#include <linux/kernel.h>
#include <linux/kprobes.h>
#include <linux/random.h>

#define div_factor 3

static u32 rand1, preh_val, posth_val;
static int errors, handler_errors, num_tests;
static u32 (*target)(u32 value);
static u32 (*target2)(u32 value);

static noinline u32 kprobe_target(u32 value)
{
	return (value / div_factor);
}

static int kp_pre_handler(struct kprobe *p, struct pt_regs *regs)
{
	if (preemptible()) {
		handler_errors++;
		pr_err("pre-handler is preemptible\n");
	}
	preh_val = (rand1 / div_factor);
	return 0;
}

static void kp_post_handler(struct kprobe *p, struct pt_regs *regs,
		unsigned long flags)
{
	if (preemptible()) {
		handler_errors++;
		pr_err("post-handler is preemptible\n");
	}
	if (preh_val != (rand1 / div_factor)) {
		handler_errors++;
		pr_err("incorrect value in post_handler\n");
	}
	posth_val = preh_val + div_factor;
}

static struct kprobe kp = {
	.symbol_name = "kprobe_target",
	.pre_handler = kp_pre_handler,
	.post_handler = kp_post_handler
};

static int test_kprobe(void)
{
	int ret;

	ret = register_kprobe(&kp);
	if (ret < 0) {
		pr_err("register_kprobe returned %d\n", ret);
		return ret;
	}

	ret = target(rand1);
	unregister_kprobe(&kp);

	if (preh_val == 0) {
		pr_err("kprobe pre_handler not called\n");
		handler_errors++;
	}

	if (posth_val == 0) {
		pr_err("kprobe post_handler not called\n");
		handler_errors++;
	}

	return 0;
}

static noinline u32 kprobe_target2(u32 value)
{
	return (value / div_factor) + 1;
}

static int kp_pre_handler2(struct kprobe *p, struct pt_regs *regs)
{
	preh_val = (rand1 / div_factor) + 1;
	return 0;
}

static void kp_post_handler2(struct kprobe *p, struct pt_regs *regs,
		unsigned long flags)
{
	if (preh_val != (rand1 / div_factor) + 1) {
		handler_errors++;
		pr_err("incorrect value in post_handler2\n");
	}
	posth_val = preh_val + div_factor;
}

static struct kprobe kp2 = {
	.symbol_name = "kprobe_target2",
	.pre_handler = kp_pre_handler2,
	.post_handler = kp_post_handler2
};

static int test_kprobes(void)
{
	int ret;
	struct kprobe *kps[2] = {&kp, &kp2};

	/* addr and flags should be cleard for reusing kprobe. */
	kp.addr = NULL;
	kp.flags = 0;
	ret = register_kprobes(kps, 2);
	if (ret < 0) {
		pr_err("register_kprobes returned %d\n", ret);
		return ret;
	}

	preh_val = 0;
	posth_val = 0;
	ret = target(rand1);

	if (preh_val == 0) {
		pr_err("kprobe pre_handler not called\n");
		handler_errors++;
	}

	if (posth_val == 0) {
		pr_err("kprobe post_handler not called\n");
		handler_errors++;
	}

	preh_val = 0;
	posth_val = 0;
	ret = target2(rand1);

	if (preh_val == 0) {
		pr_err("kprobe pre_handler2 not called\n");
		handler_errors++;
	}

	if (posth_val == 0) {
		pr_err("kprobe post_handler2 not called\n");
		handler_errors++;
	}

	unregister_kprobes(kps, 2);
	return 0;

}

#ifdef CONFIG_KRETPROBES
static u32 krph_val;

static int entry_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	if (preemptible()) {
		handler_errors++;
		pr_err("kretprobe entry handler is preemptible\n");
	}
	krph_val = (rand1 / div_factor);
	return 0;
}

static int return_handler(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	unsigned long ret = regs_return_value(regs);

	if (preemptible()) {
		handler_errors++;
		pr_err("kretprobe return handler is preemptible\n");
	}
	if (ret != (rand1 / div_factor)) {
		handler_errors++;
		pr_err("incorrect value in kretprobe handler\n");
	}
	if (krph_val == 0) {
		handler_errors++;
		pr_err("call to kretprobe entry handler failed\n");
	}

	krph_val = rand1;
	return 0;
}

static struct kretprobe rp = {
	.handler	= return_handler,
	.entry_handler  = entry_handler,
	.kp.symbol_name = "kprobe_target"
};

static int test_kretprobe(void)
{
	int ret;

	ret = register_kretprobe(&rp);
	if (ret < 0) {
		pr_err("register_kretprobe returned %d\n", ret);
		return ret;
	}

	ret = target(rand1);
	unregister_kretprobe(&rp);
	if (krph_val != rand1) {
		pr_err("kretprobe handler not called\n");
		handler_errors++;
	}

	return 0;
}

static int return_handler2(struct kretprobe_instance *ri, struct pt_regs *regs)
{
	unsigned long ret = regs_return_value(regs);

	if (ret != (rand1 / div_factor) + 1) {
		handler_errors++;
		pr_err("incorrect value in kretprobe handler2\n");
	}
	if (krph_val == 0) {
		handler_errors++;
		pr_err("call to kretprobe entry handler failed\n");
	}

	krph_val = rand1;
	return 0;
}

static struct kretprobe rp2 = {
	.handler	= return_handler2,
	.entry_handler  = entry_handler,
	.kp.symbol_name = "kprobe_target2"
};

static int test_kretprobes(void)
{
	int ret;
	struct kretprobe *rps[2] = {&rp, &rp2};

	/* addr and flags should be cleard for reusing kprobe. */
	rp.kp.addr = NULL;
	rp.kp.flags = 0;
	ret = register_kretprobes(rps, 2);
	if (ret < 0) {
		pr_err("register_kretprobe returned %d\n", ret);
		return ret;
	}

	krph_val = 0;
	ret = target(rand1);
	if (krph_val != rand1) {
		pr_err("kretprobe handler not called\n");
		handler_errors++;
	}

	krph_val = 0;
	ret = target2(rand1);
	if (krph_val != rand1) {
		pr_err("kretprobe handler2 not called\n");
		handler_errors++;
	}
	unregister_kretprobes(rps, 2);
	return 0;
}
#endif /* CONFIG_KRETPROBES */

int init_test_probes(void)
{
	int ret;

	target = kprobe_target;
	target2 = kprobe_target2;

	do {
		rand1 = prandom_u32();
	} while (rand1 <= div_factor);

	pr_info("started\n");
	num_tests++;
	ret = test_kprobe();
	if (ret < 0)
		errors++;

	num_tests++;
	ret = test_kprobes();
	if (ret < 0)
		errors++;

#ifdef CONFIG_KRETPROBES
	num_tests++;
	ret = test_kretprobe();
	if (ret < 0)
		errors++;

	num_tests++;
	ret = test_kretprobes();
	if (ret < 0)
		errors++;
#endif /* CONFIG_KRETPROBES */

	if (errors)
		pr_err("BUG: %d out of %d tests failed\n", errors, num_tests);
	else if (handler_errors)
		pr_err("BUG: %d error(s) running handlers\n", handler_errors);
	else
		pr_info("passed successfully\n");

	return 0;
}
Commit	Line	Data
7170066e	1	// SPDX-License-Identifier: GPL-2.0-or-later
8c1c9356 AM	2	/*
	3	* test_kprobes.c - simple sanity test for *probes
	4	*
	5	* Copyright IBM Corp. 2008
8c1c9356 AM	6	*/
8c1c9356 AM	7
4878b14b FF	8	#define pr_fmt(fmt) "Kprobe smoke test: " fmt
4878b14b FF	9
8c1c9356 AM	10	#include <linux/kernel.h>
	11	#include <linux/kprobes.h>
	12	#include <linux/random.h>
	13
	14	#define div_factor 3
	15
2c7d662e	16	static u32 rand1, preh_val, posth_val;
8c1c9356	17	static int errors, handler_errors, num_tests;
8e114405	18	static u32 (*target)(u32 value);
12da3b88	19	static u32 (*target2)(u32 value);
8c1c9356 AM	20
	21	static noinline u32 kprobe_target(u32 value)
	22	{
8c1c9356 AM	23	return (value / div_factor);
	24	}
	25
	26	static int kp_pre_handler(struct kprobe p, struct pt_regs regs)
	27	{
3539d091 MH	28	if (preemptible()) {
	29	handler_errors++;
	30	pr_err("pre-handler is preemptible\n");
	31	}
8c1c9356 AM	32	preh_val = (rand1 / div_factor);
	33	return 0;
	34	}
	35
	36	static void kp_post_handler(struct kprobe p, struct pt_regs regs,
	37	unsigned long flags)
	38	{
3539d091 MH	39	if (preemptible()) {
	40	handler_errors++;
	41	pr_err("post-handler is preemptible\n");
	42	}
8c1c9356 AM	43	if (preh_val != (rand1 / div_factor)) {
8c1c9356 AM	44	handler_errors++;
4878b14b	45	pr_err("incorrect value in post_handler\n");
8c1c9356 AM	46	}
	47	posth_val = preh_val + div_factor;
	48	}
	49
	50	static struct kprobe kp = {
	51	.symbol_name = "kprobe_target",
	52	.pre_handler = kp_pre_handler,
	53	.post_handler = kp_post_handler
	54	};
	55
	56	static int test_kprobe(void)
	57	{
	58	int ret;
	59
	60	ret = register_kprobe(&kp);
	61	if (ret < 0) {
4878b14b	62	pr_err("register_kprobe returned %d\n", ret);
8c1c9356 AM	63	return ret;
	64	}
	65
8e114405	66	ret = target(rand1);
8c1c9356 AM	67	unregister_kprobe(&kp);
	68
	69	if (preh_val == 0) {
4878b14b	70	pr_err("kprobe pre_handler not called\n");
8c1c9356 AM	71	handler_errors++;
	72	}
	73
	74	if (posth_val == 0) {
4878b14b	75	pr_err("kprobe post_handler not called\n");
8c1c9356 AM	76	handler_errors++;
	77	}
	78
	79	return 0;
	80	}
	81
12da3b88 MH	82	static noinline u32 kprobe_target2(u32 value)
	83	{
	84	return (value / div_factor) + 1;
	85	}
	86
	87	static int kp_pre_handler2(struct kprobe p, struct pt_regs regs)
	88	{
	89	preh_val = (rand1 / div_factor) + 1;
	90	return 0;
	91	}
	92
	93	static void kp_post_handler2(struct kprobe p, struct pt_regs regs,
	94	unsigned long flags)
	95	{
	96	if (preh_val != (rand1 / div_factor) + 1) {
	97	handler_errors++;
4878b14b	98	pr_err("incorrect value in post_handler2\n");
12da3b88 MH	99	}
	100	posth_val = preh_val + div_factor;
	101	}
	102
	103	static struct kprobe kp2 = {
	104	.symbol_name = "kprobe_target2",
	105	.pre_handler = kp_pre_handler2,
	106	.post_handler = kp_post_handler2
	107	};
	108
	109	static int test_kprobes(void)
	110	{
	111	int ret;
	112	struct kprobe *kps[2] = {&kp, &kp2};
	113
fd02e6f7 MH	114	/* addr and flags should be cleard for reusing kprobe. */
	115	kp.addr = NULL;
	116	kp.flags = 0;
12da3b88 MH	117	ret = register_kprobes(kps, 2);
12da3b88 MH	118	if (ret < 0) {
4878b14b	119	pr_err("register_kprobes returned %d\n", ret);
12da3b88 MH	120	return ret;
	121	}
	122
	123	preh_val = 0;
	124	posth_val = 0;
	125	ret = target(rand1);
	126
	127	if (preh_val == 0) {
4878b14b	128	pr_err("kprobe pre_handler not called\n");
12da3b88 MH	129	handler_errors++;
	130	}
	131
	132	if (posth_val == 0) {
4878b14b	133	pr_err("kprobe post_handler not called\n");
12da3b88 MH	134	handler_errors++;
	135	}
	136
	137	preh_val = 0;
	138	posth_val = 0;
	139	ret = target2(rand1);
	140
	141	if (preh_val == 0) {
4878b14b	142	pr_err("kprobe pre_handler2 not called\n");
12da3b88 MH	143	handler_errors++;
	144	}
	145
	146	if (posth_val == 0) {
4878b14b	147	pr_err("kprobe post_handler2 not called\n");
12da3b88 MH	148	handler_errors++;
	149	}
	150
	151	unregister_kprobes(kps, 2);
	152	return 0;
	153
	154	}
	155
8c1c9356 AM	156	#ifdef CONFIG_KRETPROBES
	157	static u32 krph_val;
	158
f47cd9b5 AS	159	static int entry_handler(struct kretprobe_instance ri, struct pt_regs regs)
f47cd9b5 AS	160	{
3539d091 MH	161	if (preemptible()) {
	162	handler_errors++;
	163	pr_err("kretprobe entry handler is preemptible\n");
	164	}
f47cd9b5 AS	165	krph_val = (rand1 / div_factor);
	166	return 0;
	167	}
	168
8c1c9356 AM	169	static int return_handler(struct kretprobe_instance ri, struct pt_regs regs)
	170	{
	171	unsigned long ret = regs_return_value(regs);
	172
3539d091 MH	173	if (preemptible()) {
	174	handler_errors++;
	175	pr_err("kretprobe return handler is preemptible\n");
	176	}
8c1c9356 AM	177	if (ret != (rand1 / div_factor)) {
8c1c9356 AM	178	handler_errors++;
4878b14b	179	pr_err("incorrect value in kretprobe handler\n");
8c1c9356	180	}
f47cd9b5 AS	181	if (krph_val == 0) {
f47cd9b5 AS	182	handler_errors++;
4878b14b	183	pr_err("call to kretprobe entry handler failed\n");
f47cd9b5	184	}
8c1c9356	185
f47cd9b5	186	krph_val = rand1;
8c1c9356 AM	187	return 0;
	188	}
	189
	190	static struct kretprobe rp = {
	191	.handler = return_handler,
f47cd9b5	192	.entry_handler = entry_handler,
8c1c9356 AM	193	.kp.symbol_name = "kprobe_target"
	194	};
	195
	196	static int test_kretprobe(void)
	197	{
	198	int ret;
	199
	200	ret = register_kretprobe(&rp);
	201	if (ret < 0) {
4878b14b	202	pr_err("register_kretprobe returned %d\n", ret);
8c1c9356 AM	203	return ret;
	204	}
	205
8e114405	206	ret = target(rand1);
8c1c9356	207	unregister_kretprobe(&rp);
f47cd9b5	208	if (krph_val != rand1) {
4878b14b	209	pr_err("kretprobe handler not called\n");
8c1c9356 AM	210	handler_errors++;
	211	}
	212
	213	return 0;
	214	}
12da3b88 MH	215
	216	static int return_handler2(struct kretprobe_instance ri, struct pt_regs regs)
	217	{
	218	unsigned long ret = regs_return_value(regs);
	219
	220	if (ret != (rand1 / div_factor) + 1) {
	221	handler_errors++;
4878b14b	222	pr_err("incorrect value in kretprobe handler2\n");
12da3b88 MH	223	}
	224	if (krph_val == 0) {
	225	handler_errors++;
4878b14b	226	pr_err("call to kretprobe entry handler failed\n");
12da3b88 MH	227	}
	228
	229	krph_val = rand1;
	230	return 0;
	231	}
	232
	233	static struct kretprobe rp2 = {
	234	.handler = return_handler2,
	235	.entry_handler = entry_handler,
	236	.kp.symbol_name = "kprobe_target2"
	237	};
	238
	239	static int test_kretprobes(void)
	240	{
	241	int ret;
	242	struct kretprobe *rps[2] = {&rp, &rp2};
	243
fd02e6f7 MH	244	/* addr and flags should be cleard for reusing kprobe. */
	245	rp.kp.addr = NULL;
	246	rp.kp.flags = 0;
12da3b88 MH	247	ret = register_kretprobes(rps, 2);
12da3b88 MH	248	if (ret < 0) {
4878b14b	249	pr_err("register_kretprobe returned %d\n", ret);
12da3b88 MH	250	return ret;
	251	}
	252
	253	krph_val = 0;
	254	ret = target(rand1);
	255	if (krph_val != rand1) {
4878b14b	256	pr_err("kretprobe handler not called\n");
12da3b88 MH	257	handler_errors++;
	258	}
	259
	260	krph_val = 0;
	261	ret = target2(rand1);
	262	if (krph_val != rand1) {
4878b14b	263	pr_err("kretprobe handler2 not called\n");
12da3b88 MH	264	handler_errors++;
	265	}
	266	unregister_kretprobes(rps, 2);
	267	return 0;
	268	}
8c1c9356 AM	269	#endif /* CONFIG_KRETPROBES */
	270
	271	int init_test_probes(void)
	272	{
	273	int ret;
	274
8e114405	275	target = kprobe_target;
12da3b88	276	target2 = kprobe_target2;
8e114405	277
8c1c9356	278	do {
6d65df33	279	rand1 = prandom_u32();
8c1c9356 AM	280	} while (rand1 <= div_factor);
8c1c9356 AM	281
4878b14b	282	pr_info("started\n");
8c1c9356 AM	283	num_tests++;
	284	ret = test_kprobe();
	285	if (ret < 0)
	286	errors++;
	287
12da3b88 MH	288	num_tests++;
	289	ret = test_kprobes();
	290	if (ret < 0)
	291	errors++;
	292
8c1c9356 AM	293	#ifdef CONFIG_KRETPROBES
	294	num_tests++;
	295	ret = test_kretprobe();
	296	if (ret < 0)
	297	errors++;
12da3b88 MH	298
	299	num_tests++;
	300	ret = test_kretprobes();
	301	if (ret < 0)
	302	errors++;
8c1c9356 AM	303	#endif /* CONFIG_KRETPROBES */
	304
	305	if (errors)
4878b14b	306	pr_err("BUG: %d out of %d tests failed\n", errors, num_tests);
8c1c9356	307	else if (handler_errors)
4878b14b	308	pr_err("BUG: %d error(s) running handlers\n", handler_errors);
8c1c9356	309	else
4878b14b	310	pr_info("passed successfully\n");
8c1c9356 AM	311
	312	return 0;
	313	}