[mirror_ubuntu-hirsute-kernel.git] / lib / kunit / test.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 <linux/kernel.h>
#include <linux/sched/debug.h>

#include "string-stream.h"
#include "try-catch-impl.h"

static void kunit_set_failure(struct kunit *test)
{
	WRITE_ONCE(test->success, false);
}

static void kunit_print_tap_version(void)
{
	static bool kunit_has_printed_tap_version;

	if (!kunit_has_printed_tap_version) {
		pr_info("TAP version 14\n");
		kunit_has_printed_tap_version = true;
	}
}

static size_t kunit_test_cases_len(struct kunit_case *test_cases)
{
	struct kunit_case *test_case;
	size_t len = 0;

	for (test_case = test_cases; test_case->run_case; test_case++)
		len++;

	return len;
}

static void kunit_print_subtest_start(struct kunit_suite *suite)
{
	kunit_print_tap_version();
	pr_info("\t# Subtest: %s\n", suite->name);
	pr_info("\t1..%zd\n", kunit_test_cases_len(suite->test_cases));
}

static void kunit_print_ok_not_ok(bool should_indent,
				  bool is_ok,
				  size_t test_number,
				  const char *description)
{
	const char *indent, *ok_not_ok;

	if (should_indent)
		indent = "\t";
	else
		indent = "";

	if (is_ok)
		ok_not_ok = "ok";
	else
		ok_not_ok = "not ok";

	pr_info("%s%s %zd - %s\n", indent, ok_not_ok, test_number, description);
}

static bool kunit_suite_has_succeeded(struct kunit_suite *suite)
{
	const struct kunit_case *test_case;

	for (test_case = suite->test_cases; test_case->run_case; test_case++)
		if (!test_case->success)
			return false;

	return true;
}

static void kunit_print_subtest_end(struct kunit_suite *suite)
{
	static size_t kunit_suite_counter = 1;

	kunit_print_ok_not_ok(false,
			      kunit_suite_has_succeeded(suite),
			      kunit_suite_counter++,
			      suite->name);
}

static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case,
					    size_t test_number)
{
	kunit_print_ok_not_ok(true,
			      test_case->success,
			      test_number,
			      test_case->name);
}

