mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-12-29 17:25:38 +00:00
99185c10d5
Patch series "resource: Fix region_intersects() vs add_memory_driver_managed()", v3. The patchset fixes a bug of region_intersects() for systems with CXL memory. The details of the bug can be found in [1/3]. To avoid similar bugs in the future. A kunit test case for region_intersects() is added in [3/3]. [2/3] is a preparation patch for [3/3]. This patch (of 3): region_intersects() is important because it's used for /dev/mem permission checking. To avoid possible bug of region_intersects() in the future, a kunit test case for region_intersects() is added. Link: https://lkml.kernel.org/r/20240906030713.204292-1-ying.huang@intel.com Link: https://lkml.kernel.org/r/20240906030713.204292-4-ying.huang@intel.com Signed-off-by: "Huang, Ying" <ying.huang@intel.com> Cc: Dan Williams <dan.j.williams@intel.com> Cc: David Hildenbrand <david@redhat.com> Cc: Davidlohr Bueso <dave@stgolabs.net> Cc: Jonathan Cameron <jonathan.cameron@huawei.com> Cc: Dave Jiang <dave.jiang@intel.com> Cc: Alison Schofield <alison.schofield@intel.com> Cc: Vishal Verma <vishal.l.verma@intel.com> Cc: Ira Weiny <ira.weiny@intel.com> Cc: Alistair Popple <apopple@nvidia.com> Cc: Andy Shevchenko <andriy.shevchenko@linux.intel.com> Cc: Bjorn Helgaas <bhelgaas@google.com> Cc: Baoquan He <bhe@redhat.com> Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
297 lines
9.9 KiB
C
297 lines
9.9 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Test cases for API provided by resource.c and ioport.h
|
|
*/
|
|
|
|
#include <kunit/test.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/sizes.h>
|
|
#include <linux/mm.h>
|
|
|
|
#define R0_START 0x0000
|
|
#define R0_END 0xffff
|
|
#define R1_START 0x1234
|
|
#define R1_END 0x2345
|
|
#define R2_START 0x4567
|
|
#define R2_END 0x5678
|
|
#define R3_START 0x6789
|
|
#define R3_END 0x789a
|
|
#define R4_START 0x2000
|
|
#define R4_END 0x7000
|
|
|
|
static struct resource r0 = { .start = R0_START, .end = R0_END };
|
|
static struct resource r1 = { .start = R1_START, .end = R1_END };
|
|
static struct resource r2 = { .start = R2_START, .end = R2_END };
|
|
static struct resource r3 = { .start = R3_START, .end = R3_END };
|
|
static struct resource r4 = { .start = R4_START, .end = R4_END };
|
|
|
|
struct result {
|
|
struct resource *r1;
|
|
struct resource *r2;
|
|
struct resource r;
|
|
bool ret;
|
|
};
|
|
|
|
static struct result results_for_union[] = {
|
|
{
|
|
.r1 = &r1, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
|
|
}, {
|
|
.r1 = &r4, .r2 = &r0, .r.start = R0_START, .r.end = R0_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r1, .ret = false,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r1, .ret = false,
|
|
}, {
|
|
.r1 = &r4, .r2 = &r1, .r.start = R1_START, .r.end = R4_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r3, .ret = false,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r4, .r.start = R4_START, .r.end = R4_END, .ret = true,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r4, .r.start = R4_START, .r.end = R3_END, .ret = true,
|
|
},
|
|
};
|
|
|
|
static struct result results_for_intersection[] = {
|
|
{
|
|
.r1 = &r1, .r2 = &r0, .r.start = R1_START, .r.end = R1_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r0, .r.start = R2_START, .r.end = R2_END, .ret = true,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r0, .r.start = R3_START, .r.end = R3_END, .ret = true,
|
|
}, {
|
|
.r1 = &r4, .r2 = &r0, .r.start = R4_START, .r.end = R4_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r1, .ret = false,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r1, .ret = false,
|
|
}, {
|
|
.r1 = &r4, .r2 = &r1, .r.start = R4_START, .r.end = R1_END, .ret = true,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r3, .ret = false,
|
|
}, {
|
|
.r1 = &r2, .r2 = &r4, .r.start = R2_START, .r.end = R2_END, .ret = true,
|
|
}, {
|
|
.r1 = &r3, .r2 = &r4, .r.start = R3_START, .r.end = R4_END, .ret = true,
|
|
},
|
|
};
|
|
|
|
static void resource_do_test(struct kunit *test, bool ret, struct resource *r,
|
|
bool exp_ret, struct resource *exp_r,
|
|
struct resource *r1, struct resource *r2)
|
|
{
|
|
KUNIT_EXPECT_EQ_MSG(test, ret, exp_ret, "Resources %pR %pR", r1, r2);
|
|
KUNIT_EXPECT_EQ_MSG(test, r->start, exp_r->start, "Start elements are not equal");
|
|
KUNIT_EXPECT_EQ_MSG(test, r->end, exp_r->end, "End elements are not equal");
|
|
}
|
|
|
|
static void resource_do_union_test(struct kunit *test, struct result *r)
|
|
{
|
|
struct resource result;
|
|
bool ret;
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
ret = resource_union(r->r1, r->r2, &result);
|
|
resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
ret = resource_union(r->r2, r->r1, &result);
|
|
resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
|
|
}
|
|
|
|
static void resource_test_union(struct kunit *test)
|
|
{
|
|
struct result *r = results_for_union;
|
|
unsigned int i = 0;
|
|
|
|
do {
|
|
resource_do_union_test(test, &r[i]);
|
|
} while (++i < ARRAY_SIZE(results_for_union));
|
|
}
|
|
|
|
static void resource_do_intersection_test(struct kunit *test, struct result *r)
|
|
{
|
|
struct resource result;
|
|
bool ret;
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
ret = resource_intersection(r->r1, r->r2, &result);
|
|
resource_do_test(test, ret, &result, r->ret, &r->r, r->r1, r->r2);
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
ret = resource_intersection(r->r2, r->r1, &result);
|
|
resource_do_test(test, ret, &result, r->ret, &r->r, r->r2, r->r1);
|
|
}
|
|
|
|
static void resource_test_intersection(struct kunit *test)
|
|
{
|
|
struct result *r = results_for_intersection;
|
|
unsigned int i = 0;
|
|
|
|
do {
|
|
resource_do_intersection_test(test, &r[i]);
|
|
} while (++i < ARRAY_SIZE(results_for_intersection));
|
|
}
|
|
|
|
/*
|
|
* The test resource tree for region_intersects() test:
|
|
*
|
|
* BASE-BASE+1M-1 : Test System RAM 0
|
|
* # hole 0 (BASE+1M-BASE+2M)
|
|
* BASE+2M-BASE+3M-1 : Test CXL Window 0
|
|
* BASE+3M-BASE+4M-1 : Test System RAM 1
|
|
* BASE+4M-BASE+7M-1 : Test CXL Window 1
|
|
* BASE+4M-BASE+5M-1 : Test System RAM 2
|
|
* BASE+4M+128K-BASE+4M+256K-1: Test Code
|
|
* BASE+5M-BASE+6M-1 : Test System RAM 3
|
|
*/
|
|
#define RES_TEST_RAM0_OFFSET 0
|
|
#define RES_TEST_RAM0_SIZE SZ_1M
|
|
#define RES_TEST_HOLE0_OFFSET (RES_TEST_RAM0_OFFSET + RES_TEST_RAM0_SIZE)
|
|
#define RES_TEST_HOLE0_SIZE SZ_1M
|
|
#define RES_TEST_WIN0_OFFSET (RES_TEST_HOLE0_OFFSET + RES_TEST_HOLE0_SIZE)
|
|
#define RES_TEST_WIN0_SIZE SZ_1M
|
|
#define RES_TEST_RAM1_OFFSET (RES_TEST_WIN0_OFFSET + RES_TEST_WIN0_SIZE)
|
|
#define RES_TEST_RAM1_SIZE SZ_1M
|
|
#define RES_TEST_WIN1_OFFSET (RES_TEST_RAM1_OFFSET + RES_TEST_RAM1_SIZE)
|
|
#define RES_TEST_WIN1_SIZE (SZ_1M * 3)
|
|
#define RES_TEST_RAM2_OFFSET RES_TEST_WIN1_OFFSET
|
|
#define RES_TEST_RAM2_SIZE SZ_1M
|
|
#define RES_TEST_CODE_OFFSET (RES_TEST_RAM2_OFFSET + SZ_128K)
|
|
#define RES_TEST_CODE_SIZE SZ_128K
|
|
#define RES_TEST_RAM3_OFFSET (RES_TEST_RAM2_OFFSET + RES_TEST_RAM2_SIZE)
|
|
#define RES_TEST_RAM3_SIZE SZ_1M
|
|
#define RES_TEST_TOTAL_SIZE ((RES_TEST_WIN1_OFFSET + RES_TEST_WIN1_SIZE))
|
|
|
|
static void remove_free_resource(void *ctx)
|
|
{
|
|
struct resource *res = (struct resource *)ctx;
|
|
|
|
remove_resource(res);
|
|
kfree(res);
|
|
}
|
|
|
|
static void resource_test_request_region(struct kunit *test, struct resource *parent,
|
|
resource_size_t start, resource_size_t size,
|
|
const char *name, unsigned long flags)
|
|
{
|
|
struct resource *res;
|
|
|
|
res = __request_region(parent, start, size, name, flags);
|
|
KUNIT_ASSERT_NOT_NULL(test, res);
|
|
kunit_add_action_or_reset(test, remove_free_resource, res);
|
|
}
|
|
|
|
static void resource_test_insert_resource(struct kunit *test, struct resource *parent,
|
|
resource_size_t start, resource_size_t size,
|
|
const char *name, unsigned long flags)
|
|
{
|
|
struct resource *res;
|
|
|
|
res = kzalloc(sizeof(*res), GFP_KERNEL);
|
|
KUNIT_ASSERT_NOT_NULL(test, res);
|
|
|
|
res->name = name;
|
|
res->start = start;
|
|
res->end = start + size - 1;
|
|
res->flags = flags;
|
|
if (insert_resource(parent, res)) {
|
|
kfree(res);
|
|
KUNIT_FAIL_AND_ABORT(test, "Fail to insert resource %pR\n", res);
|
|
}
|
|
|
|
kunit_add_action_or_reset(test, remove_free_resource, res);
|
|
}
|
|
|
|
static void resource_test_region_intersects(struct kunit *test)
|
|
{
|
|
unsigned long flags = IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY;
|
|
struct resource *parent;
|
|
resource_size_t start;
|
|
|
|
/* Find an iomem_resource hole to hold test resources */
|
|
parent = alloc_free_mem_region(&iomem_resource, RES_TEST_TOTAL_SIZE, SZ_1M,
|
|
"test resources");
|
|
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
|
|
start = parent->start;
|
|
kunit_add_action_or_reset(test, remove_free_resource, parent);
|
|
|
|
resource_test_request_region(test, parent, start + RES_TEST_RAM0_OFFSET,
|
|
RES_TEST_RAM0_SIZE, "Test System RAM 0", flags);
|
|
resource_test_insert_resource(test, parent, start + RES_TEST_WIN0_OFFSET,
|
|
RES_TEST_WIN0_SIZE, "Test CXL Window 0",
|
|
IORESOURCE_MEM);
|
|
resource_test_request_region(test, parent, start + RES_TEST_RAM1_OFFSET,
|
|
RES_TEST_RAM1_SIZE, "Test System RAM 1", flags);
|
|
resource_test_insert_resource(test, parent, start + RES_TEST_WIN1_OFFSET,
|
|
RES_TEST_WIN1_SIZE, "Test CXL Window 1",
|
|
IORESOURCE_MEM);
|
|
resource_test_request_region(test, parent, start + RES_TEST_RAM2_OFFSET,
|
|
RES_TEST_RAM2_SIZE, "Test System RAM 2", flags);
|
|
resource_test_insert_resource(test, parent, start + RES_TEST_CODE_OFFSET,
|
|
RES_TEST_CODE_SIZE, "Test Code", flags);
|
|
resource_test_request_region(test, parent, start + RES_TEST_RAM3_OFFSET,
|
|
RES_TEST_RAM3_SIZE, "Test System RAM 3", flags);
|
|
kunit_release_action(test, remove_free_resource, parent);
|
|
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_RAM0_OFFSET, PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_RAM0_OFFSET +
|
|
RES_TEST_RAM0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
|
|
region_intersects(start + RES_TEST_HOLE0_OFFSET, PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_DISJOINT,
|
|
region_intersects(start + RES_TEST_HOLE0_OFFSET +
|
|
RES_TEST_HOLE0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_MIXED,
|
|
region_intersects(start + RES_TEST_WIN0_OFFSET +
|
|
RES_TEST_WIN0_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_RAM1_OFFSET +
|
|
RES_TEST_RAM1_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_RAM2_OFFSET +
|
|
RES_TEST_RAM2_SIZE - PAGE_SIZE, 2 * PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_CODE_OFFSET, PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_INTERSECTS,
|
|
region_intersects(start + RES_TEST_RAM2_OFFSET,
|
|
RES_TEST_RAM2_SIZE + PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
KUNIT_EXPECT_EQ(test, REGION_MIXED,
|
|
region_intersects(start + RES_TEST_RAM3_OFFSET,
|
|
RES_TEST_RAM3_SIZE + PAGE_SIZE,
|
|
IORESOURCE_SYSTEM_RAM, IORES_DESC_NONE));
|
|
}
|
|
|
|
static struct kunit_case resource_test_cases[] = {
|
|
KUNIT_CASE(resource_test_union),
|
|
KUNIT_CASE(resource_test_intersection),
|
|
KUNIT_CASE(resource_test_region_intersects),
|
|
{}
|
|
};
|
|
|
|
static struct kunit_suite resource_test_suite = {
|
|
.name = "resource",
|
|
.test_cases = resource_test_cases,
|
|
};
|
|
kunit_test_suite(resource_test_suite);
|
|
|
|
MODULE_DESCRIPTION("I/O Port & Memory Resource manager unit tests");
|
|
MODULE_LICENSE("GPL");
|