Merge tag 'linux-kselftest-kunit-5.9-rc1' of...

other program directly inside of a host operating system. To be clear, it does

not require any virtualization support: it is just a regular program.

What is a kunitconfig?

======================

What is a .kunitconfig?

=======================

It's just a defconfig that kunit_tool looks for in the base directory.

kunit_tool uses it to generate a .config as you might expect. In addition, it

verifies that the generated .config contains the CONFIG options in the

kunitconfig; the reason it does this is so that it is easy to be sure that a

.kunitconfig; the reason it does this is so that it is easy to be sure that a

CONFIG that enables a test actually ends up in the .config.

How do I use kunit_tool?

- ``--timeout`` sets a maximum amount of time to allow tests to run.

- ``--jobs`` sets the number of threads to use to build the kernel.

If you just want to use the defconfig that ships with the kernel, you can

append the ``--defconfig`` flag as well:

.. code-block:: bash

	./tools/testing/kunit/kunit.py run --timeout=30 --jobs=`nproc --all` --defconfig

.. note::

	This command is particularly helpful for getting started because it

	just works. No kunitconfig needs to be present.

	This command will work even without a .kunitconfig file: if no

        .kunitconfig is present, a default one will be used instead.

For a list of all the flags supported by kunit_tool, you can run:

.. code-block:: bash

	./tools/testing/kunit/kunit.py run --defconfig

	./tools/testing/kunit/kunit.py run

For more information on this wrapper (also called kunit_tool) check out the

:doc:`kunit-tool` page.

#include <linux/module.h>

#include <linux/slab.h>

#include <linux/types.h>

#include <linux/kref.h>

struct kunit_resource;

/**

 * struct kunit_resource - represents a *test managed resource*

 * @allocation: for the user to store arbitrary data.

 * @data: for the user to store arbitrary data.

 * @free: a user supplied function to free the resource. Populated by

 * kunit_alloc_resource().

 * kunit_resource_alloc().

 *

 * Represents a *test managed resource*, a resource which will automatically be

 * cleaned up at the end of a test case.

 *

 * Resources are reference counted so if a resource is retrieved via

 * kunit_alloc_and_get_resource() or kunit_find_resource(), we need

 * to call kunit_put_resource() to reduce the resource reference count

 * when finished with it.  Note that kunit_alloc_resource() does not require a

 * kunit_resource_put() because it does not retrieve the resource itself.

 *

 * Example:

 *

 * .. code-block:: c

 *	static int kunit_kmalloc_init(struct kunit_resource *res, void *context)

 *	{

 *		struct kunit_kmalloc_params *params = context;

 *		res->allocation = kmalloc(params->size, params->gfp);

 *		res->data = kmalloc(params->size, params->gfp);

 *

 *		if (!res->allocation)

 *		if (!res->data)

 *			return -ENOMEM;

 *

 *		return 0;

 *

 *	static void kunit_kmalloc_free(struct kunit_resource *res)

 *	{

 *		kfree(res->allocation);

 *		kfree(res->data);

 *	}

 *

 *	void *kunit_kmalloc(struct kunit *test, size_t size, gfp_t gfp)

 *	{

 *		struct kunit_kmalloc_params params;

 *		struct kunit_resource *res;

 *

 *		params.size = size;

 *		params.gfp = gfp;

 *

 *		res = kunit_alloc_resource(test, kunit_kmalloc_init,

 *		return kunit_alloc_resource(test, kunit_kmalloc_init,

 *			kunit_kmalloc_free, &params);

 *		if (res)

 *			return res->allocation;

 *

 *		return NULL;

 *	}

 *

 * Resources can also be named, with lookup/removal done on a name

 * basis also.  kunit_add_named_resource(), kunit_find_named_resource()

 * and kunit_destroy_named_resource().  Resource names must be

 * unique within the test instance.

 */

struct kunit_resource {

	void *allocation;

	kunit_resource_free_t free;

	void *data;

	const char *name;		/* optional name */

	/* private: internal use only. */

	kunit_resource_free_t free;

	struct kref refcount;

	struct list_head node;

};

						    gfp_t internal_gfp,

						    void *context);

/**

 * kunit_get_resource() - Hold resource for use.  Should not need to be used

 *			  by most users as we automatically get resources

 *			  retrieved by kunit_find_resource*().

 * @res: resource

 */

static inline void kunit_get_resource(struct kunit_resource *res)

{

	kref_get(&res->refcount);

}

/*

 * Called when refcount reaches zero via kunit_put_resources();

 * should not be called directly.

 */