static void kunit_print_string_stream(struct kunit *test,
				      struct string_stream *stream)
{
	struct string_stream_fragment *fragment;
	char *buf;

	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)
{
	spin_lock_init(&test->lock);
	INIT_LIST_HEAD(&test->resources);
	test->name = name;
	test->success = true;
}
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;

	/*
	 * 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_try_catch_context context;
	struct kunit_try_catch *try_catch;
	struct kunit test;

	kunit_init_test(&test, test_case->name);
	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);

	test_case->success = test.success;
}

int kunit_run_tests(struct kunit_suite *suite)
{
	struct kunit_case *test_case;
	size_t test_case_count = 1;

	kunit_print_subtest_start(suite);

	for (test_case = suite->test_cases; test_case->run_case; test_case++) {
		kunit_run_case_catch_errors(suite, test_case);
		kunit_print_test_case_ok_not_ok(test_case, test_case_count++);
	}

	kunit_print_subtest_end(suite);

	return 0;
}
EXPORT_SYMBOL_GPL(kunit_run_tests);

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 *context)
{
	struct kunit_resource *res;
	int ret;

	res = kzalloc(sizeof(*res), internal_gfp);
	if (!res)
		return NULL;

	ret = init(res, context);
	if (ret)
		return NULL;

	res->free = free;
	spin_lock(&test->lock);
	list_add_tail(&res->node, &test->resources);
	spin_unlock(&test->lock);

	return res;
}
EXPORT_SYMBOL_GPL(kunit_alloc_and_get_resource);

static void kunit_resource_free(struct kunit *test, struct kunit_resource *res)
{
	res->free(res);
	kfree(res);
}

static struct kunit_resource *kunit_resource_find(struct kunit *test,
						  kunit_resource_match_t match,
						  kunit_resource_free_t free,
						  void *match_data)
{
	struct kunit_resource *resource;

	lockdep_assert_held(&test->lock);

	list_for_each_entry_reverse(resource, &test->resources, node) {
		if (resource->free != free)
			continue;
		if (match(test, resource->allocation, match_data))
			return resource;
	}

	return NULL;
}

static struct kunit_resource *kunit_resource_remove(
		struct kunit *test,
		kunit_resource_match_t match,
		kunit_resource_free_t free,
		void *match_data)
{
	struct kunit_resource *resource;

	spin_lock(&test->lock);
	resource = kunit_resource_find(test, match, free, match_data);
	if (resource)
		list_del(&resource->node);
	spin_unlock(&test->lock);

	return resource;
}

int kunit_resource_destroy(struct kunit *test,
			   kunit_resource_match_t match,
			   kunit_resource_free_t free,
			   void *match_data)
{
	struct kunit_resource *resource;

	resource = kunit_resource_remove(test, match, free, match_data);

	if (!resource)
		return -ENOENT;

	kunit_resource_free(test, resource);
	return 0;
}
EXPORT_SYMBOL_GPL(kunit_resource_destroy);

struct kunit_kmalloc_params {
	size_t size;
	gfp_t gfp;
};

static int kunit_kmalloc_init(struct kunit_resource *res, void *context)
{
	struct kunit_kmalloc_params *params = context;

	res->allocation = kmalloc(params->size, params->gfp);
	if (!res->allocation)
		return -ENOMEM;

	return 0;
}

static void kunit_kmalloc_free(struct kunit_resource *res)
{
	kfree(res->allocation);
}

void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp)
{
	struct kunit_kmalloc_params params = {
		.size = size,
		.gfp = gfp
	};

	return kunit_alloc_resource(test,
				    kunit_kmalloc_init,
				    kunit_kmalloc_free,
				    gfp,
				    &params);
}
EXPORT_SYMBOL_GPL(kunit_kmalloc);

void kunit_kfree(struct kunit *test, const void *ptr)
{
	int rc;

	rc = kunit_resource_destroy(test,
				    kunit_resource_instance_match,
				    kunit_kmalloc_free,
				    (void *)ptr);

	WARN_ON(rc);
}
EXPORT_SYMBOL_GPL(kunit_kfree);

void kunit_cleanup(struct kunit *test)
{
	struct kunit_resource *resource;

	/*
	 * 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(&test->lock);
		if (list_empty(&test->resources)) {
			spin_unlock(&test->lock);
			break;
		}
		resource = list_last_entry(&test->resources,
					   struct kunit_resource,
					   node);
		list_del(&resource->node);
		spin_unlock(&test->lock);

		kunit_resource_free(test, resource);
	}
}
EXPORT_SYMBOL_GPL(kunit_cleanup);

static int __init kunit_init(void)
{
	return 0;
}
late_initcall(kunit_init);

static void __exit kunit_exit(void)
{
}
module_exit(kunit_exit);

MODULE_LICENSE("GPL v2");
Commit	Line	Data
914cc63e BH	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Base unit test (KUnit) API.
	4	*
	5	* Copyright (C) 2019, Google LLC.
	6	* Author: Brendan Higgins <brendanhiggins@google.com>
	7	*/
	8
	9	#include <kunit/test.h>
	10	#include <linux/kernel.h>
5f3e0620	11	#include <linux/sched/debug.h>
914cc63e	12
109fb06f	13	#include "string-stream.h"
9bbb11c6	14	#include "try-catch-impl.h"
109fb06f	15
914cc63e BH	16	static void kunit_set_failure(struct kunit *test)
	17	{
	18	WRITE_ONCE(test->success, false);
	19	}
	20
