Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084// SPDX-License-Identifier: GPL-2.0/* * Base unit test (KUnit) API. * * Copyright (C) 2019, Google LLC. * Author: Brendan Higgins <brendanhiggins@google.com> */
#include <kunit/resource.h>#include <kunit/test.h>#include <kunit/test-bug.h>#include <kunit/attributes.h>#include <linux/kernel.h>#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/mutex.h>#include <linux/panic.h>#include <linux/sched/debug.h>#include <linux/sched.h>#include <linux/mm.h>
#include "debugfs.h"#include "device-impl.h"#include "hooks-impl.h"#include "string-stream.h"#include "try-catch-impl.h"
static DEFINE_MUTEX(kunit_run_lock);
/* * Hook to fail the current test and print an error message to the log. */void __printf(3, 4) __kunit_fail_current_test_impl(const char *file, int line, const char *fmt, ...){ va_list args; int len; char *buffer;
if (!current->kunit_test) return;
kunit_set_failure(current->kunit_test);
/* kunit_err() only accepts literals, so evaluate the args first. */ va_start(args, fmt); len = vsnprintf(NULL, 0, fmt, args) + 1; va_end(args);
buffer = kunit_kmalloc(current->kunit_test, len, GFP_KERNEL); if (!buffer) return;
va_start(args, fmt); vsnprintf(buffer, len, fmt, args); va_end(args);
kunit_err(current->kunit_test, "%s:%d: %s", file, line, buffer); kunit_kfree(current->kunit_test, buffer);}
/* * Enable KUnit tests to run. */#ifdef CONFIG_KUNIT_DEFAULT_ENABLEDstatic bool enable_param = true;#elsestatic bool enable_param;#endifmodule_param_named(enable, enable_param, bool, 0);MODULE_PARM_DESC(enable, "Enable KUnit tests");
/* * Configure the base timeout. */static unsigned long kunit_base_timeout = CONFIG_KUNIT_DEFAULT_TIMEOUT;module_param_named(timeout, kunit_base_timeout, ulong, 0644);MODULE_PARM_DESC(timeout, "Set the base timeout for Kunit test cases");
/* * KUnit statistic mode: * 0 - disabled * 1 - only when there is more than one subtest * 2 - enabled */static int kunit_stats_enabled = 1;module_param_named(stats_enabled, kunit_stats_enabled, int, 0644);MODULE_PARM_DESC(stats_enabled, "Print test stats: never (0), only for multiple subtests (1), or always (2)");
struct kunit_result_stats { unsigned long passed; unsigned long skipped; unsigned long failed; unsigned long total;};
static bool kunit_should_print_stats(struct kunit_result_stats *stats){ if (kunit_stats_enabled == 0) return false;
if (kunit_stats_enabled == 2) return true;
return (stats->total > 1);}
static void kunit_print_test_stats(struct kunit *test, struct kunit_result_stats *stats){ if (!kunit_should_print_stats(stats)) return;
kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT "# %s: pass:%lu fail:%lu skip:%lu total:%lu", test->name, stats->passed, stats->failed, stats->skipped, stats->total);}
/* Append formatted message to log. */void kunit_log_append(struct string_stream *log, const char *fmt, ...){ va_list args;
if (!log) return;
va_start(args, fmt); string_stream_vadd(log, fmt, args); va_end(args);}EXPORT_SYMBOL_GPL(kunit_log_append);
size_t kunit_suite_num_test_cases(struct kunit_suite *suite){ struct kunit_case *test_case; size_t len = 0;
kunit_suite_for_each_test_case(suite, test_case) len++;
return len;}EXPORT_SYMBOL_GPL(kunit_suite_num_test_cases);
/* Currently supported test levels */enum { KUNIT_LEVEL_SUITE = 0, KUNIT_LEVEL_CASE, KUNIT_LEVEL_CASE_PARAM,};
static void kunit_print_suite_start(struct kunit_suite *suite){ /* * We do not log the test suite header as doing so would * mean debugfs display would consist of the test suite * header prior to individual test results. * Hence directly printk the suite status, and we will * separately seq_printf() the suite header for the debugfs * representation. */ pr_info(KUNIT_SUBTEST_INDENT "KTAP version 1\n"); pr_info(KUNIT_SUBTEST_INDENT "# Subtest: %s\n", suite->name); kunit_print_attr((void *)suite, false, KUNIT_LEVEL_CASE); pr_info(KUNIT_SUBTEST_INDENT "1..%zd\n", kunit_suite_num_test_cases(suite));}
static void kunit_print_ok_not_ok(struct kunit *test, unsigned int test_level, enum kunit_status status, size_t test_number, const char *description, const char *directive){ const char *directive_header = (status == KUNIT_SKIPPED) ? " # SKIP " : ""; const char *directive_body = (status == KUNIT_SKIPPED) ? directive : "";
/* * When test is NULL assume that results are from the suite * and today suite results are expected at level 0 only. */ WARN(!test && test_level, "suite test level can't be %u!\n", test_level);
/* * We do not log the test suite results as doing so would * mean debugfs display would consist of an incorrect test * number. Hence directly printk the suite result, and we will * separately seq_printf() the suite results for the debugfs * representation. */ if (!test) pr_info("%s %zd %s%s%s\n", kunit_status_to_ok_not_ok(status), test_number, description, directive_header, directive_body); else kunit_log(KERN_INFO, test, "%*s%s %zd %s%s%s", KUNIT_INDENT_LEN * test_level, "", kunit_status_to_ok_not_ok(status), test_number, description, directive_header, directive_body);}
enum kunit_status kunit_suite_has_succeeded(struct kunit_suite *suite){ const struct kunit_case *test_case; enum kunit_status status = KUNIT_SKIPPED;
if (suite->suite_init_err) return KUNIT_FAILURE;
kunit_suite_for_each_test_case(suite, test_case) { if (test_case->status == KUNIT_FAILURE) return KUNIT_FAILURE; else if (test_case->status == KUNIT_SUCCESS) status = KUNIT_SUCCESS; }
return status;}EXPORT_SYMBOL_GPL(kunit_suite_has_succeeded);
static size_t kunit_suite_counter = 1;
static void kunit_print_suite_end(struct kunit_suite *suite){ kunit_print_ok_not_ok(NULL, KUNIT_LEVEL_SUITE, kunit_suite_has_succeeded(suite), kunit_suite_counter++, suite->name, suite->status_comment);}
unsigned int kunit_test_case_num(struct kunit_suite *suite, struct kunit_case *test_case){ struct kunit_case *tc; unsigned int i = 1;
kunit_suite_for_each_test_case(suite, tc) { if (tc == test_case) return i; i++; }
return 0;}EXPORT_SYMBOL_GPL(kunit_test_case_num);
static void kunit_print_string_stream(struct kunit *test, struct string_stream *stream){ struct string_stream_fragment *fragment; char *buf;
if (string_stream_is_empty(stream)) return;
buf = string_stream_get_string(stream); if (!buf) { kunit_err(test, "Could not allocate buffer, dumping stream:\n"); list_for_each_entry(fragment, &stream->fragments, node) { kunit_err(test, "%s", fragment->fragment); } kunit_err(test, "\n"); } else { kunit_err(test, "%s", buf); kfree(buf); }}
static void kunit_fail(struct kunit *test, const struct kunit_loc *loc, enum kunit_assert_type type, const struct kunit_assert *assert, assert_format_t assert_format, const struct va_format *message){ struct string_stream *stream;
kunit_set_failure(test);
stream = kunit_alloc_string_stream(test, GFP_KERNEL); if (IS_ERR(stream)) { WARN(true, "Could not allocate stream to print failed assertion in %s:%d\n", loc->file, loc->line); return; }
kunit_assert_prologue(loc, type, stream); assert_format(assert, message, stream);
kunit_print_string_stream(test, stream);
kunit_free_string_stream(test, stream);}
void __noreturn __kunit_abort(struct kunit *test){ kunit_try_catch_throw(&test->try_catch); /* Does not return. */
/* * Throw could not abort from test. * * XXX: we should never reach this line! As kunit_try_catch_throw is * marked __noreturn. */ WARN_ONCE(true, "Throw could not abort from test!\n");}EXPORT_SYMBOL_GPL(__kunit_abort);
void __kunit_do_failed_assertion(struct kunit *test, const struct kunit_loc *loc, enum kunit_assert_type type, const struct kunit_assert *assert, assert_format_t assert_format, const char *fmt, ...){ va_list args; struct va_format message; va_start(args, fmt);
message.fmt = fmt; message.va = &args;
kunit_fail(test, loc, type, assert, assert_format, &message);
va_end(args);}EXPORT_SYMBOL_GPL(__kunit_do_failed_assertion);
static void kunit_init_params(struct kunit *test){ test->params_array.params = NULL; test->params_array.get_description = NULL; test->params_array.num_params = 0; test->params_array.elem_size = 0;}
void kunit_init_test(struct kunit *test, const char *name, struct string_stream *log){ spin_lock_init(&test->lock); INIT_LIST_HEAD(&test->resources); test->name = name; test->log = log; if (test->log) string_stream_clear(log); test->status = KUNIT_SUCCESS; test->status_comment[0] = '\0'; kunit_init_params(test);}EXPORT_SYMBOL_GPL(kunit_init_test);
/* Only warn when a test takes more than twice the threshold */#define KUNIT_SPEED_WARNING_MULTIPLIER 2
/* Slow tests are defined as taking more than 1s */#define KUNIT_SPEED_SLOW_THRESHOLD_S 1
#define KUNIT_SPEED_SLOW_WARNING_THRESHOLD_S \ (KUNIT_SPEED_WARNING_MULTIPLIER * KUNIT_SPEED_SLOW_THRESHOLD_S)
#define s_to_timespec64(s) ns_to_timespec64((s) * NSEC_PER_SEC)
static void kunit_run_case_check_speed(struct kunit *test, struct kunit_case *test_case, struct timespec64 duration){ struct timespec64 slow_thr = s_to_timespec64(KUNIT_SPEED_SLOW_WARNING_THRESHOLD_S); enum kunit_speed speed = test_case->attr.speed;
if (timespec64_compare(&duration, &slow_thr) < 0) return;
if (speed == KUNIT_SPEED_VERY_SLOW || speed == KUNIT_SPEED_SLOW) return;
kunit_warn(test, "Test should be marked slow (runtime: %lld.%09lds)", duration.tv_sec, duration.tv_nsec);}
/* Returns timeout multiplier based on speed. * DEFAULT: 1 * KUNIT_SPEED_SLOW: 3 * KUNIT_SPEED_VERY_SLOW: 12 */static int kunit_timeout_mult(enum kunit_speed speed){ switch (speed) { case KUNIT_SPEED_SLOW: return 3; case KUNIT_SPEED_VERY_SLOW: return 12; default: return 1; }}
static unsigned long kunit_test_timeout(struct kunit_suite *suite, struct kunit_case *test_case){ int mult = 1;
/* * The default test timeout is 300 seconds and will be adjusted by mult * based on the test speed. The test speed will be overridden by the * innermost test component. */ if (suite->attr.speed != KUNIT_SPEED_UNSET) mult = kunit_timeout_mult(suite->attr.speed); if (test_case->attr.speed != KUNIT_SPEED_UNSET) mult = kunit_timeout_mult(test_case->attr.speed); return mult * kunit_base_timeout * msecs_to_jiffies(MSEC_PER_SEC);}
/* * Initializes and runs test case. Does not clean up or do post validations. */static void kunit_run_case_internal(struct kunit *test, struct kunit_suite *suite, struct kunit_case *test_case){ struct timespec64 start, end;
if (suite->init) { int ret;
ret = suite->init(test); if (ret) { kunit_err(test, "failed to initialize: %d\n", ret); kunit_set_failure(test); return; } }
ktime_get_ts64(&start);
test_case->run_case(test);
ktime_get_ts64(&end);
kunit_run_case_check_speed(test, test_case, timespec64_sub(end, start));}
static void kunit_case_internal_cleanup(struct kunit *test){ kunit_cleanup(test);}
/* * Performs post validations and cleanup after a test case was run. * XXX: Should ONLY BE CALLED AFTER kunit_run_case_internal! */static void kunit_run_case_cleanup(struct kunit *test, struct kunit_suite *suite){ if (suite->exit) suite->exit(test);
kunit_case_internal_cleanup(test);}
struct kunit_try_catch_context { struct kunit *test; struct kunit_suite *suite; struct kunit_case *test_case;};
static void kunit_try_run_case(void *data){ struct kunit_try_catch_context *ctx = data; struct kunit *test = ctx->test; struct kunit_suite *suite = ctx->suite; struct kunit_case *test_case = ctx->test_case;
current->kunit_test = test;
/* * kunit_run_case_internal may encounter a fatal error; if it does, * abort will be called, this thread will exit, and finally the parent * thread will resume control and handle any necessary clean up. */ kunit_run_case_internal(test, suite, test_case);}
static void kunit_try_run_case_cleanup(void *data){ struct kunit_try_catch_context *ctx = data; struct kunit *test = ctx->test; struct kunit_suite *suite = ctx->suite;
current->kunit_test = test;
kunit_run_case_cleanup(test, suite);}
static void kunit_catch_run_case_cleanup(void *data){ struct kunit_try_catch_context *ctx = data; struct kunit *test = ctx->test; int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
/* It is always a failure if cleanup aborts. */ kunit_set_failure(test);
if (try_exit_code) { /* * Test case could not finish, we have no idea what state it is * in, so don't do clean up. */ if (try_exit_code == -ETIMEDOUT) { kunit_err(test, "test case cleanup timed out\n"); /* * Unknown internal error occurred preventing test case from * running, so there is nothing to clean up. */ } else { kunit_err(test, "internal error occurred during test case cleanup: %d\n", try_exit_code); } return; }
kunit_err(test, "test aborted during cleanup. continuing without cleaning up\n");}
static void kunit_catch_run_case(void *data){ struct kunit_try_catch_context *ctx = data; struct kunit *test = ctx->test; int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
if (try_exit_code) { kunit_set_failure(test); /* * Test case could not finish, we have no idea what state it is * in, so don't do clean up. */ if (try_exit_code == -ETIMEDOUT) { kunit_err(test, "test case timed out\n"); /* * Unknown internal error occurred preventing test case from * running, so there is nothing to clean up. */ } else { kunit_err(test, "internal error occurred preventing test case from running: %d\n", try_exit_code); } return; }}
/* * Performs all logic to run a test case. It also catches most errors that * occur in a test case and reports them as failures. */static void kunit_run_case_catch_errors(struct kunit_suite *suite, struct kunit_case *test_case, struct kunit *test){ struct kunit_try_catch_context context; struct kunit_try_catch *try_catch;
try_catch = &test->try_catch;
kunit_try_catch_init(try_catch, test, kunit_try_run_case, kunit_catch_run_case, kunit_test_timeout(suite, test_case)); context.test = test; context.suite = suite; context.test_case = test_case; kunit_try_catch_run(try_catch, &context);
/* Now run the cleanup */ kunit_try_catch_init(try_catch, test, kunit_try_run_case_cleanup, kunit_catch_run_case_cleanup, kunit_test_timeout(suite, test_case)); kunit_try_catch_run(try_catch, &context);
/* Propagate the parameter result to the test case. */ if (test->status == KUNIT_FAILURE) test_case->status = KUNIT_FAILURE; else if (test_case->status != KUNIT_FAILURE && test->status == KUNIT_SUCCESS) test_case->status = KUNIT_SUCCESS;}
static void kunit_print_suite_stats(struct kunit_suite *suite, struct kunit_result_stats *suite_stats, struct kunit_result_stats *param_stats){ if (kunit_should_print_stats(suite_stats)) { kunit_log(KERN_INFO, suite, "# %s: pass:%lu fail:%lu skip:%lu total:%lu", suite->name, suite_stats->passed, suite_stats->failed, suite_stats->skipped, suite_stats->total); }
if (kunit_should_print_stats(param_stats)) { kunit_log(KERN_INFO, suite, "# Totals: pass:%lu fail:%lu skip:%lu total:%lu", param_stats->passed, param_stats->failed, param_stats->skipped, param_stats->total); }}
static void kunit_update_stats(struct kunit_result_stats *stats, enum kunit_status status){ switch (status) { case KUNIT_SUCCESS: stats->passed++; break; case KUNIT_SKIPPED: stats->skipped++; break; case KUNIT_FAILURE: stats->failed++; break; }
stats->total++;}
static void kunit_accumulate_stats(struct kunit_result_stats *total, struct kunit_result_stats add){ total->passed += add.passed; total->skipped += add.skipped; total->failed += add.failed; total->total += add.total;}
const void *kunit_array_gen_params(struct kunit *test, const void *prev, char *desc){ struct kunit_params *params_arr = &test->params_array; const void *param;
if (test->param_index < params_arr->num_params) { param = (char *)params_arr->params + test->param_index * params_arr->elem_size;
if (params_arr->get_description) params_arr->get_description(test, param, desc); return param; } return NULL;}EXPORT_SYMBOL_GPL(kunit_array_gen_params);
static void kunit_init_parent_param_test(struct kunit_case *test_case, struct kunit *test){ if (test_case->param_init) { int err = test_case->param_init(test);
if (err) { kunit_err(test_case, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT "# failed to initialize parent parameter test (%d)", err); test->status = KUNIT_FAILURE; test_case->status = KUNIT_FAILURE; } }}
static noinline_for_stack voidkunit_run_param_test(struct kunit_suite *suite, struct kunit_case *test_case, struct kunit *test, struct kunit_result_stats *suite_stats, struct kunit_result_stats *total_stats, struct kunit_result_stats *param_stats){ char param_desc[KUNIT_PARAM_DESC_SIZE]; const void *curr_param;
kunit_init_parent_param_test(test_case, test); if (test_case->status == KUNIT_FAILURE) { kunit_update_stats(param_stats, test->status); return; } /* Get initial param. */ param_desc[0] = '\0'; /* TODO: Make generate_params try-catch */ curr_param = test_case->generate_params(test, NULL, param_desc); test_case->status = KUNIT_SKIPPED; kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT "KTAP version 1\n"); kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT "# Subtest: %s", test_case->name); if (test->params_array.params && test_case->generate_params == kunit_array_gen_params) { kunit_log(KERN_INFO, test, KUNIT_SUBTEST_INDENT KUNIT_SUBTEST_INDENT "1..%zd\n", test->params_array.num_params); }
while (curr_param) { struct kunit param_test = { .param_value = curr_param, .param_index = ++test->param_index, .parent = test, }; kunit_init_test(¶m_test, test_case->name, NULL); param_test.log = test_case->log; kunit_run_case_catch_errors(suite, test_case, ¶m_test);
if (param_desc[0] == '\0') { snprintf(param_desc, sizeof(param_desc), "param-%d", param_test.param_index); }
kunit_print_ok_not_ok(¶m_test, KUNIT_LEVEL_CASE_PARAM, param_test.status, param_test.param_index, param_desc, param_test.status_comment);
kunit_update_stats(param_stats, param_test.status);
/* Get next param. */ param_desc[0] = '\0'; curr_param = test_case->generate_params(test, curr_param, param_desc); } /* * TODO: Put into a try catch. Since we don't need suite->exit * for it we can't reuse kunit_try_run_cleanup for this yet. */ if (test_case->param_exit) test_case->param_exit(test); /* TODO: Put this kunit_cleanup into a try-catch. */ kunit_cleanup(test);}
static noinline_for_stack voidkunit_run_one_test(struct kunit_suite *suite, struct kunit_case *test_case, struct kunit_result_stats *suite_stats, struct kunit_result_stats *total_stats){ struct kunit test = { .param_value = NULL, .param_index = 0 }; struct kunit_result_stats param_stats = { 0 };
kunit_init_test(&test, test_case->name, test_case->log); if (test_case->status == KUNIT_SKIPPED) { /* Test marked as skip */ test.status = KUNIT_SKIPPED; kunit_update_stats(¶m_stats, test.status); } else if (!test_case->generate_params) { /* Non-parameterised test. */ test_case->status = KUNIT_SKIPPED; kunit_run_case_catch_errors(suite, test_case, &test); kunit_update_stats(¶m_stats, test.status); } else { kunit_run_param_test(suite, test_case, &test, suite_stats, total_stats, ¶m_stats); } kunit_print_attr((void *)test_case, true, KUNIT_LEVEL_CASE);
kunit_print_test_stats(&test, ¶m_stats);
kunit_print_ok_not_ok(&test, KUNIT_LEVEL_CASE, test_case->status, kunit_test_case_num(suite, test_case), test_case->name, test.status_comment);
kunit_update_stats(suite_stats, test_case->status); kunit_accumulate_stats(total_stats, param_stats);}
int kunit_run_tests(struct kunit_suite *suite){ struct kunit_case *test_case; struct kunit_result_stats suite_stats = { 0 }; struct kunit_result_stats total_stats = { 0 };
/* Taint the kernel so we know we've run tests. */ add_taint(TAINT_TEST, LOCKDEP_STILL_OK);
if (suite->suite_init) { suite->suite_init_err = suite->suite_init(suite); if (suite->suite_init_err) { kunit_err(suite, KUNIT_SUBTEST_INDENT "# failed to initialize (%d)", suite->suite_init_err); goto suite_end; } }
kunit_print_suite_start(suite);
kunit_suite_for_each_test_case(suite, test_case) kunit_run_one_test(suite, test_case, &suite_stats, &total_stats);
if (suite->suite_exit) suite->suite_exit(suite);
kunit_print_suite_stats(suite, &suite_stats, &total_stats);suite_end: kunit_print_suite_end(suite);
return 0;}EXPORT_SYMBOL_GPL(kunit_run_tests);
static void kunit_init_suite(struct kunit_suite *suite){ kunit_debugfs_create_suite(suite); suite->status_comment[0] = '\0'; suite->suite_init_err = 0;
if (suite->log) string_stream_clear(suite->log);}
bool kunit_enabled(void){ return enable_param;}
int __kunit_test_suites_init(struct kunit_suite * const * const suites, int num_suites, bool run_tests){ unsigned int i;
if (num_suites == 0) return 0;
if (!kunit_enabled() && num_suites > 0) { pr_info("kunit: disabled\n"); return 0; }
kunit_suite_counter = 1;
/* Use mutex lock to guard against running tests concurrently. */ if (mutex_lock_interruptible(&kunit_run_lock)) { pr_err("kunit: test interrupted\n"); return -EINTR; } static_branch_inc(&kunit_running);
for (i = 0; i < num_suites; i++) { kunit_init_suite(suites[i]); if (run_tests) kunit_run_tests(suites[i]); }
static_branch_dec(&kunit_running); mutex_unlock(&kunit_run_lock); return 0;}EXPORT_SYMBOL_GPL(__kunit_test_suites_init);
static void kunit_exit_suite(struct kunit_suite *suite){ kunit_debugfs_destroy_suite(suite);}
void __kunit_test_suites_exit(struct kunit_suite **suites, int num_suites){ unsigned int i;
if (!kunit_enabled()) return;
for (i = 0; i < num_suites; i++) kunit_exit_suite(suites[i]);}EXPORT_SYMBOL_GPL(__kunit_test_suites_exit);
static void kunit_module_init(struct module *mod){ struct kunit_suite_set suite_set, filtered_set; struct kunit_suite_set normal_suite_set = { mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites, }; struct kunit_suite_set init_suite_set = { mod->kunit_init_suites, mod->kunit_init_suites + mod->num_kunit_init_suites, }; const char *action = kunit_action(); int err = 0;
if (mod->num_kunit_init_suites > 0) suite_set = kunit_merge_suite_sets(init_suite_set, normal_suite_set); else suite_set = normal_suite_set;
filtered_set = kunit_filter_suites(&suite_set, kunit_filter_glob() ?: "*.*", kunit_filter(), kunit_filter_action(), &err); if (err) pr_err("kunit module: error filtering suites: %d\n", err);
mod->kunit_suites = (struct kunit_suite **)filtered_set.start; mod->num_kunit_suites = filtered_set.end - filtered_set.start;
if (mod->num_kunit_init_suites > 0) kfree(suite_set.start);
if (!action) kunit_exec_run_tests(&filtered_set, false); else if (!strcmp(action, "list")) kunit_exec_list_tests(&filtered_set, false); else if (!strcmp(action, "list_attr")) kunit_exec_list_tests(&filtered_set, true); else pr_err("kunit: unknown action '%s'\n", action);}
static void kunit_module_exit(struct module *mod){ struct kunit_suite_set suite_set = { mod->kunit_suites, mod->kunit_suites + mod->num_kunit_suites, }; const char *action = kunit_action();
/* * Check if the start address is a valid virtual address to detect * if the module load sequence has failed and the suite set has not * been initialized and filtered. */ if (!suite_set.start || !virt_addr_valid(suite_set.start)) return;
if (!action) __kunit_test_suites_exit(mod->kunit_suites, mod->num_kunit_suites);
kunit_free_suite_set(suite_set);}
static int kunit_module_notify(struct notifier_block *nb, unsigned long val, void *data){ struct module *mod = data;
switch (val) { case MODULE_STATE_LIVE: kunit_module_init(mod); break; case MODULE_STATE_GOING: kunit_module_exit(mod); break; case MODULE_STATE_COMING: break; case MODULE_STATE_UNFORMED: break; }
return 0;}
static struct notifier_block kunit_mod_nb = { .notifier_call = kunit_module_notify, .priority = 0,};
KUNIT_DEFINE_ACTION_WRAPPER(kfree_action_wrapper, kfree, const void *)
void *kunit_kmalloc_array(struct kunit *test, size_t n, size_t size, gfp_t gfp){ void *data;
data = kmalloc_array(n, size, gfp);
if (!data) return NULL;
if (kunit_add_action_or_reset(test, kfree_action_wrapper, data) != 0) return NULL;
return data;}EXPORT_SYMBOL_GPL(kunit_kmalloc_array);
void kunit_kfree(struct kunit *test, const void *ptr){ if (!ptr) return;
kunit_release_action(test, kfree_action_wrapper, (void *)ptr);}EXPORT_SYMBOL_GPL(kunit_kfree);
void kunit_kfree_const(struct kunit *test, const void *x){#if !IS_MODULE(CONFIG_KUNIT) if (!is_kernel_rodata((unsigned long)x))#endif kunit_kfree(test, x);}EXPORT_SYMBOL_GPL(kunit_kfree_const);
const char *kunit_kstrdup_const(struct kunit *test, const char *str, gfp_t gfp){#if !IS_MODULE(CONFIG_KUNIT) if (is_kernel_rodata((unsigned long)str)) return str;#endif return kunit_kstrdup(test, str, gfp);}EXPORT_SYMBOL_GPL(kunit_kstrdup_const);
void kunit_cleanup(struct kunit *test){ struct kunit_resource *res; unsigned long flags;
/* * test->resources is a stack - each allocation must be freed in the * reverse order from which it was added since one resource may depend * on another for its entire lifetime. * Also, we cannot use the normal list_for_each constructs, even the * safe ones because *arbitrary* nodes may be deleted when * kunit_resource_free is called; the list_for_each_safe variants only * protect against the current node being deleted, not the next. */ while (true) { spin_lock_irqsave(&test->lock, flags); if (list_empty(&test->resources)) { spin_unlock_irqrestore(&test->lock, flags); break; } res = list_last_entry(&test->resources, struct kunit_resource, node); /* * Need to unlock here as a resource may remove another * resource, and this can't happen if the test->lock * is held. */ spin_unlock_irqrestore(&test->lock, flags); kunit_remove_resource(test, res); } current->kunit_test = NULL;}EXPORT_SYMBOL_GPL(kunit_cleanup);
static int __init kunit_init(void){ /* Install the KUnit hook functions. */ kunit_install_hooks();
kunit_debugfs_init();
kunit_bus_init(); return register_module_notifier(&kunit_mod_nb);}late_initcall(kunit_init);
static void __exit kunit_exit(void){ memset(&kunit_hooks, 0, sizeof(kunit_hooks)); unregister_module_notifier(&kunit_mod_nb);
kunit_bus_shutdown();
kunit_debugfs_cleanup(); kunit_free_boot_suites();}module_exit(kunit_exit);
MODULE_DESCRIPTION("Base unit test (KUnit) API");MODULE_LICENSE("GPL v2");