github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-07-27 01:32:21 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

raid6_kunit: use KUNIT_CASE_PARAM

Browse Source 
The raid6 test combines various generation and recovery algorithms.  Use
KUNIT_CASE_PARAM and provide a generator that iterates over the possible
combinations instead of looping inside a single test instance.

Link: https://lore.kernel.org/20260518051804.462141-15-hch@lst.de
Signed-off-by: Christoph Hellwig <hch@lst.de>
Acked-by: Ard Biesheuvel <ardb@kernel.org>
Tested-by: Ard Biesheuvel <ardb@kernel.org> # kunit only on arm64
Cc: Albert Ou <aou@eecs.berkeley.edu>
Cc: Alexander Gordeev <agordeev@linux.ibm.com>
Cc: Alexandre Ghiti <alex@ghiti.fr>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: "Borislav Petkov (AMD)" <bp@alien8.de>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Chris Mason <clm@fb.com>
Cc: Christian Borntraeger <borntraeger@linux.ibm.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: David Sterba <dsterba@suse.com>
Cc: Heiko Carstens <hca@linux.ibm.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Huacai Chen <chenhuacai@kernel.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Li Nan <linan122@huawei.com>
Cc: Madhavan Srinivasan <maddy@linux.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Nicholas Piggin <npiggin@gmail.com>
Cc: Palmer Dabbelt <palmer@dabbelt.com>
Cc: Song Liu <song@kernel.org>
Cc: Sven Schnelle <svens@linux.ibm.com>
Cc: Vasily Gorbik <gor@linux.ibm.com>
Cc: WANG Xuerui <kernel@xen0n.name>
Cc: Will Deacon <will@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
This commit is contained in:
Christoph Hellwig 2026-05-18 07:17:57 +02:00 committed by Andrew Morton
parent 30bf04bd13
commit 2175395f76
1 changed files with 69 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
lib/raid/raid6/tests/raid6_kunit.c
View File