914cc63e BH	21	static void kunit_print_tap_version(void)
	22	{
	23	static bool kunit_has_printed_tap_version;
	24
	25	if (!kunit_has_printed_tap_version) {
741a98d0	26	pr_info("TAP version 14\n");
914cc63e BH	27	kunit_has_printed_tap_version = true;
	28	}
	29	}
	30
	31	static size_t kunit_test_cases_len(struct kunit_case *test_cases)
	32	{
	33	struct kunit_case *test_case;
	34	size_t len = 0;
	35
	36	for (test_case = test_cases; test_case->run_case; test_case++)
	37	len++;
	38
	39	return len;
	40	}
	41
	42	static void kunit_print_subtest_start(struct kunit_suite *suite)
	43	{
	44	kunit_print_tap_version();
741a98d0 BH	45	pr_info("\t# Subtest: %s\n", suite->name);
741a98d0 BH	46	pr_info("\t1..%zd\n", kunit_test_cases_len(suite->test_cases));
914cc63e BH	47	}
	48
	49	static void kunit_print_ok_not_ok(bool should_indent,
	50	bool is_ok,
	51	size_t test_number,
	52	const char *description)
	53	{
	54	const char indent, ok_not_ok;
	55
	56	if (should_indent)
	57	indent = "\t";
	58	else
	59	indent = "";
	60
	61	if (is_ok)
	62	ok_not_ok = "ok";
	63	else
	64	ok_not_ok = "not ok";
	65
741a98d0	66	pr_info("%s%s %zd - %s\n", indent, ok_not_ok, test_number, description);
914cc63e BH	67	}
	68
	69	static bool kunit_suite_has_succeeded(struct kunit_suite *suite)
	70	{
	71	const struct kunit_case *test_case;
	72
	73	for (test_case = suite->test_cases; test_case->run_case; test_case++)
	74	if (!test_case->success)
	75	return false;
	76
	77	return true;
	78	}
	79
	80	static void kunit_print_subtest_end(struct kunit_suite *suite)
	81	{
	82	static size_t kunit_suite_counter = 1;
	83
	84	kunit_print_ok_not_ok(false,
	85	kunit_suite_has_succeeded(suite),
	86	kunit_suite_counter++,
	87	suite->name);
	88	}
	89
	90	static void kunit_print_test_case_ok_not_ok(struct kunit_case *test_case,
	91	size_t test_number)
	92	{
	93	kunit_print_ok_not_ok(true,
	94	test_case->success,
	95	test_number,
	96	test_case->name);
	97	}
	98
73cda7bb BH	99	static void kunit_print_string_stream(struct kunit *test,
	100	struct string_stream *stream)
	101	{
	102	struct string_stream_fragment *fragment;
	103	char *buf;
	104
	105	buf = string_stream_get_string(stream);
	106	if (!buf) {
	107	kunit_err(test,
	108	"Could not allocate buffer, dumping stream:\n");
	109	list_for_each_entry(fragment, &stream->fragments, node) {
741a98d0	110	kunit_err(test, "%s", fragment->fragment);
73cda7bb BH	111	}
	112	kunit_err(test, "\n");
	113	} else {
741a98d0	114	kunit_err(test, "%s", buf);
73cda7bb BH	115	kunit_kfree(test, buf);
	116	}
	117	}
	118
	119	static void kunit_fail(struct kunit test, struct kunit_assert assert)
	120	{
	121	struct string_stream *stream;
	122
	123	kunit_set_failure(test);
	124
	125	stream = alloc_string_stream(test, GFP_KERNEL);
	126	if (!stream) {
	127	WARN(true,
	128	"Could not allocate stream to print failed assertion in %s:%d\n",
	129	assert->file,
	130	assert->line);
	131	return;
	132	}
	133
	134	assert->format(assert, stream);
	135
	136	kunit_print_string_stream(test, stream);
	137
	138	WARN_ON(string_stream_destroy(stream));
	139	}
	140
5f3e0620 BH	141	static void __noreturn kunit_abort(struct kunit *test)
	142	{
	143	kunit_try_catch_throw(&test->try_catch); /* Does not return. */
	144
	145	/*
	146	* Throw could not abort from test.
	147	*
	148	* XXX: we should never reach this line! As kunit_try_catch_throw is
	149	* marked __noreturn.
	150	*/
	151	WARN_ONCE(true, "Throw could not abort from test!\n");
	152	}
	153
