lib/test_fprobe: add testcase for mixed fprobe

Add the testcase for the fprobe, which will hook the same target with two
fprobe: entry, entry+exit. And the two fprobes will be registered with
different order.

fgraph and ftrace are both used for the fprobe, and this testcase is for
the mixed situation.

Link: https://lore.kernel.org/all/20251015083238.2374294-3-dongml2@chinatelecom.cn/
Signed-off-by: Menglong Dong <dongml2@chinatelecom.cn>
Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>

diff --git a/lib/tests/test_fprobe.c b/lib/tests/test_fprobe.c
index cf92111b5c79de795fa659d1912e009eaaefa6d0..108c7aa33cb452933b9a1cedea1175bdb81af4e1 100644 (file)
--- a/lib/tests/test_fprobe.c
+++ b/lib/tests/test_fprobe.c
@@ -12,7 +12,8 @@
 
 static struct kunit *current_test;
 
-static u32 rand1, entry_val, exit_val;
+static u32 rand1, entry_only_val, entry_val, exit_val;
+static u32 entry_only_count, entry_count, exit_count;
 
 /* Use indirect calls to avoid inlining the target functions */
 static u32 (*target)(u32 value);
@@ -190,6 +191,101 @@ static void test_fprobe_skip(struct kunit *test)
        KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp));
 }
 
+/* Handler for fprobe entry only case */
+static notrace int entry_only_handler(struct fprobe *fp, unsigned long ip,
+                                     unsigned long ret_ip,
+                                     struct ftrace_regs *fregs, void *data)
+{
+       KUNIT_EXPECT_FALSE(current_test, preemptible());
+       KUNIT_EXPECT_EQ(current_test, ip, target_ip);
+
+       entry_only_count++;
+       entry_only_val = (rand1 / div_factor);
+
+       return 0;
+}
+
+static notrace int fprobe_entry_multi_handler(struct fprobe *fp, unsigned long ip,
+                                             unsigned long ret_ip,
+                                             struct ftrace_regs *fregs,
+                                             void *data)
+{
+       KUNIT_EXPECT_FALSE(current_test, preemptible());
+       KUNIT_EXPECT_EQ(current_test, ip, target_ip);
+
+       entry_count++;
+       entry_val = (rand1 / div_factor);
+
+       return 0;
+}
+
+static notrace void fprobe_exit_multi_handler(struct fprobe *fp, unsigned long ip,
+                                             unsigned long ret_ip,
+                                             struct ftrace_regs *fregs,
+                                             void *data)
+{
+       unsigned long ret = ftrace_regs_get_return_value(fregs);
+
+       KUNIT_EXPECT_FALSE(current_test, preemptible());
+       KUNIT_EXPECT_EQ(current_test, ip, target_ip);
+       KUNIT_EXPECT_EQ(current_test, ret, (rand1 / div_factor));
+
+       exit_count++;
+       exit_val = ret;
+}
+
+static void check_fprobe_multi(struct kunit *test)
+{
+       entry_only_count = entry_count = exit_count = 0;
+       entry_only_val = entry_val = exit_val = 0;
+
+       target(rand1);
+
+       /* Verify all handlers were called */
+       KUNIT_EXPECT_EQ(test, 1, entry_only_count);
+       KUNIT_EXPECT_EQ(test, 1, entry_count);
+       KUNIT_EXPECT_EQ(test, 1, exit_count);
+
+       /* Verify values are correct */
+       KUNIT_EXPECT_EQ(test, (rand1 / div_factor), entry_only_val);
+       KUNIT_EXPECT_EQ(test, (rand1 / div_factor), entry_val);
+       KUNIT_EXPECT_EQ(test, (rand1 / div_factor), exit_val);
+}
+
+/* Test multiple fprobes hooking the same target function */
+static void test_fprobe_multi(struct kunit *test)
+{
+       struct fprobe fp1 = {
+               .entry_handler = fprobe_entry_multi_handler,
+               .exit_handler = fprobe_exit_multi_handler,
+       };
+       struct fprobe fp2 = {
+               .entry_handler = entry_only_handler,
+       };
+
+       current_test = test;
+
+       /* Test Case 1: Register in order 1 -> 2 */
+       KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp1, "fprobe_selftest_target", NULL));
+       KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp2, "fprobe_selftest_target", NULL));
+
+       check_fprobe_multi(test);
+
+       /* Unregister all */
+       KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp1));
+       KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp2));
+
+       /* Test Case 2: Register in order 2 -> 1 */
+       KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp2, "fprobe_selftest_target", NULL));
+       KUNIT_EXPECT_EQ(test, 0, register_fprobe(&fp1, "fprobe_selftest_target", NULL));
+
+       check_fprobe_multi(test);
+
+       /* Unregister all */
+       KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp1));
+       KUNIT_EXPECT_EQ(test, 0, unregister_fprobe(&fp2));
+}
+
 static unsigned long get_ftrace_location(void *func)
 {
        unsigned long size, addr = (unsigned long)func;
@@ -217,6 +313,7 @@ static struct kunit_case fprobe_testcases[] = {
        KUNIT_CASE(test_fprobe_syms),
        KUNIT_CASE(test_fprobe_data),
        KUNIT_CASE(test_fprobe_skip),
+       KUNIT_CASE(test_fprobe_multi),
        {}
 };