Release 4.15 kernel/test_kprobes.c

Directory: kernel
/*
 * test_kprobes.c - simple sanity test for *probes
 *
 * Copyright IBM Corp. 2008
 *
 * This program is free software;  you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it would be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
 * the GNU General Public License for more details.
 */


#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);
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 27 64.29% 1 50.00%
Masami Hiramatsu 15 35.71% 1 50.00%
Total 42 100.00% 2 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 45 73.77% 1 33.33%
Masami Hiramatsu 15 24.59% 1 33.33%
Fabian Frederick 1 1.64% 1 33.33%
Total 61 100.00% 3 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 57 67.06% 1 25.00%
Masami Hiramatsu 25 29.41% 2 50.00%
Fabian Frederick 3 3.53% 1 25.00%
Total 85 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 19 100.00% 1 100.00%
Total 19 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 47 97.92% 1 50.00%
Fabian Frederick 1 2.08% 1 50.00%
Total 48 100.00% 2 100.00%


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;

}

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 166 97.08% 2 66.67%
Fabian Frederick 5 2.92% 1 33.33%
Total 171 100.00% 3 100.00%

#if 0
static u32 jph_val;

static u32 j_kprobe_target(u32 value)
{
        if (preemptible()) {
                handler_errors++;
                pr_err("jprobe-handler is preemptible\n");
        }
        if (value != rand1) {
                handler_errors++;
                pr_err("incorrect value in jprobe handler\n");
        }

        jph_val = rand1;
        jprobe_return();
        return 0;
}

static struct jprobe jp = {
        .entry          = j_kprobe_target,
        .kp.symbol_name = "kprobe_target"
};

static int test_jprobe(void)
{
        int ret;

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

        ret = target(rand1);
        unregister_jprobe(&jp);
        if (jph_val == 0) {
                pr_err("jprobe handler not called\n");
                handler_errors++;
        }

        return 0;
}

static struct jprobe jp2 = {
        .entry          = j_kprobe_target,
        .kp.symbol_name = "kprobe_target2"
};

static int test_jprobes(void)
{
        int ret;
        struct jprobe *jps[2] = {&jp, &jp2};

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

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

        jph_val = 0;
        ret = target2(rand1);
        if (jph_val == 0) {
                pr_err("jprobe handler2 not called\n");
                handler_errors++;
        }
        unregister_jprobes(jps, 2);

        return 0;
}
#else

#define test_jprobe() (0)

#define test_jprobes() (0)
#endif
#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;
}

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 42 100.00% 2 100.00%
Total 42 100.00% 2 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 55 66.27% 2 50.00%
Ananth N. Mavinakayanahalli 26 31.33% 1 25.00%
Fabian Frederick 2 2.41% 1 25.00%
Total 83 100.00% 4 100.00%


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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 56 81.16% 1 25.00%
Masami Hiramatsu 11 15.94% 2 50.00%
Fabian Frederick 2 2.90% 1 25.00%
Total 69 100.00% 4 100.00%



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;
}

Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 49 70.00% 1 25.00%
Abhishek Sagar 15 21.43% 1 25.00%
Masami Hiramatsu 4 5.71% 1 25.00%
Fabian Frederick 2 2.86% 1 25.00%
Total 70 100.00% 4 100.00%


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;
}
Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 74 54.81% 3 50.00%
Ananth N. Mavinakayanahalli 56 41.48% 1 16.67%
Fabian Frederick 3 2.22% 1 16.67%
Abhishek Sagar 2 1.48% 1 16.67%
Total 135 100.00% 6 100.00%

#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++;

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

	num_tests++;
	ret = test_jprobes();
	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;
}
Contributors
Person Tokens Prop Commits CommitProp
Ananth N. Mavinakayanahalli 112 62.22% 1 20.00%
Masami Hiramatsu 59 32.78% 2 40.00%
Fabian Frederick 8 4.44% 1 20.00%
Akinobu Mita 1 0.56% 1 20.00%
Total 180 100.00% 5 100.00%

Overall Contributors
Person Tokens Prop Commits CommitProp
Masami Hiramatsu 644 52.27% 5 55.56%
Ananth N. Mavinakayanahalli 531 43.10% 1 11.11%
Fabian Frederick 34 2.76% 1 11.11%
Abhishek Sagar 22 1.79% 1 11.11%
Akinobu Mita 1 0.08% 1 11.11%
Total 1232 100.00% 9 100.00%
Directory: kernel

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Ananth N. Mavinakayanahalli	17	100.00%	1	100.00%
Total	17	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.15 kernel/test_kprobes.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