73cda7bb BH	154	void kunit_do_assertion(struct kunit *test,
	155	struct kunit_assert *assert,
	156	bool pass,
	157	const char *fmt, ...)
	158	{
	159	va_list args;
	160
	161	if (pass)
	162	return;
	163
	164	va_start(args, fmt);
	165
	166	assert->message.fmt = fmt;
	167	assert->message.va = &args;
	168
	169	kunit_fail(test, assert);
	170
	171	va_end(args);
5f3e0620 BH	172
	173	if (assert->type == KUNIT_ASSERTION)
	174	kunit_abort(test);
73cda7bb	175	}
c475c77d	176	EXPORT_SYMBOL_GPL(kunit_do_assertion);
73cda7bb	177
914cc63e BH	178	void kunit_init_test(struct kunit test, const char name)
914cc63e BH	179	{
0a756853 BH	180	spin_lock_init(&test->lock);
0a756853 BH	181	INIT_LIST_HEAD(&test->resources);
914cc63e BH	182	test->name = name;
	183	test->success = true;
	184	}
c475c77d	185	EXPORT_SYMBOL_GPL(kunit_init_test);
914cc63e BH	186
914cc63e BH	187	/*
5f3e0620	188	* Initializes and runs test case. Does not clean up or do post validations.
914cc63e	189	*/
5f3e0620 BH	190	static void kunit_run_case_internal(struct kunit *test,
	191	struct kunit_suite *suite,
	192	struct kunit_case *test_case)
914cc63e	193	{
914cc63e BH	194	if (suite->init) {
	195	int ret;
	196
5f3e0620	197	ret = suite->init(test);
914cc63e	198	if (ret) {
5f3e0620 BH	199	kunit_err(test, "failed to initialize: %d\n", ret);
5f3e0620 BH	200	kunit_set_failure(test);
914cc63e BH	201	return;
	202	}
	203	}
	204
5f3e0620 BH	205	test_case->run_case(test);
	206	}
	207
	208	static void kunit_case_internal_cleanup(struct kunit *test)
	209	{
	210	kunit_cleanup(test);
	211	}
