mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
acd8e8407b
When a number of tests fail, it can be useful to get higher-level statistics of how many tests are failing (or how many parameters are failing in parameterised tests), and in what cases or suites. This is already done by some non-KUnit tests, so add support for automatically generating these for KUnit tests. This change adds a 'kunit.stats_enabled' switch which has three values: - 0: No stats are printed (current behaviour) - 1: Stats are printed only for tests/suites with more than one subtest (new default) - 2: Always print test statistics For parameterised tests, the summary line looks as follows: " # inode_test_xtimestamp_decoding: pass:16 fail:0 skip:0 total:16" For test suites, there are two lines looking like this: "# ext4_inode_test: pass:1 fail:0 skip:0 total:1" "# Totals: pass:16 fail:0 skip:0 total:16" The first line gives the number of direct subtests, the second "Totals" line is the accumulated sum of all tests and test parameters. This format is based on the one used by kselftest[1]. [1]: https://elixir.bootlin.com/linux/latest/source/tools/testing/selftests/kselftest.h#L109 Signed-off-by: David Gow <davidgow@google.com> Reviewed-by: Brendan Higgins <brendanhiggins@google.com> Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
808 lines
19 KiB
C
808 lines
19 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Base unit test (KUnit) API.
|
|
*
|
|
* Copyright (C) 2019, Google LLC.
|
|
* Author: Brendan Higgins <brendanhiggins@google.com>
|
|
*/
|
|
|
|
#include <kunit/test.h>
|
|
#include <kunit/test-bug.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/kref.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/sched/debug.h>
|
|
#include <linux/sched.h>
|
|
|
|
#include "debugfs.h"
|
|
#include "string-stream.h"
|
|
#include "try-catch-impl.h"
|
|
|
|
#if IS_BUILTIN(CONFIG_KUNIT)
|
|
/*
|
|
* Fail the current test and print an error message to the log.
|
|
*/
|
|
void __kunit_fail_current_test(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);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__kunit_fail_current_test);
|
|
#endif
|
|
|
|
/*
|
|
* 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, size of which is limited to
|
|
* KUNIT_LOG_SIZE bytes (including null terminating byte).
|
|
*/
|
|
void kunit_log_append(char *log, const char *fmt, ...)
|
|
{
|
|
char line[KUNIT_LOG_SIZE];
|
|
va_list args;
|
|
int len_left;
|
|
|
|
if (!log)
|
|
return;
|
|
|
|
len_left = KUNIT_LOG_SIZE - strlen(log) - 1;
|
|
if (len_left <= 0)
|
|
return;
|
|
|
|
va_start(args, fmt);
|
|
vsnprintf(line, sizeof(line), fmt, args);
|
|
va_end(args);
|
|
|
|
strncat(log, line, len_left);
|
|
}
|
|
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);
|
|
|
|
static void kunit_print_subtest_start(struct kunit_suite *suite)
|
|
{
|
|
kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT "# Subtest: %s",
|
|
suite->name);
|
|
kunit_log(KERN_INFO, suite, KUNIT_SUBTEST_INDENT "1..%zd",
|
|
kunit_suite_num_test_cases(suite));
|
|
}
|
|
|
|
static void kunit_print_ok_not_ok(void *test_or_suite,
|
|
bool is_test,
|
|
enum kunit_status status,
|
|
size_t test_number,
|
|
const char *description,
|
|
const char *directive)
|
|
{
|
|
struct kunit_suite *suite = is_test ? NULL : test_or_suite;
|
|
struct kunit *test = is_test ? test_or_suite : NULL;
|
|
const char *directive_header = (status == KUNIT_SKIPPED) ? " # SKIP " : "";
|
|
|
|
/*
|
|
* We do not log the test suite results as doing so would
|
|
* mean debugfs display would consist of the test suite
|
|
* description and status prior to individual test results.
|
|
* Hence directly printk the suite status, and we will
|
|
* separately seq_printf() the suite status for the debugfs
|
|
* representation.
|
|
*/
|
|
if (suite)
|
|
pr_info("%s %zd - %s%s%s\n",
|
|
kunit_status_to_ok_not_ok(status),
|
|
test_number, description, directive_header,
|
|
(status == KUNIT_SKIPPED) ? directive : "");
|
|
else
|
|
kunit_log(KERN_INFO, test,
|
|
KUNIT_SUBTEST_INDENT "%s %zd - %s%s%s",
|
|
kunit_status_to_ok_not_ok(status),
|
|
test_number, description, directive_header,
|
|
(status == KUNIT_SKIPPED) ? directive : "");
|
|
}
|
|
|
|
enum kunit_status kunit_suite_has_succeeded(struct kunit_suite *suite)
|
|
{
|
|
const struct kunit_case *test_case;
|
|
enum kunit_status status = KUNIT_SKIPPED;
|
|
|
|
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 void kunit_print_subtest_end(struct kunit_suite *suite)
|
|
{
|
|
static size_t kunit_suite_counter = 1;
|
|
|
|
kunit_print_ok_not_ok((void *)suite, false,
|
|
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);
|
|
kunit_kfree(test, buf);
|
|
}
|
|
}
|
|
|
|
static void kunit_fail(struct kunit *test, struct kunit_assert *assert)
|
|
{
|
|
struct string_stream *stream;
|
|
|
|
kunit_set_failure(test);
|
|
|
|
stream = alloc_string_stream(test, GFP_KERNEL);
|
|
if (!stream) {
|
|
WARN(true,
|
|
"Could not allocate stream to print failed assertion in %s:%d\n",
|
|
assert->file,
|
|
assert->line);
|
|
return;
|
|
}
|
|
|
|
assert->format(assert, stream);
|
|
|
|
kunit_print_string_stream(test, stream);
|
|
|
|
WARN_ON(string_stream_destroy(stream));
|
|
}
|
|
|
|
static 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");
|
|
}
|
|
|
|
void kunit_do_assertion(struct kunit *test,
|
|
struct kunit_assert *assert,
|
|
bool pass,
|
|
const char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
|
|
if (pass)
|
|
return;
|
|
|
|
va_start(args, fmt);
|
|
|
|
assert->message.fmt = fmt;
|
|
assert->message.va = &args;
|
|
|
|
kunit_fail(test, assert);
|
|
|
|
va_end(args);
|
|
|
|
if (assert->type == KUNIT_ASSERTION)
|
|
kunit_abort(test);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_do_assertion);
|
|
|
|
void kunit_init_test(struct kunit *test, const char *name, char *log)
|
|
{
|
|
spin_lock_init(&test->lock);
|
|
INIT_LIST_HEAD(&test->resources);
|
|
test->name = name;
|
|
test->log = log;
|
|
if (test->log)
|
|
test->log[0] = '\0';
|
|
test->status = KUNIT_SUCCESS;
|
|
test->status_comment[0] = '\0';
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_init_test);
|
|
|
|
/*
|
|
* 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)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
test_case->run_case(test);
|
|
}
|
|
|
|
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);
|
|
/* This line may never be reached. */
|
|
kunit_run_case_cleanup(test, suite);
|
|
}
|
|
|
|
static void kunit_catch_run_case(void *data)
|
|
{
|
|
struct kunit_try_catch_context *ctx = data;
|
|
struct kunit *test = ctx->test;
|
|
struct kunit_suite *suite = ctx->suite;
|
|
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;
|
|
}
|
|
|
|
/*
|
|
* Test case was run, but aborted. It is the test case's business as to
|
|
* whether it failed or not, we just need to clean up.
|
|
*/
|
|
kunit_run_case_cleanup(test, suite);
|
|
}
|
|
|
|
/*
|
|
* 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;
|
|
|
|
kunit_init_test(test, test_case->name, test_case->log);
|
|
try_catch = &test->try_catch;
|
|
|
|
kunit_try_catch_init(try_catch,
|
|
test,
|
|
kunit_try_run_case,
|
|
kunit_catch_run_case);
|
|
context.test = test;
|
|
context.suite = suite;
|
|
context.test_case = 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;
|
|
}
|
|
|
|
int kunit_run_tests(struct kunit_suite *suite)
|
|
{
|
|
char param_desc[KUNIT_PARAM_DESC_SIZE];
|
|
struct kunit_case *test_case;
|
|
struct kunit_result_stats suite_stats = { 0 };
|
|
struct kunit_result_stats total_stats = { 0 };
|
|
|
|
kunit_print_subtest_start(suite);
|
|
|
|
kunit_suite_for_each_test_case(suite, test_case) {
|
|
struct kunit test = { .param_value = NULL, .param_index = 0 };
|
|
struct kunit_result_stats param_stats = { 0 };
|
|
test_case->status = KUNIT_SKIPPED;
|
|
|
|
if (test_case->generate_params) {
|
|
/* Get initial param. */
|
|
param_desc[0] = '\0';
|
|
test.param_value = test_case->generate_params(NULL, param_desc);
|
|
}
|
|
|
|
do {
|
|
kunit_run_case_catch_errors(suite, test_case, &test);
|
|
|
|
if (test_case->generate_params) {
|
|
if (param_desc[0] == '\0') {
|
|
snprintf(param_desc, sizeof(param_desc),
|
|
"param-%d", test.param_index);
|
|
}
|
|
|
|
kunit_log(KERN_INFO, &test,
|
|
KUNIT_SUBTEST_INDENT
|
|
"# %s: %s %d - %s",
|
|
test_case->name,
|
|
kunit_status_to_ok_not_ok(test.status),
|
|
test.param_index + 1, param_desc);
|
|
|
|
/* Get next param. */
|
|
param_desc[0] = '\0';
|
|
test.param_value = test_case->generate_params(test.param_value, param_desc);
|
|
test.param_index++;
|
|
}
|
|
|
|
kunit_update_stats(¶m_stats, test.status);
|
|
|
|
} while (test.param_value);
|
|
|
|
kunit_print_test_stats(&test, param_stats);
|
|
|
|
kunit_print_ok_not_ok(&test, true, 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);
|
|
}
|
|
|
|
kunit_print_suite_stats(suite, suite_stats, total_stats);
|
|
kunit_print_subtest_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';
|
|
}
|
|
|
|
int __kunit_test_suites_init(struct kunit_suite * const * const suites)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; suites[i] != NULL; i++) {
|
|
kunit_init_suite(suites[i]);
|
|
kunit_run_tests(suites[i]);
|
|
}
|
|
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)
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i = 0; suites[i] != NULL; i++)
|
|
kunit_exit_suite(suites[i]);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__kunit_test_suites_exit);
|
|
|
|
/*
|
|
* Used for static resources and when a kunit_resource * has been created by
|
|
* kunit_alloc_resource(). When an init function is supplied, @data is passed
|
|
* into the init function; otherwise, we simply set the resource data field to
|
|
* the data value passed in.
|
|
*/
|
|
int kunit_add_resource(struct kunit *test,
|
|
kunit_resource_init_t init,
|
|
kunit_resource_free_t free,
|
|
struct kunit_resource *res,
|
|
void *data)
|
|
{
|
|
int ret = 0;
|
|
unsigned long flags;
|
|
|
|
res->free = free;
|
|
kref_init(&res->refcount);
|
|
|
|
if (init) {
|
|
ret = init(res, data);
|
|
if (ret)
|
|
return ret;
|
|
} else {
|
|
res->data = data;
|
|
}
|
|
|
|
spin_lock_irqsave(&test->lock, flags);
|
|
list_add_tail(&res->node, &test->resources);
|
|
/* refcount for list is established by kref_init() */
|
|
spin_unlock_irqrestore(&test->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_add_resource);
|
|
|
|
int kunit_add_named_resource(struct kunit *test,
|
|
kunit_resource_init_t init,
|
|
kunit_resource_free_t free,
|
|
struct kunit_resource *res,
|
|
const char *name,
|
|
void *data)
|
|
{
|
|
struct kunit_resource *existing;
|
|
|
|
if (!name)
|
|
return -EINVAL;
|
|
|
|
existing = kunit_find_named_resource(test, name);
|
|
if (existing) {
|
|
kunit_put_resource(existing);
|
|
return -EEXIST;
|
|
}
|
|
|
|
res->name = name;
|
|
|
|
return kunit_add_resource(test, init, free, res, data);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_add_named_resource);
|
|
|
|
struct kunit_resource *kunit_alloc_and_get_resource(struct kunit *test,
|
|
kunit_resource_init_t init,
|
|
kunit_resource_free_t free,
|
|
gfp_t internal_gfp,
|
|
void *data)
|
|
{
|
|
struct kunit_resource *res;
|
|
int ret;
|
|
|
|
res = kzalloc(sizeof(*res), internal_gfp);
|
|
if (!res)
|
|
return NULL;
|
|
|
|
ret = kunit_add_resource(test, init, free, res, data);
|
|
if (!ret) {
|
|
/*
|
|
* bump refcount for get; kunit_resource_put() should be called
|
|
* when done.
|
|
*/
|
|
kunit_get_resource(res);
|
|
return res;
|
|
}
|
|
return NULL;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_alloc_and_get_resource);
|
|
|
|
void kunit_remove_resource(struct kunit *test, struct kunit_resource *res)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&test->lock, flags);
|
|
list_del(&res->node);
|
|
spin_unlock_irqrestore(&test->lock, flags);
|
|
kunit_put_resource(res);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_remove_resource);
|
|
|
|
int kunit_destroy_resource(struct kunit *test, kunit_resource_match_t match,
|
|
void *match_data)
|
|
{
|
|
struct kunit_resource *res = kunit_find_resource(test, match,
|
|
match_data);
|
|
|
|
if (!res)
|
|
return -ENOENT;
|
|
|
|
kunit_remove_resource(test, res);
|
|
|
|
/* We have a reference also via _find(); drop it. */
|
|
kunit_put_resource(res);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_destroy_resource);
|
|
|
|
struct kunit_kmalloc_array_params {
|
|
size_t n;
|
|
size_t size;
|
|
gfp_t gfp;
|
|
};
|
|
|
|
static int kunit_kmalloc_array_init(struct kunit_resource *res, void *context)
|
|
{
|
|
struct kunit_kmalloc_array_params *params = context;
|
|
|
|
res->data = kmalloc_array(params->n, params->size, params->gfp);
|
|
if (!res->data)
|
|
return -ENOMEM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void kunit_kmalloc_array_free(struct kunit_resource *res)
|
|
{
|
|
kfree(res->data);
|
|
}
|
|
|
|
void *kunit_kmalloc_array(struct kunit *test, size_t n, size_t size, gfp_t gfp)
|
|
{
|
|
struct kunit_kmalloc_array_params params = {
|
|
.size = size,
|
|
.n = n,
|
|
.gfp = gfp
|
|
};
|
|
|
|
return kunit_alloc_resource(test,
|
|
kunit_kmalloc_array_init,
|
|
kunit_kmalloc_array_free,
|
|
gfp,
|
|
¶ms);
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_kmalloc_array);
|
|
|
|
void kunit_kfree(struct kunit *test, const void *ptr)
|
|
{
|
|
struct kunit_resource *res;
|
|
|
|
res = kunit_find_resource(test, kunit_resource_instance_match,
|
|
(void *)ptr);
|
|
|
|
/*
|
|
* Removing the resource from the list of resources drops the
|
|
* reference count to 1; the final put will trigger the free.
|
|
*/
|
|
kunit_remove_resource(test, res);
|
|
|
|
kunit_put_resource(res);
|
|
|
|
}
|
|
EXPORT_SYMBOL_GPL(kunit_kfree);
|
|
|
|
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)
|
|
{
|
|
kunit_debugfs_init();
|
|
|
|
return 0;
|
|
}
|
|
late_initcall(kunit_init);
|
|
|
|
static void __exit kunit_exit(void)
|
|
{
|
|
kunit_debugfs_cleanup();
|
|
}
|
|
module_exit(kunit_exit);
|
|
|
|
MODULE_LICENSE("GPL v2");
|