May 2022 - Linux-kselftest-mirror

[PATCH] kselftest: alsa: handle cross compilation

by Antonio Terceiro

Calling just `pkg-config` is adequate for native builds, but finding the foreign libraries with pkg-config needs pkg-config to be called via its architecture-specific wrapper. This works in Debian, where there is a corresponding *-pkg-config wrapper script for each enabled foreign architecture, just like there are *-gcc, *-ld. Signed-off-by: Antonio Terceiro <antonio.terceiro(a)linaro.org> --- tools/testing/selftests/alsa/Makefile | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/testing/selftests/alsa/Makefile b/tools/testing/selftests/alsa/Makefile index f64d9090426d..f5675b3c929d 100644 --- a/tools/testing/selftests/alsa/Makefile +++ b/tools/testing/selftests/alsa/Makefile @@ -1,8 +1,10 @@ # SPDX-License-Identifier: GPL-2.0 # -CFLAGS += $(shell pkg-config --cflags alsa) -LDLIBS += $(shell pkg-config --libs alsa) +PKG_CONFIG ?= $(CROSS_COMPILE)pkg-config + +CFLAGS += $(shell $(PKG_CONFIG) --cflags alsa) +LDLIBS += $(shell $(PKG_CONFIG) --libs alsa) TEST_GEN_PROGS := mixer-test -- 2.35.1

2 years, 7 months

2
1
0 0

[PATCH bpf-next v3 0/7] bpf trampoline for arm64

by Xu Kuohai

Add bpf trampoline support for arm64. Most of the logic is the same as x86. Tested on qemu, result: #18 bpf_tcp_ca:OK #51 dummy_st_ops:OK #55 fentry_fexit:OK #56 fentry_test:OK #57 fexit_bpf2bpf:OK #58 fexit_sleep:OK #59 fexit_stress:OK #60 fexit_test:OK #67 get_func_args_test:OK #68 get_func_ip_test:OK #101 modify_return:OK #233 xdp_bpf2bpf:OK Also tested bpftrace kfunc/kretfunc and it worked fine. v3: - Append test results for bpf_tcp_ca, dummy_st_ops, fexit_bpf2bpf, xdp_bpf2bpf - Support to poke bpf progs - Fix return value of arch_prepare_bpf_trampoline() to the total number of bytes instead of number of instructions - Do not check whether CONFIG_DYNAMIC_FTRACE_WITH_REGS is enabled in arch_prepare_bpf_trampoline, since the trampoline may be hooked to a bpf prog - Restrict bpf_arch_text_poke() to poke bpf text only, as kernel functions are poked by ftrace - Rewrite trace_direct_tramp() in inline assembly in trace_selftest.c to avoid messing entry-ftrace.S - isolate arch_ftrace_set_direct_caller() with macro CONFIG_HAVE_DYNAMIC_FTRACE_WITH_DIRECT_CALLS to avoid compile error when this macro is disabled - Some trivial code sytle fixes v2: https://lore.kernel.org/bpf/20220414162220.1985095-1-xukuohai@huawei.com/ - Add Song's ACK - Change the multi-line comment in is_valid_bpf_tramp_flags() into net style (patch 3) - Fix a deadloop issue in ftrace selftest (patch 2) - Replace pt_regs->x0 with pt_regs->orig_x0 in patch 1 commit message - Replace "bpf trampoline" with "custom trampoline" in patch 1, as ftrace direct call is not only used by bpf trampoline. v1: https://lore.kernel.org/bpf/20220413054959.1053668-1-xukuohai@huawei.com/ Xu Kuohai (7): arm64: ftrace: Add ftrace direct call support ftrace: Fix deadloop caused by direct call in ftrace selftest bpf: Move is_valid_bpf_tramp_flags() to the public trampoline code bpf, arm64: Impelment bpf_arch_text_poke() for arm64 bpf, arm64: Support to poke bpf prog bpf, arm64: bpf trampoline for arm64 selftests/bpf: Fix trivial typo in fentry_fexit.c arch/arm64/Kconfig | 2 + arch/arm64/include/asm/ftrace.h | 12 + arch/arm64/kernel/asm-offsets.c | 1 + arch/arm64/kernel/entry-ftrace.S | 18 +- arch/arm64/net/bpf_jit.h | 8 + arch/arm64/net/bpf_jit_comp.c | 446 +++++++++++++++++- arch/x86/net/bpf_jit_comp.c | 20 - include/linux/bpf.h | 5 + kernel/bpf/bpf_struct_ops.c | 4 +- kernel/bpf/trampoline.c | 34 +- kernel/trace/trace_selftest.c | 16 + .../selftests/bpf/prog_tests/fentry_fexit.c | 4 +- 12 files changed, 531 insertions(+), 39 deletions(-) -- 2.30.2

