xiaomi-sm8450/android_kernel_xiaomi_sm8450
1
0
포크 0
코드 이슈 풀 리퀘스트 Actions Packages Projects 릴리즈 위키 활동

kunit: generalize kunit_resource API beyond allocated resources

소스 검색 
In its original form, the kunit resources API - consisting the
struct kunit_resource and associated functions - was focused on
adding allocated resources during test operation that would be
automatically cleaned up on test completion.

The recent RFC patch proposing converting KASAN tests to KUnit [1]
showed another potential model - where outside of test context,
but with a pointer to the test state, we wish to access/update
test-related data, but expressly want to avoid allocations.

It turns out we can generalize the kunit_resource to support
static resources where the struct kunit_resource * is passed
in and initialized for us. As part of this work, we also
change the "allocation" field to the more general "data" name,
as instead of associating an allocation, we can associate a
pointer to static data.  Static data is distinguished by a NULL
free functions.  A test is added to cover using kunit_add_resource()
with a static resource and data.

Finally we also make use of the kernel's krefcount interfaces
to manage reference counting of KUnit resources.  The motivation
for this is simple; if we have kernel threads accessing and
using resources (say via kunit_find_resource()) we need to
ensure we do not remove said resources (or indeed free them
if they were dynamically allocated) until the reference count
reaches zero.  A new function - kunit_put_resource() - is
added to handle this, and it should be called after a
thread using kunit_find_resource() is finished with the
retrieved resource.

We ensure that the functions needed to look up, use and
drop reference count are "static inline"-defined so that
they can be used by builtin code as well as modules in
the case that KUnit is built as a module.

A cosmetic change here also; I've tried moving to
kunit_[action]_resource() as the format of function names
for consistency and readability.

[1] https://lkml.org/lkml/2020/2/26/1286

Signed-off-by: Alan Maguire <alan.maguire@oracle.com>
Reviewed-by: Brendan Higgins <brendanhiggins@google.com>
Signed-off-by: Shuah Khan <skhan@linuxfoundation.org>
This commit is contained in:
Alan Maguire
2020-05-29 22:46:20 +01:00
committed by Shuah Khan
부모 48778464bb
커밋 d4cdd146d0
4개의 변경된 파일과 270개의 추가작업 그리고 131개의 파일을 삭제
Download Patch File Download Diff File Expand all files Collapse all files

157
lib/kunit/test.c
파일 보기

@@ -8,6 +8,7 @@
#include <kunit/test.h>
#include <linux/kernel.h>
#include <linux/kref.h>
#include <linux/sched/debug.h>
#include "debugfs.h"
@@ -406,11 +407,45 @@ void __kunit_test_suites_exit(struct kunit_suite **suites)
}
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;
res->free = free;
kref_init(&res->refcount);
if (init) {
ret = init(res, data);
if (ret)
return ret;
} else {
res->data = data;
}
spin_lock(&test->lock);
list_add_tail(&res->node, &test->resources);
/* refcount for list is established by kref_init() */
spin_unlock(&test->lock);
return ret;
}
EXPORT_SYMBOL_GPL(kunit_add_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 *context)
void *data)
{
struct kunit_resource *res;
int ret;
@@ -419,77 +454,45 @@ struct kunit_resource *kunit_alloc_and_get_resource(struct kunit *test,
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;
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);
static void kunit_resource_free(struct kunit *test, struct kunit_resource *res)
void kunit_remove_resource(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);
list_del(&res->node);
spin_unlock(&test->lock);
return resource;
kunit_put_resource(res);
}
EXPORT_SYMBOL_GPL(kunit_remove_resource);
int kunit_resource_destroy(struct kunit *test,
kunit_resource_match_t match,
kunit_resource_free_t free,
int kunit_destroy_resource(struct kunit *test, kunit_resource_match_t match,
void *match_data)
{
struct kunit_resource *resource;
struct kunit_resource *res = kunit_find_resource(test, match,
match_data);
resource = kunit_resource_remove(test, match, free, match_data);
if (!resource)
if (!res)
return -ENOENT;
kunit_resource_free(test, resource);
kunit_remove_resource(test, res);
/* We have a reference also via _find(); drop it. */
kunit_put_resource(res);
return 0;
}
EXPORT_SYMBOL_GPL(kunit_resource_destroy);
EXPORT_SYMBOL_GPL(kunit_destroy_resource);
struct kunit_kmalloc_params {
size_t size;
@@ -500,8 +503,8 @@ 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)
res->data = kmalloc(params->size, params->gfp);
if (!res->data)
return -ENOMEM;
return 0;
@@ -509,7 +512,7 @@ static int kunit_kmalloc_init(struct kunit_resource *res, void *context)
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)
@@ -529,20 +532,25 @@ EXPORT_SYMBOL_GPL(kunit_kmalloc);
void kunit_kfree(struct kunit *test, const void *ptr)
{
int rc;
struct kunit_resource *res;
rc = kunit_resource_destroy(test,
kunit_resource_instance_match,
kunit_kmalloc_free,
(void *)ptr);
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);
WARN_ON(rc);
}
EXPORT_SYMBOL_GPL(kunit_kfree);
void kunit_cleanup(struct kunit *test)
{
struct kunit_resource *resource;
struct kunit_resource *res;
/*
* test->resources is a stack - each allocation must be freed in the
@@ -559,13 +567,16 @@ void kunit_cleanup(struct kunit *test)
spin_unlock(&test->lock);
break;
}
resource = list_last_entry(&test->resources,
struct kunit_resource,
node);
list_del(&resource->node);
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(&test->lock);
kunit_resource_free(test, resource);
kunit_remove_resource(test, res);
}
}
EXPORT_SYMBOL_GPL(kunit_cleanup);