hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

test_hash.c: refactor into kunit 

Use KUnit framework to make tests more easily integrable with CIs.  Even
though these tests are not yet properly written as unit tests this
change should help in debugging.

Also remove kernel messages (i.e.  through pr_info) as KUnit handles all
debugging output and let it handle module init and exit details.

Link: https://lkml.kernel.org/r/20211208183711.390454-6-isabbasso@riseup.net
Reviewed-by: David Gow <davidgow@google.com>
Reported-by: kernel test robot <lkp@intel.com>
Tested-by: David Gow <davidgow@google.com>
Co-developed-by: Augusto Durães Camargo <augusto.duraes33@gmail.com>
Signed-off-by: Augusto Durães Camargo <augusto.duraes33@gmail.com>
Co-developed-by: Enzo Ferreira <ferreiraenzoa@gmail.com>
Signed-off-by: Enzo Ferreira <ferreiraenzoa@gmail.com>
Signed-off-by: Isabella Basso <isabbasso@riseup.net>
Cc: Brendan Higgins <brendanhiggins@google.com>
Cc: Daniel Latypov <dlatypov@google.com>
Cc: Geert Uytterhoeven <geert@linux-m68k.org>
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Isabella Basso 2022-01-19 18:09:15 -08:00 committed by Linus Torvalds
parent 88168bf35c
commit 0acc968f35
3 changed files with 81 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
lib/Kconfig.debug
View File