2 years, 7 months

4
18
0 0

[PATCH 1/3] selftests: vm: add process_mrelease tests

by Suren Baghdasaryan

Introduce process_mrelease syscall sanity tests. They include tests of invalid pidfd and flags inputs, attempting to call process_mrelease with a live process and a valid usage of process_mrelease. Because process_mrelease has to be used against a process with a pending SIGKILL, it's possible that the process exits before process_mrelease gets called. In such cases we retry the test with a victim that allocates twice more memory up to 1GB. This would require the victim process to spend more time during exit and process_mrelease has a better chance of catching the process before it exits. Signed-off-by: Suren Baghdasaryan <surenb(a)google.com> --- tools/testing/selftests/vm/Makefile | 1 + tools/testing/selftests/vm/mrelease_test.c | 176 +++++++++++++++++++++ tools/testing/selftests/vm/run_vmtests.sh | 16 ++ 3 files changed, 193 insertions(+) create mode 100644 tools/testing/selftests/vm/mrelease_test.c diff --git a/tools/testing/selftests/vm/Makefile b/tools/testing/selftests/vm/Makefile index 04a49e876a46..733fccbff0ef 100644 --- a/tools/testing/selftests/vm/Makefile +++ b/tools/testing/selftests/vm/Makefile @@ -43,6 +43,7 @@ TEST_GEN_FILES += map_populate TEST_GEN_FILES += memfd_secret TEST_GEN_FILES += mlock-random-test TEST_GEN_FILES += mlock2-tests +TEST_GEN_FILES += mrelease_test TEST_GEN_FILES += mremap_dontunmap TEST_GEN_FILES += mremap_test TEST_GEN_FILES += on-fault-limit diff --git a/tools/testing/selftests/vm/mrelease_test.c b/tools/testing/selftests/vm/mrelease_test.c new file mode 100644 index 000000000000..a61061bf8433 --- /dev/null +++ b/tools/testing/selftests/vm/mrelease_test.c @@ -0,0 +1,176 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright 2022 Google LLC + */ +#define _GNU_SOURCE +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <sys/wait.h> +#include <unistd.h> + +#include "util.h" + +static inline int pidfd_open(pid_t pid, unsigned int flags) +{ +#ifdef __NR_pidfd_open + return syscall(__NR_pidfd_open, pid, flags); +#else + errno = ENOSYS; + return -1; +#endif +} + +static inline int process_mrelease(int pidfd, unsigned int flags) +{ +#ifdef __NR_process_mrelease + return syscall(__NR_process_mrelease, pidfd, flags); +#else + errno = ENOSYS; + return -1; +#endif +} + +static void write_fault_pages(char *addr, unsigned long nr_pages) +{ + unsigned long i; + + for (i = 0; i < nr_pages; i++) + *((unsigned long *)(addr + (i * PAGE_SIZE))) = i; +} + +static int alloc_noexit(unsigned long nr_pages, int pipefd) +{ + int ppid = getppid(); + void *buf; + + buf = mmap(NULL, nr_pages * PAGE_SIZE, PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANON, 0, 0); + if (buf == MAP_FAILED) { + perror("mmap"); + return 1; + } + + write_fault_pages((char *)buf, nr_pages); + + /* Signal the parent that the child is ready */ + if (write(pipefd, "", 1) < 0) { + perror("write"); + return 1; + } + + /* Wait to be killed (when reparenting happens) */ + while (getppid() == ppid) + sleep(1); + + munmap(buf, nr_pages * PAGE_SIZE); + + return 0; +} + + +#define MB(x) (x << 20) +#define MAX_SIZE_MB 1024 + +int main(void) +{ + int res; + int pipefd[2], pidfd; + pid_t pid; + char byte; + size_t size; + int negative_tests_done = 0; + + /* Test a wrong pidfd */ + if (!process_mrelease(-1, 0) || errno != EBADF) { + perror("process_mrelease with wring pidfd"); + exit(1); + } + + /* + * Start the test with 1MB allocation and double every time + * process_mrelease fails + */ + for (size = 1; size <= MAX_SIZE_MB; size *= 2) { + /* + * Pipe for the child to signal when it's done allocating + * memory + */ + if (pipe(pipefd)) { + perror("pipe"); + exit(1); + } + pid = fork(); + if (pid < 0) { + perror("fork"); + exit(1); + } + + if (pid == 0) { + close(pipefd[0]); + res = alloc_noexit(MB(size) / PAGE_SIZE, pipefd[1]); + close(pipefd[1]); + exit(res); + } + + close(pipefd[1]); + /* Block until the child is ready */ + res = read(pipefd[0], &byte, 1); + close(pipefd[0]); + if (res < 0) { + perror("read"); + exit(1); + } + + pidfd = pidfd_open(pid, 0); + if (pidfd < 0) { + perror("pidfd_open"); + exit(1); + } + + /* Run negative tests which require a valid child only once */ + if (!negative_tests_done) { + /* Test invalid flags */ + if (!process_mrelease(pidfd, (unsigned int)-1) || + errno != EINVAL) { + perror("process_mrelease with wrong flags"); + exit(1); + } + /* Test reapling while process is still alive */ + if (!process_mrelease(pidfd, 0) || + errno != EINVAL) { + perror("process_mrelease on a live process"); + exit(1); + } + negative_tests_done = 1; + } + + if (kill(pid, SIGKILL)) { + perror("kill"); + exit(1); + } + + if (!process_mrelease(pidfd, 0)) { + /* Terminate the test once process_mrelease succeeds */ + return 0; + } + + /* + * Ignore the failure if the child exited before mrelease got + * called, increase allocation size and retry the test + */ + if (errno != ESRCH) { + perror("process_mrelease"); + exit(1); + } + + if (waitpid(pid, NULL, 0) < 0) { + perror("waitpid"); + exit(1); + } + close(pidfd); + } + + printf("All process_mrelease attempts failed!\n"); + exit(1); +} diff --git a/tools/testing/selftests/vm/run_vmtests.sh b/tools/testing/selftests/vm/run_vmtests.sh index 352ba00cf26b..1986162fea39 100755 --- a/tools/testing/selftests/vm/run_vmtests.sh +++ b/tools/testing/selftests/vm/run_vmtests.sh @@ -287,6 +287,22 @@ else echo "[PASS]" fi +echo "---------------------" +echo "running mrelease_test" +echo "---------------------" +./mrelease_test +ret_val=$? + +if [ $ret_val -eq 0 ]; then + echo "[PASS]" +elif [ $ret_val -eq $ksft_skip ]; then + echo "[SKIP]" + exitcode=$ksft_skip +else + echo "[FAIL]" + exitcode=1 +fi + echo "-------------------" echo "running mremap_test" echo "-------------------" -- 2.36.0.512.ge40c2bad7a-goog