@ -21,6 +21,15 @@ static char data[NDISKS][PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
static char recovi[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
static char recovj[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
struct test_args {
unsigned int recov_idx;
const struct raid6_recov_calls *recov;
unsigned int gen_idx;
const struct raid6_calls *gen;
};
static struct test_args args;
static void makedata(int start, int stop)
{
int i;
@ -43,9 +52,10 @@ static char member_type(int d)
}
}
static void test_disks(struct kunit *test, const struct raid6_calls *calls,
const struct raid6_recov_calls *ra, int faila, int failb)
static void test_recover(struct kunit *test, int faila, int failb)
{
const struct test_args *ta = test->param_value;
memset(recovi, 0xf0, PAGE_SIZE);
memset(recovj, 0xba, PAGE_SIZE);
@ -61,25 +71,23 @@ static void test_disks(struct kunit *test, const struct raid6_calls *calls,
goto skip;
/* P+Q failure. Just rebuild the syndrome. */
calls->gen_syndrome(NDISKS, PAGE_SIZE, dataptrs);
ta->gen->gen_syndrome(NDISKS, PAGE_SIZE, dataptrs);
} else if (failb == NDISKS - 2) {
/* data+P failure. */
ra->datap(NDISKS, PAGE_SIZE, faila, dataptrs);
ta->recov->datap(NDISKS, PAGE_SIZE, faila, dataptrs);
} else {
/* data+data failure. */
ra->data2(NDISKS, PAGE_SIZE, faila, failb, dataptrs);
ta->recov->data2(NDISKS, PAGE_SIZE, faila, failb, dataptrs);
}
KUNIT_EXPECT_MEMEQ_MSG(test, data[faila], recovi, PAGE_SIZE,
"algo=%-8s/%-8s faila miscompared: %3d[%c] (failb=%3d[%c])\n",
calls->name, ra->name,
faila, member_type(faila),
failb, member_type(failb));
"faila miscompared: %3d[%c] (failb=%3d[%c])\n",
faila, member_type(faila),
failb, member_type(failb));
KUNIT_EXPECT_MEMEQ_MSG(test, data[failb], recovj, PAGE_SIZE,
"algo=%-8s/%-8s failb miscompared: %3d[%c] (faila=%3d[%c])\n",
calls->name, ra->name,
failb, member_type(failb),
faila, member_type(faila));
"failb miscompared: %3d[%c] (faila=%3d[%c])\n",
failb, member_type(failb),
faila, member_type(faila));
skip:
dataptrs[faila] = data[faila];
@ -88,58 +96,66 @@ static void test_disks(struct kunit *test, const struct raid6_calls *calls,
static void raid6_test(struct kunit *test)
{
const struct test_args *ta = test->param_value;
int i, j, p1, p2;
unsigned int r, g;
for (r = 0; ; r++) {
const struct raid6_recov_calls *ra = raid6_recov_algo_find(r);
/* Nuke syndromes */
memset(data[NDISKS - 2], 0xee, PAGE_SIZE);
memset(data[NDISKS - 1], 0xee, PAGE_SIZE);
if (!ra)
break;
/* Generate assumed good syndrome */
ta->gen->gen_syndrome(NDISKS, PAGE_SIZE, (void **)&dataptrs);
for (g = 0; ; g++) {
const struct raid6_calls *calls = raid6_algo_find(g);
for (i = 0; i < NDISKS - 1; i++)
for (j = i + 1; j < NDISKS; j++)
test_recover(test, i, j);
if (!calls)
break;
if (!ta->gen->xor_syndrome)
return;
/* Nuke syndromes */
memset(data[NDISKS - 2], 0xee, PAGE_SIZE);
memset(data[NDISKS - 1], 0xee, PAGE_SIZE);
/* Generate assumed good syndrome */
calls->gen_syndrome(NDISKS, PAGE_SIZE,
(void **)&dataptrs);
for (i = 0; i < NDISKS-1; i++)
for (j = i+1; j < NDISKS; j++)
test_disks(test, calls, ra, i, j);
if (!calls->xor_syndrome)
continue;
for (p1 = 0; p1 < NDISKS-2; p1++)
for (p2 = p1; p2 < NDISKS-2; p2++) {
/* Simulate rmw run */
calls->xor_syndrome(NDISKS, p1, p2, PAGE_SIZE,
(void **)&dataptrs);
makedata(p1, p2);
calls->xor_syndrome(NDISKS, p1, p2, PAGE_SIZE,
(void **)&dataptrs);
for (i = 0; i < NDISKS-1; i++)
for (j = i+1; j < NDISKS; j++)
test_disks(test, calls,
ra, i, j);
}
for (p1 = 0; p1 < NDISKS - 2; p1++) {
for (p2 = p1; p2 < NDISKS - 2; p2++) {
/* Simulate rmw run */
ta->gen->xor_syndrome(NDISKS, p1, p2, PAGE_SIZE,
(void **)&dataptrs);
makedata(p1, p2);
ta->gen->xor_syndrome(NDISKS, p1, p2, PAGE_SIZE,
(void **)&dataptrs);
for (i = 0; i < NDISKS - 1; i++)
for (j = i + 1; j < NDISKS; j++)
test_recover(test, i, j);
}
}
}
static const void *raid6_gen_params(struct kunit *test, const void *prev,
char *desc)
{
if (!prev) {
memset(&args, 0, sizeof(args));
next_algo:
args.recov_idx = 0;
args.gen = raid6_algo_find(args.gen_idx);
if (!args.gen)
return NULL;
}
if (args.recov)
args.recov_idx++;
args.recov = raid6_recov_algo_find(args.recov_idx);
if (!args.recov) {
args.gen_idx++;
goto next_algo;
}
snprintf(desc, KUNIT_PARAM_DESC_SIZE, "gen=%s recov=%s",
args.gen->name, args.recov->name);
return &args;
}
static struct kunit_case raid6_test_cases[] = {
KUNIT_CASE(raid6_test),
KUNIT_CASE_PARAM(raid6_test, raid6_gen_params),
{},
};