diff options
Diffstat (limited to '')
| -rw-r--r-- | lib/kunit/executor.c | 228 |
1 files changed, 228 insertions, 0 deletions
diff --git a/lib/kunit/executor.c b/lib/kunit/executor.c new file mode 100644 index 000000000..05ac4cdb6 --- /dev/null +++ b/lib/kunit/executor.c @@ -0,0 +1,228 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include <linux/reboot.h> +#include <kunit/test.h> +#include <linux/glob.h> +#include <linux/moduleparam.h> + +/* + * These symbols point to the .kunit_test_suites section and are defined in + * include/asm-generic/vmlinux.lds.h, and consequently must be extern. + */ +extern struct kunit_suite * const __kunit_suites_start[]; +extern struct kunit_suite * const __kunit_suites_end[]; + +#if IS_BUILTIN(CONFIG_KUNIT) + +static char *filter_glob_param; +static char *action_param; + +module_param_named(filter_glob, filter_glob_param, charp, 0); +MODULE_PARM_DESC(filter_glob, + "Filter which KUnit test suites/tests run at boot-time, e.g. list* or list*.*del_test"); +module_param_named(action, action_param, charp, 0); +MODULE_PARM_DESC(action, + "Changes KUnit executor behavior, valid values are:\n" + "<none>: run the tests like normal\n" + "'list' to list test names instead of running them.\n"); + +/* glob_match() needs NULL terminated strings, so we need a copy of filter_glob_param. */ +struct kunit_test_filter { + char *suite_glob; + char *test_glob; +}; + +/* Split "suite_glob.test_glob" into two. Assumes filter_glob is not empty. */ +static void kunit_parse_filter_glob(struct kunit_test_filter *parsed, + const char *filter_glob) +{ + const int len = strlen(filter_glob); + const char *period = strchr(filter_glob, '.'); + + if (!period) { + parsed->suite_glob = kzalloc(len + 1, GFP_KERNEL); + parsed->test_glob = NULL; + strcpy(parsed->suite_glob, filter_glob); + return; + } + + parsed->suite_glob = kzalloc(period - filter_glob + 1, GFP_KERNEL); + parsed->test_glob = kzalloc(len - (period - filter_glob) + 1, GFP_KERNEL); + + strncpy(parsed->suite_glob, filter_glob, period - filter_glob); + strncpy(parsed->test_glob, period + 1, len - (period - filter_glob)); +} + +/* Create a copy of suite with only tests that match test_glob. */ +static struct kunit_suite * +kunit_filter_tests(const struct kunit_suite *const suite, const char *test_glob) +{ + int n = 0; + struct kunit_case *filtered, *test_case; + struct kunit_suite *copy; + + kunit_suite_for_each_test_case(suite, test_case) { + if (!test_glob || glob_match(test_glob, test_case->name)) + ++n; + } + + if (n == 0) + return NULL; + + copy = kmemdup(suite, sizeof(*copy), GFP_KERNEL); + if (!copy) + return ERR_PTR(-ENOMEM); + + filtered = kcalloc(n + 1, sizeof(*filtered), GFP_KERNEL); + if (!filtered) { + kfree(copy); + return ERR_PTR(-ENOMEM); + } + + n = 0; + kunit_suite_for_each_test_case(suite, test_case) { + if (!test_glob || glob_match(test_glob, test_case->name)) + filtered[n++] = *test_case; + } + + copy->test_cases = filtered; + return copy; +} + +static char *kunit_shutdown; +core_param(kunit_shutdown, kunit_shutdown, charp, 0644); + +/* Stores an array of suites, end points one past the end */ +struct suite_set { + struct kunit_suite * const *start; + struct kunit_suite * const *end; +}; + +static void kunit_free_suite_set(struct suite_set suite_set) +{ + struct kunit_suite * const *suites; + + for (suites = suite_set.start; suites < suite_set.end; suites++) { + kfree((*suites)->test_cases); + kfree(*suites); + } + kfree(suite_set.start); +} + +static struct suite_set kunit_filter_suites(const struct suite_set *suite_set, + const char *filter_glob, + int *err) +{ + int i; + struct kunit_suite **copy, *filtered_suite; + struct suite_set filtered; + struct kunit_test_filter filter; + + const size_t max = suite_set->end - suite_set->start; + + copy = kmalloc_array(max, sizeof(*filtered.start), GFP_KERNEL); + filtered.start = copy; + if (!copy) { /* won't be able to run anything, return an empty set */ + filtered.end = copy; + return filtered; + } + + kunit_parse_filter_glob(&filter, filter_glob); + + for (i = 0; &suite_set->start[i] != suite_set->end; i++) { + if (!glob_match(filter.suite_glob, suite_set->start[i]->name)) + continue; + + filtered_suite = kunit_filter_tests(suite_set->start[i], filter.test_glob); + if (IS_ERR(filtered_suite)) { + *err = PTR_ERR(filtered_suite); + return filtered; + } + if (!filtered_suite) + continue; + + *copy++ = filtered_suite; + } + filtered.end = copy; + + kfree(filter.suite_glob); + kfree(filter.test_glob); + return filtered; +} + +static void kunit_handle_shutdown(void) +{ + if (!kunit_shutdown) + return; + + if (!strcmp(kunit_shutdown, "poweroff")) + kernel_power_off(); + else if (!strcmp(kunit_shutdown, "halt")) + kernel_halt(); + else if (!strcmp(kunit_shutdown, "reboot")) + kernel_restart(NULL); + +} + +static void kunit_exec_run_tests(struct suite_set *suite_set) +{ + size_t num_suites = suite_set->end - suite_set->start; + + pr_info("KTAP version 1\n"); + pr_info("1..%zu\n", num_suites); + + __kunit_test_suites_init(suite_set->start, num_suites); +} + +static void kunit_exec_list_tests(struct suite_set *suite_set) +{ + struct kunit_suite * const *suites; + struct kunit_case *test_case; + + /* Hack: print a ktap header so kunit.py can find the start of KUnit output. */ + pr_info("KTAP version 1\n"); + + for (suites = suite_set->start; suites < suite_set->end; suites++) + kunit_suite_for_each_test_case((*suites), test_case) { + pr_info("%s.%s\n", (*suites)->name, test_case->name); + } +} + +int kunit_run_all_tests(void) +{ + struct suite_set suite_set = {__kunit_suites_start, __kunit_suites_end}; + int err = 0; + if (!kunit_enabled()) { + pr_info("kunit: disabled\n"); + goto out; + } + + if (filter_glob_param) { + suite_set = kunit_filter_suites(&suite_set, filter_glob_param, &err); + if (err) { + pr_err("kunit executor: error filtering suites: %d\n", err); + goto out; + } + } + + if (!action_param) + kunit_exec_run_tests(&suite_set); + else if (strcmp(action_param, "list") == 0) + kunit_exec_list_tests(&suite_set); + else + pr_err("kunit executor: unknown action '%s'\n", action_param); + + if (filter_glob_param) { /* a copy was made of each suite */ + kunit_free_suite_set(suite_set); + } + +out: + kunit_handle_shutdown(); + return err; +} + +#if IS_BUILTIN(CONFIG_KUNIT_TEST) +#include "executor_test.c" +#endif + +#endif /* IS_BUILTIN(CONFIG_KUNIT) */ |