2 years, 7 months

3
16
0 0

[PATCH v1 0/5] selftests/arm64: MTE check_tags_inclusion cleanups

by Mark Brown

This series contains some random cleanups and improvements that I came up with while looking at the check_tags_inclusion test. There's nothing too exciting in here but the changes did seem like they might help the next person to look at this. Mark Brown (5): selftests/arm64: Log errors in verify_mte_pointer_validity() selftests/arm64: Allow zero tags in mte_switch_mode() selftests/arm64: Check failures to set tags in check_tags_inclusion selftests/arm64: Remove casts to/from void in check_tags_inclusion selftests/arm64: Use switch statements in mte_common_util.c .../arm64/mte/check_tags_inclusion.c | 54 +++++++++++-------- .../selftests/arm64/mte/mte_common_util.c | 25 ++++++--- 2 files changed, 50 insertions(+), 29 deletions(-) base-commit: ae60e0763e97e977b03af1ac6ba782a4a86c3a5a -- 2.30.2

2 years, 7 months

3
10
0 0

[PATCH] selftests: KVM: aarch64: Let hypercalls use UAPI *_BIT_COUNT

by Raghavendra Rao Ananta

The hypercalls test currently defines its own *_BMAP_BIT_MAX macros to define the last valid feature bit for each bitmap firmware register. However, since these definitions are already present in the uapi header, kvm.h, as *_BMAP_BIT_COUNT, and would help to keep the test updated as features grow, use these instead. No functional change intended. Signed-off-by: Raghavendra Rao Ananta <rananta(a)google.com> --- tools/testing/selftests/kvm/aarch64/hypercalls.c | 13 ++++--------- 1 file changed, 4 insertions(+), 9 deletions(-) diff --git a/tools/testing/selftests/kvm/aarch64/hypercalls.c b/tools/testing/selftests/kvm/aarch64/hypercalls.c index 41e0210b7a5e..dea019ec4dd9 100644 --- a/tools/testing/selftests/kvm/aarch64/hypercalls.c +++ b/tools/testing/selftests/kvm/aarch64/hypercalls.c @@ -18,20 +18,15 @@ #define FW_REG_ULIMIT_VAL(max_feat_bit) (GENMASK(max_feat_bit, 0)) -/* Last valid bits of the bitmapped firmware registers */ -#define KVM_REG_ARM_STD_BMAP_BIT_MAX 0 -#define KVM_REG_ARM_STD_HYP_BMAP_BIT_MAX 0 -#define KVM_REG_ARM_VENDOR_HYP_BMAP_BIT_MAX 1 - struct kvm_fw_reg_info { uint64_t reg; /* Register definition */ uint64_t max_feat_bit; /* Bit that represents the upper limit of the feature-map */ }; -#define FW_REG_INFO(r) \ - { \ - .reg = r, \ - .max_feat_bit = r##_BIT_MAX, \ +#define FW_REG_INFO(r) \ + { \ + .reg = r, \ + .max_feat_bit = r##_BIT_COUNT - 1, \ } static const struct kvm_fw_reg_info fw_reg_info[] = { -- 2.36.0.512.ge40c2bad7a-goog