static inline void kunit_release_resource(struct kref *kref)

{

	struct kunit_resource *res = container_of(kref, struct kunit_resource,

						  refcount);

	/* If free function is defined, resource was dynamically allocated. */

	if (res->free) {

		res->free(res);

		kfree(res);

	}

}

/**

 * kunit_put_resource() - When caller is done with retrieved resource,

 *			  kunit_put_resource() should be called to drop

 *			  reference count.  The resource list maintains

 *			  a reference count on resources, so if no users

 *			  are utilizing a resource and it is removed from

 *			  the resource list, it will be freed via the

 *			  associated free function (if any).  Only

 *			  needs to be used if we alloc_and_get() or

 *			  find() resource.

 * @res: resource

 */

static inline void kunit_put_resource(struct kunit_resource *res)

{

	kref_put(&res->refcount, kunit_release_resource);

}

/**

 * kunit_add_resource() - Add a *test managed resource*.

 * @test: The test context object.

 * @init: a user-supplied function to initialize the result (if needed).  If

 *        none is supplied, the resource data value is simply set to @data.

 *	  If an init function is supplied, @data is passed to it instead.

 * @free: a user-supplied function to free the resource (if needed).

 * @data: value to pass to init function or set in resource data field.

 */

int kunit_add_resource(struct kunit *test,

		       kunit_resource_init_t init,

		       kunit_resource_free_t free,

		       struct kunit_resource *res,

		       void *data);

/**

 * kunit_add_named_resource() - Add a named *test managed resource*.

 * @test: The test context object.

 * @init: a user-supplied function to initialize the resource data, if needed.

 * @free: a user-supplied function to free the resource data, if needed.

 * @name_data: name and data to be set for 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);

/**

 * kunit_alloc_resource() - Allocates a *test managed resource*.

 * @test: The test context object.

 * cleaned up at the end of a test case. See &struct kunit_resource for an

 * example.

 *

 * NOTE: KUnit needs to allocate memory for each kunit_resource object. You must

 * Note: KUnit needs to allocate memory for a kunit_resource object. You must

 * specify an @internal_gfp that is compatible with the use context of your

 * resource.

 */

{

	struct kunit_resource *res;

	res = kunit_alloc_and_get_resource(test, init, free, internal_gfp,

					   context);

	res = kzalloc(sizeof(*res), internal_gfp);

	if (!res)

		return NULL;

	if (res)

		return res->allocation;

	if (!kunit_add_resource(test, init, free, res, context))

		return res->data;

	return NULL;

}

typedef bool (*kunit_resource_match_t)(struct kunit *test,

				       const void *res,

				       struct kunit_resource *res,

				       void *match_data);

/**

 * kunit_resource_instance_match() - Match a resource with the same instance.

 * @test: Test case to which the resource belongs.

 * @res: The data stored in kunit_resource->allocation.

 * @res: The resource.

 * @match_data: The resource pointer to match against.

 *

 * An instance of kunit_resource_match_t that matches a resource whose

 * allocation matches @match_data.

 */

static inline bool kunit_resource_instance_match(struct kunit *test,

						 const void *res,

						 struct kunit_resource *res,

						 void *match_data)

{

	return res == match_data;

	return res->data == match_data;

}

/**

 * kunit_resource_destroy() - Find a kunit_resource and destroy it.

 * kunit_resource_name_match() - Match a resource with the same name.

 * @test: Test case to which the resource belongs.

 * @res: The resource.

 * @match_name: The name to match against.

 */

static inline bool kunit_resource_name_match(struct kunit *test,

					     struct kunit_resource *res,

					     void *match_name)

{

	return res->name && strcmp(res->name, match_name) == 0;

}

/**

 * kunit_find_resource() - Find a resource using match function/data.

 * @test: Test case to which the resource belongs.

 * @match: match function to be applied to resources/match data.

 * @match_data: data to be used in matching.

 */

static inline struct kunit_resource *

kunit_find_resource(struct kunit *test,

		    kunit_resource_match_t match,

		    void *match_data)

{

	struct kunit_resource *res, *found = NULL;

	spin_lock(&test->lock);

	list_for_each_entry_reverse(res, &test->resources, node) {

		if (match(test, res, (void *)match_data)) {

			found = res;

			kunit_get_resource(found);

			break;

		}

	}

	spin_unlock(&test->lock);

	return found;

}

/**

 * kunit_find_named_resource() - Find a resource using match name.

 * @test: Test case to which the resource belongs.

 * @name: match name.

 */