914cc63e	212
5f3e0620 BH	213	/*
	214	* Performs post validations and cleanup after a test case was run.
	215	* XXX: Should ONLY BE CALLED AFTER kunit_run_case_internal!
	216	*/
	217	static void kunit_run_case_cleanup(struct kunit *test,
	218	struct kunit_suite *suite)
	219	{
914cc63e	220	if (suite->exit)
5f3e0620 BH	221	suite->exit(test);
	222
	223	kunit_case_internal_cleanup(test);
	224	}
	225
	226	struct kunit_try_catch_context {
	227	struct kunit *test;
	228	struct kunit_suite *suite;
	229	struct kunit_case *test_case;
	230	};
	231
	232	static void kunit_try_run_case(void *data)
	233	{
	234	struct kunit_try_catch_context *ctx = data;
	235	struct kunit *test = ctx->test;
	236	struct kunit_suite *suite = ctx->suite;
	237	struct kunit_case *test_case = ctx->test_case;
	238
	239	/*
	240	* kunit_run_case_internal may encounter a fatal error; if it does,
	241	* abort will be called, this thread will exit, and finally the parent
	242	* thread will resume control and handle any necessary clean up.
	243	*/
	244	kunit_run_case_internal(test, suite, test_case);
	245	/* This line may never be reached. */
	246	kunit_run_case_cleanup(test, suite);
	247	}
	248
	249	static void kunit_catch_run_case(void *data)
	250	{
	251	struct kunit_try_catch_context *ctx = data;
	252	struct kunit *test = ctx->test;
	253	struct kunit_suite *suite = ctx->suite;
	254	int try_exit_code = kunit_try_catch_get_result(&test->try_catch);
	255
	256	if (try_exit_code) {
	257	kunit_set_failure(test);
	258	/*
	259	* Test case could not finish, we have no idea what state it is
	260	* in, so don't do clean up.
	261	*/
	262	if (try_exit_code == -ETIMEDOUT) {
	263	kunit_err(test, "test case timed out\n");
	264	/*
	265	* Unknown internal error occurred preventing test case from
	266	* running, so there is nothing to clean up.
	267	*/
	268	} else {
	269	kunit_err(test, "internal error occurred preventing test case from running: %d\n",
	270	try_exit_code);
	271	}
	272	return;
	273	}
	274
	275	/*
	276	* Test case was run, but aborted. It is the test case's business as to
	277	* whether it failed or not, we just need to clean up.
	278	*/
	279	kunit_run_case_cleanup(test, suite);
	280	}
	281
	282	/*
	283	* Performs all logic to run a test case. It also catches most errors that
	284	* occur in a test case and reports them as failures.
285	*/
286	static void kunit_run_case_catch_errors(struct kunit_suite *suite,
287	struct kunit_case *test_case)
288	{
289	struct kunit_try_catch_context context;
290	struct kunit_try_catch *try_catch;
291	struct kunit test;
292
293	kunit_init_test(&test, test_case->name);
294	try_catch = &test.try_catch;
914cc63e	295
5f3e0620 BH	296	kunit_try_catch_init(try_catch,
	297	&test,
	298	kunit_try_run_case,
	299	kunit_catch_run_case);
	300	context.test = &test;
	301	context.suite = suite;
	302	context.test_case = test_case;
	303	kunit_try_catch_run(try_catch, &context);
0a756853	304
914cc63e BH	305	test_case->success = test.success;
	306	}
	307
	308	int kunit_run_tests(struct kunit_suite *suite)
	309	{
	310	struct kunit_case *test_case;
	311	size_t test_case_count = 1;
	312
	313	kunit_print_subtest_start(suite);
	314
	315	for (test_case = suite->test_cases; test_case->run_case; test_case++) {
5f3e0620	316	kunit_run_case_catch_errors(suite, test_case);
914cc63e BH	317	kunit_print_test_case_ok_not_ok(test_case, test_case_count++);
	318	}
	319
	320	kunit_print_subtest_end(suite);
	321
	322	return 0;
	323	}
c475c77d	324	EXPORT_SYMBOL_GPL(kunit_run_tests);
914cc63e	325
0a756853 BH	326	struct kunit_resource kunit_alloc_and_get_resource(struct kunit test,
	327	kunit_resource_init_t init,
	328	kunit_resource_free_t free,
	329	gfp_t internal_gfp,
	330	void *context)
	331	{
	332	struct kunit_resource *res;
	333	int ret;
	334
	335	res = kzalloc(sizeof(*res), internal_gfp);
	336	if (!res)
	337	return NULL;
	338
	339	ret = init(res, context);
	340	if (ret)
	341	return NULL;
	342
	343	res->free = free;
	344	spin_lock(&test->lock);
	345	list_add_tail(&res->node, &test->resources);
	346	spin_unlock(&test->lock);
	347
	348	return res;
	349	}