2 years, 7 months

4
4
0 0

[PATCH] selftests/powerpc/pmu: Fix unsigned function returning negative constant

by Haowen Bai

The function __perf_reg_mask has an unsigned return type, but returns a negative constant to indicate an error condition. So we change unsigned to int. Signed-off-by: Haowen Bai <baihaowen(a)meizu.com> --- tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c b/tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c index fca054bbc094..c01a31d5f4ee 100644 --- a/tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c +++ b/tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c @@ -274,7 +274,7 @@ u64 *get_intr_regs(struct event *event, void *sample_buff) return intr_regs; } -static const unsigned int __perf_reg_mask(const char *register_name) +static const int __perf_reg_mask(const char *register_name) { if (!strcmp(register_name, "R0")) return 0; -- 2.7.4

2 years, 7 months

3
3
0 0

[RFC] KTAP spec v2: prefix to KTAP data

by Frank Rowand

In the middle of the "RFC - kernel test result specification (KTAP)" thread, started in August 2021, Tim Bird made a suggestion to allow a prefix to the KTAP data format: > Just as a side note, in some Fuego tests, it was very useful to include an identifier > in thethe prefix nested tests. The output looked like this: > > TAP version 13 > 1..2 > [batch_id 4] TAP version 13 > [batch_id 4] 1..2 > [batch_id 4] ok 1 - cyclictest with 1000 cycles > [batch_id 4] # problem setting CLOCK_REALTIME > [batch_id 4] not ok 2 - cyclictest with CLOCK_REALTIME > not ok 1 - check realtime > [batch_id 4] TAP version 13 > [batch_id 4] 1..1 > [batch_id 4] ok 1 - IOZone read/write 4k blocks > ok 2 - check I/O performance > > Can I propose that the prefix not be fixed by the spec, but that the spec indicates that > whatever the prefix is on the TAP version line, that prefix must be used with the output for > all lines from the test (with the exception of unknown lines)? The thread was discussing many other items, but this is the one that I want to focus on in this new RFC thread. Tim's original email was: https://lore.kernel.org/r/BYAPR13MB2503A4B79074D8ED5579345DFDCB9@BYAPR13MB2… There was one reply to this that commented on Tim's suggestion (and also many other items in the thread) at: https://lore.kernel.org/r/202108301226.800F3D6D4@keescook > Oh, interesting. This would also allow parallel (unique) test execution > to be parsable. That sounds workable. (Again, this needs LAVA patching > again...) I found Tim's original suggestion to be useful, so I have come up with two possible ways to modify the KTAP specification to implement what Tim was thinking about. I would not be surprised if someone else has a better suggestion than mine, but I will reply to this email with my two alternatives to start a discussion. My alternatives are not in the form of patches, but if discussion leads to a good result then I will create a patch for review. -Frank

2 years, 7 months

4
7
0 0

[PATCHv2 bpf-next 0/2] selftests/bpf: fix ima_setup.sh missing issue

by Hangbin Liu

The ima_setup.sh is needed by test_progs test_ima. But the file is missed if we build test_progs separately or installed bpf test to another folder. This patch set fixed the issue in 2 different scenarios. v2: no code update, just repost to bpf-next Hangbin Liu (2): selftests/bpf: Fix build error with ima_setup.sh selftests/bpf: add missed ima_setup.sh in Makefile tools/testing/selftests/bpf/Makefile | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) -- 2.35.1