static inline struct kunit_resource *

kunit_find_named_resource(struct kunit *test,

			  const char *name)

{

	return kunit_find_resource(test, kunit_resource_name_match,

				   (void *)name);

}

/**

 * kunit_destroy_resource() - Find a kunit_resource and destroy it.

 * @test: Test case to which the resource belongs.

 * @match: Match function. Returns whether a given resource matches @match_data.

 * @free: Must match free on the kunit_resource to free.

 * @match_data: Data passed into @match.

 *

 * Free the latest kunit_resource of @test for which @free matches the

 * kunit_resource_free_t associated with the resource and for which @match

 * returns true.

 *

 * RETURNS:

 * 0 if kunit_resource is found and freed, -ENOENT if not found.

 */

int kunit_resource_destroy(struct kunit *test,

int kunit_destroy_resource(struct kunit *test,

			   kunit_resource_match_t match,

			   kunit_resource_free_t free,

			   void *match_data);

static inline int kunit_destroy_named_resource(struct kunit *test,

					       const char *name)

{

	return kunit_destroy_resource(test, kunit_resource_name_match,

				      (void *)name);

}

/**

 * kunit_remove_resource: remove resource from resource list associated with

 *			  test.

 * @test: The test context object.

 * @res: The resource to be removed.

 *

 * Note that the resource will not be immediately freed since it is likely

 * the caller has a reference to it via alloc_and_get() or find();

 * in this case a final call to kunit_put_resource() is required.

 */

void kunit_remove_resource(struct kunit *test, struct kunit_resource *res);

/**

 * kunit_kmalloc() - Like kmalloc() except the allocation is *test managed*.

 * @test: The test context object.

{

	struct kunit_test_resource_context *ctx = context;

	res->allocation = &ctx->is_resource_initialized;

	res->data = &ctx->is_resource_initialized;

	ctx->is_resource_initialized = true;

	return 0;

}

static void fake_resource_free(struct kunit_resource *res)

{

	bool *is_resource_initialized = res->allocation;

	bool *is_resource_initialized = res->data;

	*is_resource_initialized = false;

}

	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, res);

	KUNIT_EXPECT_PTR_EQ(test,

			    &ctx->is_resource_initialized,

			    (bool *) res->allocation);

			    (bool *)res->data);

	KUNIT_EXPECT_TRUE(test, list_is_last(&res->node, &ctx->test.resources));

	KUNIT_EXPECT_PTR_EQ(test, free, res->free);

	kunit_put_resource(res);

}

/*

 * Note: tests below use kunit_alloc_and_get_resource(), so as a consequence

 * they have a reference to the associated resource that they must release

 * via kunit_put_resource().  In normal operation, users will only

 * have to do this for cases where they use kunit_find_resource(), and the

 * kunit_alloc_resource() function will be used (which does not take a

 * resource reference).

 */

static void kunit_resource_test_destroy_resource(struct kunit *test)

{

	struct kunit_test_resource_context *ctx = test->priv;

			GFP_KERNEL,

			ctx);

	kunit_put_resource(res);

	KUNIT_ASSERT_FALSE(test,

			   kunit_resource_destroy(&ctx->test,

			   kunit_destroy_resource(&ctx->test,

						  kunit_resource_instance_match,

						  res->free,

						  res->allocation));

						  res->data));

	KUNIT_EXPECT_FALSE(test, ctx->is_resource_initialized);

	KUNIT_EXPECT_TRUE(test, list_empty(&ctx->test.resources));

							    fake_resource_free,

							    GFP_KERNEL,

							    ctx);

		kunit_put_resource(resources[i]);

	}

	kunit_cleanup(&ctx->test);

	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 2);

	res->allocation = ctx;

	res->data = ctx;

	return 0;

}

static void fake_resource_2_free(struct kunit_resource *res)

{

	struct kunit_test_resource_context *ctx = res->allocation;

	struct kunit_test_resource_context *ctx = res->data;

	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 2);

}

static int fake_resource_1_init(struct kunit_resource *res, void *context)