@ -2207,15 +2207,6 @@ config TEST_RHASHTABLE
If unsure, say N.
config TEST_HASH
tristate "Perform selftest on hash functions"
help
Enable this option to test the kernel's integer (<linux/hash.h>), and
string (<linux/stringhash.h>) hash functions on boot (or module load).
This is intended to help people writing architecture-specific
optimized versions. If unsure, say N.
config TEST_SIPHASH
tristate "Perform selftest on siphash functions"
help
@ -2364,6 +2355,25 @@ config BITFIELD_KUNIT
If unsure, say N.
config HASH_KUNIT_TEST
tristate "KUnit Test for integer hash functions" if !KUNIT_ALL_TESTS
depends on KUNIT
default KUNIT_ALL_TESTS
help
Enable this option to test the kernel's string (<linux/stringhash.h>), and
integer (<linux/hash.h>) hash functions on boot.
KUnit tests run during boot and output the results to the debug log
in TAP format (https://testanything.org/). Only useful for kernel devs
running the KUnit test harness, and not intended for inclusion into a
production build.
For more information on KUnit and unit tests in general please refer
to the KUnit documentation in Documentation/dev-tools/kunit/.
This is intended to help people writing architecture-specific
optimized versions. If unsure, say N.
config RESOURCE_KUNIT_TEST
tristate "KUnit test for resource API"
depends on KUNIT

2
lib/Makefile
View File

@ -62,7 +62,7 @@ obj-$(CONFIG_TEST_BITOPS) += test_bitops.o
CFLAGS_test_bitops.o += -Werror
obj-$(CONFIG_TEST_SYSCTL) += test_sysctl.o
obj-$(CONFIG_TEST_SIPHASH) += test_siphash.o
obj-$(CONFIG_TEST_HASH) += test_hash.o
obj-$(CONFIG_HASH_KUNIT_TEST) += test_hash.o
obj-$(CONFIG_TEST_IDA) += test_ida.o
obj-$(CONFIG_KASAN_KUNIT_TEST) += test_kasan.o
CFLAGS_test_kasan.o += -fno-builtin

178
lib/test_hash.c
View File

@ -14,17 +14,15 @@
* and hash_64().
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt "\n"
#include <linux/compiler.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/hash.h>
#include <linux/stringhash.h>
#include <linux/printk.h>
#include <kunit/test.h>
/* 32-bit XORSHIFT generator. Seed must not be zero. */
static u32 __init __attribute_const__
static u32 __attribute_const__
xorshift(u32 seed)
{
seed ^= seed << 13;
@ -34,7 +32,7 @@ xorshift(u32 seed)
}
/* Given a non-zero x, returns a non-zero byte. */
static u8 __init __attribute_const__
static u8 __attribute_const__
mod255(u32 x)
{
x = (x & 0xffff) + (x >> 16); /* 1 <= x <= 0x1fffe */
@ -45,8 +43,7 @@ mod255(u32 x)
}
/* Fill the buffer with non-zero bytes. */
static void __init
fill_buf(char *buf, size_t len, u32 seed)
static void fill_buf(char *buf, size_t len, u32 seed)
{
size_t i;
@ -71,40 +68,32 @@ struct test_hash_params {
};
#ifdef HAVE_ARCH__HASH_32
static bool __init
test_int__hash_32(struct test_hash_params *params)
static void
test_int__hash_32(struct kunit *test, struct test_hash_params *params)
{
params->hash_or[1][0] |= params->h2 = __hash_32_generic(params->h0);
#if HAVE_ARCH__HASH_32 == 1
if (params->h1 != params->h2) {
pr_err("__hash_32(%#x) = %#x != __hash_32_generic() = %#x",
KUNIT_EXPECT_EQ_MSG(test, params->h1, params->h2,
"__hash_32(%#x) = %#x != __hash_32_generic() = %#x",
params->h0, params->h1, params->h2);
return false;
}
#endif
return true;
}
#endif
#ifdef HAVE_ARCH_HASH_64
static bool __init
test_int_hash_64(struct test_hash_params *params, u32 const *m, int *k)
static void
test_int_hash_64(struct kunit *test, struct test_hash_params *params, u32 const *m, int *k)
{
params->h2 = hash_64_generic(*params->h64, *k);
#if HAVE_ARCH_HASH_64 == 1
if (params->h1 != params->h2) {
pr_err("hash_64(%#llx, %d) = %#x != hash_64_generic() = %#x",
KUNIT_EXPECT_EQ_MSG(test, params->h1, params->h2,
"hash_64(%#llx, %d) = %#x != hash_64_generic() = %#x",
*params->h64, *k, params->h1, params->h2);
return false;
}
#else
if (params->h2 > *m) {
pr_err("hash_64_generic(%#llx, %d) = %#x > %#x",
KUNIT_EXPECT_LE_MSG(test, params->h1, params->h2,
"hash_64_generic(%#llx, %d) = %#x > %#x",
*params->h64, *k, params->h1, *m);
return false;
}
#endif
return true;
}
#endif
@ -117,8 +106,8 @@ test_int_hash_64(struct test_hash_params *params, u32 const *m, int *k)
* inline, the code being tested is actually in the module, and you can
* recompile and re-test the module without rebooting.
*/
static bool __init
test_int_hash(unsigned long long h64, u32 hash_or[2][33])
static void
test_int_hash(struct kunit *test, unsigned long long h64, u32 hash_or[2][33])
{
int k;
struct test_hash_params params = { &h64, (u32)h64, 0, 0, hash_or };
@ -126,8 +115,7 @@ test_int_hash(unsigned long long h64, u32 hash_or[2][33])
/* Test __hash32 */
hash_or[0][0] |= params.h1 = __hash_32(params.h0);
#ifdef HAVE_ARCH__HASH_32
if (!test_int__hash_32(&params))
return false;
test_int__hash_32(test, &params);
#endif
/* Test k = 1..32 bits */
@ -136,29 +124,24 @@ test_int_hash(unsigned long long h64, u32 hash_or[2][33])
/* Test hash_32 */
hash_or[0][k] |= params.h1 = hash_32(params.h0, k);
if (params.h1 > m) {
pr_err("hash_32(%#x, %d) = %#x > %#x", params.h0, k, params.h1, m);
return false;
}
KUNIT_EXPECT_LE_MSG(test, params.h1, m,
"hash_32(%#x, %d) = %#x > %#x",
params.h0, k, params.h1, m);
/* Test hash_64 */
hash_or[1][k] |= params.h1 = hash_64(h64, k);
if (params.h1 > m) {
pr_err("hash_64(%#llx, %d) = %#x > %#x", h64, k, params.h1, m);
return false;
}
KUNIT_EXPECT_LE_MSG(test, params.h1, m,
"hash_64(%#llx, %d) = %#x > %#x",
h64, k, params.h1, m);
#ifdef HAVE_ARCH_HASH_64
if (!test_int_hash_64(&params, &m, &k))
return false;
test_int_hash_64(test, &params, &m, &k);
#endif
}
return true;
}
#define SIZE 256 /* Run time is cubic in SIZE */
static int __init test_string_or(void)
static void test_string_or(struct kunit *test)
{
char buf[SIZE+1];
u32 string_or = 0;
@ -178,20 +161,15 @@ static int __init test_string_or(void)
} /* j */
/* The OR of all the hash values should cover all the bits */
if (~string_or) {
pr_err("OR of all string hash results = %#x != %#x",
KUNIT_EXPECT_EQ_MSG(test, string_or, -1u,
"OR of all string hash results = %#x != %#x",
string_or, -1u);
return -EINVAL;
}
return 0;
}
static int __init test_hash_or(void)
static void test_hash_or(struct kunit *test)
{
char buf[SIZE+1];
u32 hash_or[2][33] = { { 0, } };
unsigned tests = 0;
unsigned long long h64 = 0;
int i, j;
@ -206,39 +184,27 @@ static int __init test_hash_or(void)
u32 h0 = full_name_hash(buf+i, buf+i, j-i);
/* Check that hashlen_string gets the length right */
if (hashlen_len(hashlen) != j-i) {
pr_err("hashlen_string(%d..%d) returned length"
" %u, expected %d",
KUNIT_EXPECT_EQ_MSG(test, hashlen_len(hashlen), j-i,
"hashlen_string(%d..%d) returned length %u, expected %d",
i, j, hashlen_len(hashlen), j-i);
return -EINVAL;
}
/* Check that the hashes match */
if (hashlen_hash(hashlen) != h0) {
pr_err("hashlen_string(%d..%d) = %08x != "
"full_name_hash() = %08x",
KUNIT_EXPECT_EQ_MSG(test, hashlen_hash(hashlen), h0,
"hashlen_string(%d..%d) = %08x != full_name_hash() = %08x",
i, j, hashlen_hash(hashlen), h0);
return -EINVAL;
}
h64 = h64 << 32 | h0; /* For use with hash_64 */
if (!test_int_hash(h64, hash_or))
return -EINVAL;
tests++;
test_int_hash(test, h64, hash_or);
} /* i */
} /* j */
if (~hash_or[0][0]) {
pr_err("OR of all __hash_32 results = %#x != %#x",
KUNIT_EXPECT_EQ_MSG(test, hash_or[0][0], -1u,
"OR of all __hash_32 results = %#x != %#x",
hash_or[0][0], -1u);
return -EINVAL;
}
#ifdef HAVE_ARCH__HASH_32
#if HAVE_ARCH__HASH_32 != 1 /* Test is pointless if results match */
if (~hash_or[1][0]) {
pr_err("OR of all __hash_32_generic results = %#x != %#x",
KUNIT_EXPECT_EQ_MSG(test, hash_or[1][0], -1u,
"OR of all __hash_32_generic results = %#x != %#x",
hash_or[1][0], -1u);
return -EINVAL;
}
#endif
#endif
@ -246,65 +212,27 @@ static int __init test_hash_or(void)
for (i = 1; i <= 32; i++) {
u32 const m = ((u32)2 << (i-1)) - 1; /* Low i bits set */
if (hash_or[0][i] != m) {
pr_err("OR of all hash_32(%d) results = %#x "
"(%#x expected)", i, hash_or[0][i], m);
return -EINVAL;
KUNIT_EXPECT_EQ_MSG(test, hash_or[0][i], m,
"OR of all hash_32(%d) results = %#x (%#x expected)",
i, hash_or[0][i], m);
KUNIT_EXPECT_EQ_MSG(test, hash_or[1][i], m,
"OR of all hash_64(%d) results = %#x (%#x expected)",
i, hash_or[1][i], m);
}
if (hash_or[1][i] != m) {
pr_err("OR of all hash_64(%d) results = %#x "
"(%#x expected)", i, hash_or[1][i], m);
return -EINVAL;
}
}
pr_notice("%u tests passed.", tests);
return 0;
}
static void __init notice_skipped_tests(void)
{
/* Issue notices about skipped tests. */
#ifdef HAVE_ARCH__HASH_32
#if HAVE_ARCH__HASH_32 != 1
pr_info("__hash_32() is arch-specific; not compared to generic.");
#endif
#else
pr_info("__hash_32() has no arch implementation to test.");
#endif
#ifdef HAVE_ARCH_HASH_64
#if HAVE_ARCH_HASH_64 != 1
pr_info("hash_64() is arch-specific; not compared to generic.");
#endif
#else
pr_info("hash_64() has no arch implementation to test.");
#endif
}
static struct kunit_case hash_test_cases[] __refdata = {
KUNIT_CASE(test_string_or),
KUNIT_CASE(test_hash_or),
{}
};
static int __init
test_hash_init(void)
{
int ret;
static struct kunit_suite hash_test_suite = {
.name = "hash",
.test_cases = hash_test_cases,
};
ret = test_string_or();
if (ret < 0)
return ret;
ret = test_hash_or();
if (ret < 0)
return ret;
notice_skipped_tests();
return ret;
}
static void __exit test_hash_exit(void)
{
}
module_init(test_hash_init); /* Does everything */
module_exit(test_hash_exit); /* Does nothing */
kunit_test_suite(hash_test_suite);
MODULE_LICENSE("GPL");