c475c77d	350	EXPORT_SYMBOL_GPL(kunit_alloc_and_get_resource);
0a756853 BH	351
	352	static void kunit_resource_free(struct kunit test, struct kunit_resource res)
	353	{
	354	res->free(res);
	355	kfree(res);
	356	}
	357
	358	static struct kunit_resource kunit_resource_find(struct kunit test,
	359	kunit_resource_match_t match,
	360	kunit_resource_free_t free,
	361	void *match_data)
	362	{
	363	struct kunit_resource *resource;
	364
	365	lockdep_assert_held(&test->lock);
	366
	367	list_for_each_entry_reverse(resource, &test->resources, node) {
	368	if (resource->free != free)
	369	continue;
	370	if (match(test, resource->allocation, match_data))
	371	return resource;
	372	}
	373
	374	return NULL;
	375	}
	376
	377	static struct kunit_resource *kunit_resource_remove(
	378	struct kunit *test,
	379	kunit_resource_match_t match,
	380	kunit_resource_free_t free,
	381	void *match_data)
	382	{
	383	struct kunit_resource *resource;
	384
	385	spin_lock(&test->lock);
	386	resource = kunit_resource_find(test, match, free, match_data);
	387	if (resource)
	388	list_del(&resource->node);
	389	spin_unlock(&test->lock);
	390
	391	return resource;
	392	}
	393
	394	int kunit_resource_destroy(struct kunit *test,
	395	kunit_resource_match_t match,
	396	kunit_resource_free_t free,
	397	void *match_data)
	398	{
	399	struct kunit_resource *resource;
	400
	401	resource = kunit_resource_remove(test, match, free, match_data);
	402
	403	if (!resource)
	404	return -ENOENT;
	405
	406	kunit_resource_free(test, resource);
	407	return 0;
	408	}
c475c77d	409	EXPORT_SYMBOL_GPL(kunit_resource_destroy);
0a756853 BH	410
	411	struct kunit_kmalloc_params {
	412	size_t size;
	413	gfp_t gfp;
	414	};
	415
	416	static int kunit_kmalloc_init(struct kunit_resource res, void context)
	417	{
	418	struct kunit_kmalloc_params *params = context;
	419
	420	res->allocation = kmalloc(params->size, params->gfp);
	421	if (!res->allocation)
	422	return -ENOMEM;
	423
	424	return 0;
	425	}
	426
	427	static void kunit_kmalloc_free(struct kunit_resource *res)
	428	{
	429	kfree(res->allocation);
	430	}
	431
	432	void kunit_kmalloc(struct kunit test, size_t size, gfp_t gfp)
	433	{
	434	struct kunit_kmalloc_params params = {
	435	.size = size,
	436	.gfp = gfp
	437	};
	438
	439	return kunit_alloc_resource(test,
	440	kunit_kmalloc_init,
	441	kunit_kmalloc_free,
	442	gfp,
	443	&params);
	444	}
c475c77d	445	EXPORT_SYMBOL_GPL(kunit_kmalloc);
0a756853 BH	446
	447	void kunit_kfree(struct kunit test, const void ptr)
	448	{
	449	int rc;
	450
	451	rc = kunit_resource_destroy(test,
	452	kunit_resource_instance_match,
	453	kunit_kmalloc_free,
	454	(void *)ptr);
	455
	456	WARN_ON(rc);
	457	}
c475c77d	458	EXPORT_SYMBOL_GPL(kunit_kfree);
0a756853 BH	459
	460	void kunit_cleanup(struct kunit *test)
	461	{
	462	struct kunit_resource *resource;
	463
	464	/*
	465	* test->resources is a stack - each allocation must be freed in the
	466	* reverse order from which it was added since one resource may depend
	467	* on another for its entire lifetime.
	468	* Also, we cannot use the normal list_for_each constructs, even the
	469	* safe ones because arbitrary nodes may be deleted when
	470	* kunit_resource_free is called; the list_for_each_safe variants only
	471	* protect against the current node being deleted, not the next.
	472	*/
	473	while (true) {
	474	spin_lock(&test->lock);
	475	if (list_empty(&test->resources)) {
	476	spin_unlock(&test->lock);
	477	break;
	478	}
	479	resource = list_last_entry(&test->resources,
	480	struct kunit_resource,
	481	node);
	482	list_del(&resource->node);
	483	spin_unlock(&test->lock);
	484
	485	kunit_resource_free(test, resource);
	486	}
	487	}
c475c77d	488	EXPORT_SYMBOL_GPL(kunit_cleanup);
9fe124bf AM	489
	490	static int __init kunit_init(void)
	491	{
	492	return 0;
	493	}
	494	late_initcall(kunit_init);
	495
	496	static void __exit kunit_exit(void)
	497	{
	498	}
	499	module_exit(kunit_exit);
	500
	501	MODULE_LICENSE("GPL v2");