2 years, 7 months

3
4
0 0

[PATCH] kseltest/cgroup: Make test_stress.sh work if run interactively

by Waiman Long

Commit 54de76c01239 ("kselftest/cgroup: fix test_stress.sh to use OUTPUT dir") changes the test_core command path from . to $OUTPUT. However, variable OUTPUT may not be defined if the command is run interactively. Fix that by using ${OUTPUT:-.} to cover both cases. Signed-off-by: Waiman Long <longman(a)redhat.com> --- tools/testing/selftests/cgroup/test_stress.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/testing/selftests/cgroup/test_stress.sh b/tools/testing/selftests/cgroup/test_stress.sh index 109c044f715f..3c9c4554d5f6 100755 --- a/tools/testing/selftests/cgroup/test_stress.sh +++ b/tools/testing/selftests/cgroup/test_stress.sh @@ -1,4 +1,4 @@ #!/bin/bash # SPDX-License-Identifier: GPL-2.0 -./with_stress.sh -s subsys -s fork ${OUTPUT}/test_core +./with_stress.sh -s subsys -s fork ${OUTPUT:-.}/test_core -- 2.27.0

2 years, 7 months

3
2
0 0

[PATCH] lib/atomic64_test.c: convert to use KUnit

by Daniel Latypov

The test currently is a bunch of checks (implemented using BUG_ON()) that can be built into the kernel or as a module. Convert it to a KUnit test, which can also run in both modes. From a user's perspective, this change adds a CONFIG_KUNIT=y dep and changes the output format of the test [1]. The test itself is the same. This hopefully makes the test easier to run and more consistent with similar tests in lib/. Since it has no dependencies, it can be run without explicitly setting up a .kunitconfig via $ ./tools/testing/kunit/kunit.py run atomic ... [13:53:44] Starting KUnit Kernel (1/1)... [13:53:44] ============================================================ [13:53:47] =================== atomic (2 subtests) ==================== [13:53:47] [PASSED] test_atomic [13:53:47] [PASSED] test_atomic64 [13:53:47] ===================== [PASSED] atomic ====================== [13:53:47] ============================================================ [13:53:47] Testing complete. Passed: 2, Failed: 0, Crashed: 0, Skipped: 0, Errors: 0 [13:53:47] Elapsed time: 13.902s total, 1.629s configuring, 9.331s building, 2.852s running It can be run on ARCH=x86_64 (and others) via: $ ./tools/testing/kunit/kunit.py run --arch=x86_64 atomic The message about which platform the test ran on won't show up in kunit.py, but still gets printed out in dmesg, e.g. > TAP version 14 > 1..1 > # Subtest: atomic > 1..2 > ok 1 - test_atomic > ok 2 - test_atomic64 > # atomic: ran on x86-64 platform with CX8 and with SSE > # atomic: pass:2 fail:0 skip:0 total:2 > # Totals: pass:2 fail:0 skip:0 total:2 > ok 1 - atomic Signed-off-by: Daniel Latypov <dlatypov(a)google.com> [1] https://www.kernel.org/doc/html/latest/dev-tools/ktap.html --- Meta: 1. this patch applies on top of the kunit branch, https://git.kernel.org/pub/scm/linux/kernel/git/shuah/linux-kselftest.git/?… 2. checkpatch complains about aligning with parens, but it wants me to indent the `#ifdef CONFIG_X86_64` which seems inappropriate in context. 3. this file doesn't seem to have a clear maintainer, so I assume this conversion is fine to go through the kunit branch. The only observable differences are the new CONFIG_KUNIT=y dep and more standardized (KTAP) output format. --- lib/Kconfig.debug | 4 +- lib/atomic64_test.c | 107 +++++++++++++++++++++----------------------- 2 files changed, 55 insertions(+), 56 deletions(-) diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 075cd25363ac..4cf8d5feda0a 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2223,7 +2223,9 @@ config PERCPU_TEST If unsure, say N. config ATOMIC64_SELFTEST - tristate "Perform an atomic64_t self-test" + tristate "Perform an atomic64_t self-test" if !KUNIT_ALL_TESTS + depends on KUNIT + default KUNIT_ALL_TESTS help Enable this option to test the atomic64_t functions at boot or at module load time. diff --git a/lib/atomic64_test.c b/lib/atomic64_test.c index d9d170238165..46cb0130f8d0 100644 --- a/lib/atomic64_test.c +++ b/lib/atomic64_test.c @@ -5,13 +5,9 @@ * Copyright © 2010 Luca Barbieri */ -#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt +#include <kunit/test.h> -#include <linux/init.h> -#include <linux/bug.h> -#include <linux/kernel.h> #include <linux/atomic.h> -#include <linux/module.h> #ifdef CONFIG_X86 #include <asm/cpufeature.h> /* for boot_cpu_has below */ @@ -23,9 +19,7 @@ do { \ r = v0; \ atomic##bit##_##op(val, &v); \ r c_op val; \ - WARN(atomic##bit##_read(&v) != r, "%Lx != %Lx\n", \ - (unsigned long long)atomic##bit##_read(&v), \ - (unsigned long long)r); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_read(&v), r); \ } while (0) /* @@ -46,8 +40,8 @@ do { \ atomic##bit##_set(&v, v0); \ r = v0; \ r c_op val; \ - BUG_ON(atomic##bit##_##op(val, &v) != r); \ - BUG_ON(atomic##bit##_read(&v) != r); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_##op(val, &v), r); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_read(&v), r); \ } while (0) #define TEST_FETCH(bit, op, c_op, val) \ @@ -55,8 +49,8 @@ do { \ atomic##bit##_set(&v, v0); \ r = v0; \ r c_op val; \ - BUG_ON(atomic##bit##_##op(val, &v) != v0); \ - BUG_ON(atomic##bit##_read(&v) != r); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_##op(val, &v), v0); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_read(&v), r); \ } while (0) #define RETURN_FAMILY_TEST(bit, op, c_op, val) \ @@ -72,8 +66,8 @@ do { \ #define TEST_ARGS(bit, op, init, ret, expect, args...) \ do { \ atomic##bit##_set(&v, init); \ - BUG_ON(atomic##bit##_##op(&v, ##args) != ret); \ - BUG_ON(atomic##bit##_read(&v) != expect); \ + KUNIT_ASSERT_EQ(test, atomic##bit##_##op(&v, ##args), ret);\ + KUNIT_ASSERT_EQ(test, atomic##bit##_read(&v), expect); \ } while (0) #define XCHG_FAMILY_TEST(bit, init, new) \ @@ -101,7 +95,7 @@ do { \ i, (i) - one, (i) - one); \ } while (0) -static __init void test_atomic(void) +static void test_atomic(struct kunit *test) { int v0 = 0xaaa31337; int v1 = 0xdeadbeef; @@ -144,7 +138,7 @@ static __init void test_atomic(void) } #define INIT(c) do { atomic64_set(&v, c); r = c; } while (0) -static __init void test_atomic64(void) +static void test_atomic64(struct kunit *test) { long long v0 = 0xaaa31337c001d00dLL; long long v1 = 0xdeadbeefdeafcafeLL; @@ -156,12 +150,12 @@ static __init void test_atomic64(void) atomic64_t v = ATOMIC64_INIT(v0); long long r = v0; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); atomic64_set(&v, v1); r = v1; - BUG_ON(v.counter != r); - BUG_ON(atomic64_read(&v) != r); + KUNIT_ASSERT_EQ(test, v.counter, r); + KUNIT_ASSERT_EQ(test, atomic64_read(&v), r); TEST(64, add, +=, onestwos); TEST(64, add, +=, -one); @@ -190,12 +184,12 @@ static __init void test_atomic64(void) INIT(v0); atomic64_inc(&v); r += one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(v0); atomic64_dec(&v); r -= one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); INC_RETURN_FAMILY_TEST(64, v0); DEC_RETURN_FAMILY_TEST(64, v0); @@ -204,73 +198,76 @@ static __init void test_atomic64(void) CMPXCHG_FAMILY_TEST(64, v0, v1, v2); INIT(v0); - BUG_ON(atomic64_add_unless(&v, one, v0)); - BUG_ON(v.counter != r); + KUNIT_ASSERT_FALSE(test, atomic64_add_unless(&v, one, v0)); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(v0); - BUG_ON(!atomic64_add_unless(&v, one, v1)); + KUNIT_ASSERT_TRUE(test, atomic64_add_unless(&v, one, v1)); r += one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(onestwos); - BUG_ON(atomic64_dec_if_positive(&v) != (onestwos - 1)); + KUNIT_ASSERT_EQ(test, atomic64_dec_if_positive(&v), (onestwos - 1)); r -= one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(0); - BUG_ON(atomic64_dec_if_positive(&v) != -one); - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, atomic64_dec_if_positive(&v), -one); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(-one); - BUG_ON(atomic64_dec_if_positive(&v) != (-one - one)); - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, atomic64_dec_if_positive(&v), (-one - one)); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(onestwos); - BUG_ON(!atomic64_inc_not_zero(&v)); + KUNIT_ASSERT_TRUE(test, atomic64_inc_not_zero(&v)); r += one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(0); - BUG_ON(atomic64_inc_not_zero(&v)); - BUG_ON(v.counter != r); + KUNIT_ASSERT_FALSE(test, atomic64_inc_not_zero(&v)); + KUNIT_ASSERT_EQ(test, v.counter, r); INIT(-one); - BUG_ON(!atomic64_inc_not_zero(&v)); + KUNIT_ASSERT_TRUE(test, atomic64_inc_not_zero(&v)); r += one; - BUG_ON(v.counter != r); + KUNIT_ASSERT_EQ(test, v.counter, r); /* Confirm the return value fits in an int, even if the value doesn't */ INIT(v3); + r_int = atomic64_inc_not_zero(&v); - BUG_ON(!r_int); + KUNIT_ASSERT_NE(test, r_int, 0); } -static __init int test_atomics_init(void) -{ - test_atomic(); - test_atomic64(); +static struct kunit_case atomic_test_cases[] = { + KUNIT_CASE(test_atomic), + KUNIT_CASE(test_atomic64), + {}, +}; +static void atomic_suite_exit(struct kunit_suite *suite) +{ #ifdef CONFIG_X86 - pr_info("passed for %s platform %s CX8 and %s SSE\n", + kunit_info(suite, "ran on %s platform %s CX8 and %s SSE\n", #ifdef CONFIG_X86_64 - "x86-64", + "x86-64", #elif defined(CONFIG_X86_CMPXCHG64) - "i586+", + "i586+", #else - "i386+", + "i386+", #endif - boot_cpu_has(X86_FEATURE_CX8) ? "with" : "without", - boot_cpu_has(X86_FEATURE_XMM) ? "with" : "without"); -#else - pr_info("passed\n"); + boot_cpu_has(X86_FEATURE_CX8) ? "with" : "without", + boot_cpu_has(X86_FEATURE_XMM) ? "with" : "without"); #endif - - return 0; } -static __exit void test_atomics_exit(void) {} +static struct kunit_suite atomic_test_suite = { + .name = "atomic", + .test_cases = atomic_test_cases, + .suite_exit = atomic_suite_exit, +}; -module_init(test_atomics_init); -module_exit(test_atomics_exit); +kunit_test_suites(&atomic_test_suite); MODULE_LICENSE("GPL"); base-commit: 38289a26e1b8a37755f3e07056ca416c1ee2a2e8 -- 2.36.0.464.gb9c8b46e94-goog

2 years, 7 months

4
4
0 0

2024

2023

2022

2021

2020

2019

2018

2017

Linux-kselftest-mirror May 2022