{

	struct kunit_test_resource_context *ctx = context;

	struct kunit_resource *res2;

	kunit_alloc_and_get_resource(&ctx->test,

	res2 = kunit_alloc_and_get_resource(&ctx->test,

					    fake_resource_2_init,

					    fake_resource_2_free,

					    GFP_KERNEL,

	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, allocate_order, 1);

	res->allocation = ctx;

	res->data = ctx;

	kunit_put_resource(res2);

	return 0;

}

static void fake_resource_1_free(struct kunit_resource *res)

{

	struct kunit_test_resource_context *ctx = res->allocation;

	struct kunit_test_resource_context *ctx = res->data;

	KUNIT_RESOURCE_TEST_MARK_ORDER(ctx, free_order, 1);

}

static void kunit_resource_test_proper_free_ordering(struct kunit *test)

{

	struct kunit_test_resource_context *ctx = test->priv;

	struct kunit_resource *res;

	/* fake_resource_1 allocates a fake_resource_2 in its init. */

	kunit_alloc_and_get_resource(&ctx->test,

	res = kunit_alloc_and_get_resource(&ctx->test,

					   fake_resource_1_init,

					   fake_resource_1_free,

					   GFP_KERNEL,

	KUNIT_EXPECT_EQ(test, ctx->allocate_order[0], 2);

	KUNIT_EXPECT_EQ(test, ctx->allocate_order[1], 1);

	kunit_put_resource(res);

	kunit_cleanup(&ctx->test);

	/*

	KUNIT_EXPECT_EQ(test, ctx->free_order[1], 2);

}

static void kunit_resource_test_static(struct kunit *test)

{

	struct kunit_test_resource_context ctx;

	struct kunit_resource res;

	KUNIT_EXPECT_EQ(test, kunit_add_resource(test, NULL, NULL, &res, &ctx),

			0);

	KUNIT_EXPECT_PTR_EQ(test, res.data, (void *)&ctx);

	kunit_cleanup(test);

	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));

}

static void kunit_resource_test_named(struct kunit *test)

{

	struct kunit_resource res1, res2, *found = NULL;

	struct kunit_test_resource_context ctx;

	KUNIT_EXPECT_EQ(test,

			kunit_add_named_resource(test, NULL, NULL, &res1,

						 "resource_1", &ctx),

			0);

	KUNIT_EXPECT_PTR_EQ(test, res1.data, (void *)&ctx);

	KUNIT_EXPECT_EQ(test,

			kunit_add_named_resource(test, NULL, NULL, &res1,

						 "resource_1", &ctx),

			-EEXIST);

	KUNIT_EXPECT_EQ(test,

			kunit_add_named_resource(test, NULL, NULL, &res2,

						 "resource_2", &ctx),

			0);

	found = kunit_find_named_resource(test, "resource_1");

	KUNIT_EXPECT_PTR_EQ(test, found, &res1);

	if (found)

		kunit_put_resource(&res1);

	KUNIT_EXPECT_EQ(test, kunit_destroy_named_resource(test, "resource_2"),

			0);

	kunit_cleanup(test);

	KUNIT_EXPECT_TRUE(test, list_empty(&test->resources));

}

static int kunit_resource_test_init(struct kunit *test)

{

	struct kunit_test_resource_context *ctx =

	KUNIT_CASE(kunit_resource_test_destroy_resource),

	KUNIT_CASE(kunit_resource_test_cleanup_resources),

	KUNIT_CASE(kunit_resource_test_proper_free_ordering),

	KUNIT_CASE(kunit_resource_test_static),

	KUNIT_CASE(kunit_resource_test_named),

	{}

};

	if (!frag->fragment)

		return -ENOMEM;

	res->allocation = frag;

	res->data = frag;

	return 0;

}

static void string_stream_fragment_free(struct kunit_resource *res)

{

	struct string_stream_fragment *frag = res->allocation;

	struct string_stream_fragment *frag = res->data;

	list_del(&frag->node);

	kunit_kfree(frag->test, frag->fragment);

static int string_stream_fragment_destroy(struct string_stream_fragment *frag)

{

	return kunit_resource_destroy(frag->test,

	return kunit_destroy_resource(frag->test,

				      kunit_resource_instance_match,

				      string_stream_fragment_free,

				      frag);

}

	if (!stream)

		return -ENOMEM;

	res->allocation = stream;

	res->data = stream;

	stream->gfp = ctx->gfp;

	stream->test = ctx->test;

	INIT_LIST_HEAD(&stream->fragments);

static void string_stream_free(struct kunit_resource *res)

{

	struct string_stream *stream = res->allocation;

	struct string_stream *stream = res->data;

	string_stream_clear(stream);

}

int string_stream_destroy(struct string_stream *stream)

{

	return kunit_resource_destroy(stream->test,

	return kunit_destroy_resource(stream->test,

				      kunit_resource_instance_match,

				      string_stream_free,

				      stream);

}