new file mode 100644
@@ -0,0 +1,84 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _KUNIT_FTRACE_STUB_H
+#define _KUNIT_FTRACE_STUB_H
+
+/** KUNIT_STUBBABLE - marks a function as stubbable when stubbing support is
+ * enabled.
+ *
+ * Stubbing uses ftrace internally, so we can only stub out functions when they
+ * are not inlined. This macro evaluates to noinline when stubbing support is
+ * enabled to thus make it safe.
+ *
+ * If you cannot add this annotation to the function, you can instead use
+ * KUNIT_STUBBABLE_TRAMPOLINE, which is the same, but evaluates to
+ * __always_inline when stubbing is not enabled.
+ *
+ * Consider copy_to_user, which is marked as __always_inline:
+ *
+ * .. code-block:: c
+ * static KUNIT_STUBBABLE_TRAMPOLINE unsigned long
+ * copy_to_user_trampoline(void __user *to, const void *from, unsigned long n)
+ * {
+ * return copy_to_user(to, from, n);
+ * }
+ *
+ * Then we simply need to update our code to go through this function instead
+ * (in the places where we want to stub it out).
+ */
+#if IS_ENABLED(CONFIG_KUNIT_FTRACE_STUBS)
+#define KUNIT_STUBBABLE noinline
+#define KUNIT_STUBBABLE_TRAMPOLINE noinline
+#else
+#define KUNIT_STUBBABLE
+#define KUNIT_STUBBABLE_TRAMPOLINE __always_inline
+#endif
+
+struct kunit;
+
+/**
+ * kunit_activate_ftrace_stub() - makes all calls to @func go to @replacement during @test.
+ * @test: The test context object.
+ * @func: The function to stub out, must be annotated with KUNIT_STUBBABLE.
+ * @replacement: The function to replace @func with.
+ *
+ * All calls to @func will instead call @replacement for the duration of the
+ * current test. If called from outside the test's thread, the function will
+ * not be redirected.
+ *
+ * The redirection can be disabled again with kunit_deactivate_ftrace_stub().
+ *
+ * Example:
+ *
+ * .. code-block:: c
+ * KUNIT_STUBBABLE int real_func(int n)
+ * {
+ * pr_info("real_func() called with %d", n);
+ * return 0;
+ * }
+ *
+ * void replacement_func(int n)
+ * {
+ * pr_info("replacement_func() called with %d", n);
+ * return 42;
+ * }
+ *
+ * void example_test(struct kunit *test)
+ * {
+ * kunit_activate_ftrace_stub(test, real_func, replacement_func);
+ * KUNIT_EXPECT_EQ(test, real_func(1), 42);
+ * }
+ *
+ */
+#define kunit_activate_ftrace_stub(test, func, replacement) do { \
+ typecheck_fn(typeof(&func), replacement); \
+ __kunit_activate_ftrace_stub(test, #func, func, replacement); \
+} while (0)
+
+void __kunit_activate_ftrace_stub(struct kunit *test,
+ const char *name,
+ void *real_fn_addr,
+ void *replacement_addr);
+
+
+void kunit_deactivate_ftrace_stub(struct kunit *test, void *real_fn_addr);
+#endif /* _KUNIT_STUB_H */
@@ -36,6 +36,8 @@
#include <linux/rcupdate.h>
#include <linux/kprobes.h>
+#include <kunit/visibility.h>
+
#include <trace/events/sched.h>
#include <asm/sections.h>
@@ -1663,6 +1665,7 @@ unsigned long ftrace_location(unsigned long ip)
}
return loc;
}
+EXPORT_SYMBOL_IF_KUNIT(ftrace_location);
/**
* ftrace_text_reserved - return true if range contains an ftrace location
@@ -93,4 +93,15 @@ config KUNIT_AUTORUN_ENABLED
In most cases this should be left as Y. Only if additional opt-in
behavior is needed should this be set to N.
+config KUNIT_FTRACE_STUBS
+ bool "Support for stubbing out functions in KUnit tests with ftrace and kernel livepatch"
+ depends on FTRACE=y && FUNCTION_TRACER=y && MODULES=y && DEBUG_KERNEL=y && KALLSYMS_ALL=y && LIVEPATCH=y
+ help
+ Builds support for stubbing out functions for the duration of KUnit
+ test cases or suites using ftrace and kernel livepatch.
+ See KUNIT_EXAMPLE_TEST for an example.
+
+ NOTE: this does not work on all architectures (like UML, arm64) and
+ relies on a lot of magic (see the dependencies list).
+
endif # KUNIT
@@ -29,3 +29,7 @@ obj-$(CONFIG_KUNIT_TEST) += assert_test.o
endif
obj-$(CONFIG_KUNIT_EXAMPLE_TEST) += kunit-example-test.o
+
+ifeq ($(CONFIG_KUNIT_FTRACE_STUBS),y)
+kunit-objs += ftrace_stub.o
+endif
new file mode 100644
@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <kunit/test.h>
+#include <kunit/ftrace_stub.h>
+
+#include <linux/typecheck.h>
+
+#include <linux/ftrace.h>
+#include <linux/livepatch.h>
+#include <linux/sched.h>
+
+struct kunit_ftrace_stub_ctx {
+ struct kunit *test;
+ unsigned long real_fn_addr; /* used as a key to lookup the stub */
+ unsigned long replacement_addr;
+ struct ftrace_ops ops; /* a copy of kunit_stub_base_ops with .private set */
+};
+
+static void kunit_stub_trampoline(unsigned long ip, unsigned long parent_ip,
+ struct ftrace_ops *ops,
+ struct ftrace_regs *fregs)
+{
+ struct kunit_ftrace_stub_ctx *ctx = ops->private;
+ int lock_bit;
+
+ if (current->kunit_test != ctx->test)
+ return;
+
+ lock_bit = ftrace_test_recursion_trylock(ip, parent_ip);
+ KUNIT_ASSERT_GE(ctx->test, lock_bit, 0);
+
+ ftrace_regs_set_instruction_pointer(fregs, ctx->replacement_addr);
+
+ ftrace_test_recursion_unlock(lock_bit);
+}
+
+static struct ftrace_ops kunit_stub_base_ops = {
+ .func = &kunit_stub_trampoline,
+ .flags = FTRACE_OPS_FL_IPMODIFY |
+#ifndef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_ARGS
+ FTRACE_OPS_FL_SAVE_REGS |
+#endif
+ FTRACE_OPS_FL_DYNAMIC
+};
+
+static void __kunit_ftrace_stub_resource_free(struct kunit_resource *res)
+{
+ struct kunit_ftrace_stub_ctx *ctx = res->data;
+
+ unregister_ftrace_function(&ctx->ops);
+ kfree(ctx);
+}
+
+/* Matching function for kunit_find_resource(). match_data is real_fn_addr. */
+static bool __kunit_ftrace_stub_resource_match(struct kunit *test,
+ struct kunit_resource *res,
+ void *match_real_fn_addr)
+{
+ /* This pointer is only valid if res is a ftrace stub resource. */
+ struct kunit_ftrace_stub_ctx *ctx = res->data;
+
+ /* Make sure the resource is a ftrace stub resource. */
+ if (res->free != &__kunit_ftrace_stub_resource_free)
+ return false;
+
+ return ctx->real_fn_addr == (unsigned long)match_real_fn_addr;
+}
+
+void kunit_deactivate_ftrace_stub(struct kunit *test, void *real_fn_addr)
+{
+ struct kunit_resource *res;
+
+ KUNIT_ASSERT_PTR_NE_MSG(test, real_fn_addr, NULL,
+ "Tried to deactivate a NULL stub.");
+
+ /* Look up the existing stub for this function. */
+ res = kunit_find_resource(test,
+ __kunit_ftrace_stub_resource_match,
+ real_fn_addr);
+
+ /* Error out if the stub doesn't exist. */
+ KUNIT_ASSERT_PTR_NE_MSG(test, res, NULL,
+ "Tried to deactivate a nonexistent stub.");
+
+ /* Free the stub. We 'put' twice, as we got a reference
+ * from kunit_find_resource(). The free function will deactivate the
+ * ftrace stub.
+ */
+ kunit_remove_resource(test, res);
+ kunit_put_resource(res);
+}
+EXPORT_SYMBOL_GPL(kunit_deactivate_ftrace_stub);
+
+void __kunit_activate_ftrace_stub(struct kunit *test,
+ const char *name,
+ void *real_fn_addr,
+ void *replacement_addr)
+{
+ unsigned long ftrace_ip;
+ struct kunit_ftrace_stub_ctx *ctx;
+ int ret;
+
+ ftrace_ip = ftrace_location((unsigned long)real_fn_addr);
+ if (!ftrace_ip)
+ KUNIT_FAIL_AND_ABORT(test, "%s ip is invalid: not a function, or is marked notrace or inline", name);
+
+ /* Allocate the stub context, which contains pointers to the replacement
+ * function and the test object. It's also registered as a KUnit
+ * resource which can be looked up by address (to deactivate manually)
+ * and is destroyed automatically on test exit.
+ */
+ ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ctx, "failed to allocate kunit stub for %s", name);
+
+ ctx->test = test;
+ ctx->ops = kunit_stub_base_ops;
+ ctx->ops.private = ctx;
+ ctx->real_fn_addr = (unsigned long)real_fn_addr;
+ ctx->replacement_addr = (unsigned long)replacement_addr;
+
+ ret = ftrace_set_filter_ip(&ctx->ops, ftrace_ip, 0, 0);
+ if (ret) {
+ kfree(ctx);
+ KUNIT_FAIL_AND_ABORT(test, "failed to set filter ip for %s: %d", name, ret);
+ }
+
+ ret = register_ftrace_function(&ctx->ops);
+ if (ret) {
+ kfree(ctx);
+ if (ret == -EBUSY)
+ KUNIT_FAIL_AND_ABORT(test, "failed to register stub (-EBUSY) for %s, likely due to already stubbing it?", name);
+ KUNIT_FAIL_AND_ABORT(test, "failed to register stub for %s: %d", name, ret);
+ }
+
+ /* Register the stub as a resource with a cleanup function */
+ kunit_alloc_resource(test, NULL,
+ __kunit_ftrace_stub_resource_free,
+ GFP_KERNEL, ctx);
+}
+EXPORT_SYMBOL_GPL(__kunit_activate_ftrace_stub);
@@ -8,6 +8,7 @@
#include <kunit/test.h>
#include <kunit/static_stub.h>
+#include <kunit/ftrace_stub.h>
/*
* This is the most fundamental element of KUnit, the test case. A test case
@@ -152,7 +153,7 @@ static void example_all_expect_macros_test(struct kunit *test)
}
/* This is a function we'll replace with static stubs. */
-static int add_one(int i)
+static KUNIT_STUBBABLE int add_one(int i)
{
/* This will trigger the stub if active. */
KUNIT_STATIC_STUB_REDIRECT(add_one, i);
@@ -277,6 +278,29 @@ static void example_slow_test(struct kunit *test)
KUNIT_EXPECT_EQ(test, 1 + 1, 2);
}
+/*
+ * This test shows the use of ftrace stubs.
+ */
+static void example_ftrace_stub_test(struct kunit *test)
+{
+#if !IS_ENABLED(CONFIG_KUNIT_FTRACE_STUBS)
+ kunit_skip(test, "KUNIT_FTRACE_STUBS not enabled");
+#else
+ /* By default, function is not stubbed. */
+ KUNIT_EXPECT_EQ(test, add_one(1), 2);
+
+ /* Replace add_one() with subtract_one(). */
+ kunit_activate_ftrace_stub(test, add_one, subtract_one);
+
+ /* add_one() is now replaced. */
+ KUNIT_EXPECT_EQ(test, add_one(1), 0);
+
+ /* Return add_one() to normal. */
+ kunit_deactivate_ftrace_stub(test, add_one);
+ KUNIT_EXPECT_EQ(test, add_one(1), 2);
+#endif
+}
+
/*
* Here we make a list of all the test cases we want to add to the test suite
* below.
@@ -297,6 +321,7 @@ static struct kunit_case example_test_cases[] = {
KUNIT_CASE(example_priv_test),
KUNIT_CASE_PARAM(example_params_test, example_gen_params),
KUNIT_CASE_SLOW(example_slow_test),
+ KUNIT_CASE(example_ftrace_stub_test),
{}
};
new file mode 100644
@@ -0,0 +1,11 @@
+CONFIG_KUNIT=y
+CONFIG_KUNIT_FTRACE_STUBS=y
+CONFIG_KUNIT_EXAMPLE_TEST=y
+
+# Depedencies
+CONFIG_FTRACE=y
+CONFIG_FUNCTION_TRACER=y
+CONFIG_MODULES=y
+CONFIG_DEBUG_KERNEL=y
+CONFIG_KALLSYMS_ALL=y
+CONFIG_LIVEPATCH=y