From: sashiko-bot@kernel.org
To: "Zhanpeng Zhang" <zhangzhanpeng.jasper@bytedance.com>
Cc: linux-perf-users@vger.kernel.org
Subject: Re: [PATCH v13 10/11] selftests/riscv: add SSE test module
Date: Thu, 19 Nov 2026 12:37:13 +0000 [thread overview]
Message-ID: <sashiko-outbox-223098@kernel.org> (raw)
In-Reply-To: <20261119120824.13969-23-zhangzhanpeng.jasper@bytedance.com>
Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [Medium] selftests/riscv: sse: deadlock between migrate_disable() and
cpus_read_lock()
- [Medium] selftests/riscv: sse: fast test ignores errors and races on
1-jiffy timeout
- [Medium] selftests/riscv: sse: stress test treats -EEXIST as failure
instead of skip
- [Medium] selftests/riscv: sse module Makefile defaults KDIR to host
/lib/modules
- [Low] selftests/riscv: sse: stale pointers left in priority_test_arg
on teardown
- [Low] selftests/riscv: sse: swapped log args in sse_test_handler() and
dead field
- [Low] selftests/riscv: run_sse_test.sh added with non-executable mode
0644
--
commit e938d689e90e8ec77bc093b9edf15fcf64552952
Author: Clément Léger <cleger@rivosinc.com>
selftests/riscv: add SSE test module
This commit adds a kernel module and kselftest runner script to test the
RISC-V SBI Supervisor Software Events (SSE) framework, including fast
injection, event priority chaining, and stress modes.
> diff --git a/tools/testing/selftests/riscv/sse/module/Makefile b/tools/testing/selftests/riscv/sse/module/Makefile
> new file mode 100644
> index 0000000000000..eac4b1c6228bb
> --- /dev/null
> +++ b/tools/testing/selftests/riscv/sse/module/Makefile
> @@ -0,0 +1,22 @@
> +ifneq ($(CONFIG_RISCV_SBI_SSE),)
> +obj-m += riscv_sse_test.o
> +endif
> +
> +ifndef KERNELRELEASE
> +
> +TESTMODS_DIR := $(realpath $(dir $(abspath $(lastword $(MAKEFILE_LIST)))))
> +KDIR ?= /lib/modules/$(shell uname -r)/build
> +
> +# Ensure that KDIR exists, otherwise skip the compilation
> +modules:
> +ifneq ("$(wildcard $(KDIR))", "")
> + $(Q)$(MAKE) -C $(KDIR) modules KBUILD_EXTMOD=$(TESTMODS_DIR)
> +endif
[Severity: Medium]
Does defaulting KDIR to /lib/modules/$(shell uname -r)/build break
cross-compilation and in-tree or O= builds?
When cross-compiling with ARCH=riscv on a non-RISC-V host where
/lib/modules/$(uname -r)/build exists, Kbuild runs against the host kernel
headers with ARCH=riscv and fails. When /lib/modules/$(uname -r)/build is
absent or points to a running kernel without CONFIG_RISCV_SBI_SSE,
riscv_sse_test.ko is silently skipped instead of building against the
target kernel tree. Other selftest modules (such as
tools/testing/selftests/mm/page_frag/Makefile) resolve KDIR from O,
KBUILD_OUTPUT, or $(abs_srctree).
> diff --git a/tools/testing/selftests/riscv/sse/module/riscv_sse_test.c b/tools/testing/selftests/riscv/sse/module/riscv_sse_test.c
> new file mode 100644
> index 0000000000000..cc5c2e46f2fdb
> --- /dev/null
> +++ b/tools/testing/selftests/riscv/sse/module/riscv_sse_test.c
[ ... ]
> +static int sse_test_handler(u32 evt, void *arg, struct pt_regs *regs)
> +{
> + int ret = 0;
> + struct fast_test_arg *targ = arg;
> + u32 test_evt;
> + int cpu;
> +
> + atomic_inc(&sse_test_handler_count);
> +
> + /* Pairs with the argument publication in sse_run_fast_test_cpu(). */
> + if (!smp_load_acquire(&targ->args_ready)) {
> + sse_err("Received SSE event %x before its test arguments were published\n",
> + evt);
> + ret = -EINVAL;
> + goto complete;
> + }
> +
> + test_evt = READ_ONCE(targ->evt);
> + cpu = READ_ONCE(targ->cpu);
> +
> + if (evt != test_evt) {
> + sse_err("Received SSE event id %x instead of %x\n", test_evt, evt);
> + ret = -EINVAL;
> + }
[Severity: Low]
Are test_evt and evt swapped in this sse_err() call? evt is the received
event ID and test_evt is the expected one.
Also, struct priority_test_arg below defines an unused check_func member.
[ ... ]
> +static int sse_run_fast_test_cpu(struct fast_test_arg *test_arg,
> + struct sse_event *event, u32 evt, int cpu)
> +{
> + unsigned long timeout;
> + int ret;
> +
> + WRITE_ONCE(test_arg->completion, false);
> + WRITE_ONCE(test_arg->args_ready, false);
> + WRITE_ONCE(test_arg->evt, evt);
> + WRITE_ONCE(test_arg->cpu, cpu);
> + /* Publish all arguments before firmware can inject on another hart. */
> + smp_store_release(&test_arg->args_ready, true);
> +
> + ret = sse_test_inject_event(event, evt, cpu);
> + if (ret) {
> + sse_err("event %s injection failed, err %d\n",
> + sse_evt_name(evt), ret);
> + return ret;
> + }
> +
> + timeout = jiffies + HZ / 100;
> + /* We can not use <linux/completion.h> since they are not NMI safe */
> + /* Pairs with the handler's completion publication. */
> + while (!smp_load_acquire(&test_arg->completion) &&
> + time_before(jiffies, timeout))
> + cpu_relax();
> + /* Acquire the handler's checks even if the loop observed a timeout. */
> + if (!smp_load_acquire(&test_arg->completion)) {
> + sse_err("Failed to wait for event %s completion on CPU %d\n",
> + sse_evt_name(evt), cpu);
> + return -ETIMEDOUT;
> + }
> +
> + return sse_test_wait_not_running_on_cpu(evt, cpu);
> +}
> +
> +static void sse_run_fast_test(struct fast_test_arg *test_arg,
> + struct sse_event *event, u32 evt)
> +{
> + int cpu;
> +
> + if (sse_event_is_global(evt)) {
> + /* Keep the selected target online through injection and completion. */
> + cpu_hotplug_disable();
> + for_each_online_cpu(cpu) {
> + if (sse_run_fast_test_cpu(test_arg, event, evt, cpu))
> + break;
> + }
> + cpu_hotplug_enable();
> + return;
> + }
> +
> + guard(cpus_read_lock)();
> + for_each_online_cpu(cpu) {
> + if (sse_run_fast_test_cpu(test_arg, event, evt, cpu))
> + return;
> + }
> +}
> +
> +static void sse_test_injection_fast(void)
> +{
[ ... ]
> + for (j = 0; j < RUN_LOOP_COUNT; j++)
> + sse_run_fast_test(&fast_test_arg, event, evt);
[Severity: Medium]
Can a timeout in sse_run_fast_test_cpu() race with an in-flight handler on
fast_test_arg across the remaining RUN_LOOP_COUNT iterations?
With CONFIG_HZ=100, HZ / 100 is 1 jiffy, which can expire on the next
timer tick while waiting for a remote CPU. On timeout,
sse_run_fast_test_cpu() returns without calling
sse_test_wait_not_running_on_cpu(), and sse_run_fast_test() discards the
error so sse_test_injection_fast() immediately starts the next iteration
and overwrites the shared static fast_test_arg while the delayed handler
may still be running (or stalls module load if all 1,000 iterations time
out). In addition, non-timeout errors in
sse_test_wait_not_running_on_cpu() (-ENOMEM or smp_call_function_single()
and sse_event_attr_read() failures) return without logging sse_err(), so
run_sse_test.sh will not detect them.
[ ... ]
> +static void sse_test_injection_priority_arg(struct priority_test_arg *args, unsigned int args_size,
> + sse_event_handler_fn handler, const char *test_name)
> +{
> + unsigned int i;
> + unsigned long timeout;
> + int ret;
> + int target_cpu;
> + struct sse_event *event;
> + struct priority_test_arg *arg, *first_arg = NULL, *prev_arg = NULL;
> +
> + pr_info("Starting SSE priority test (%s)\n", test_name);
> + /* Keep the complete priority chain on one CPU. */
> + migrate_disable();
> + target_cpu = smp_processor_id();
> +
> + for (i = 0; i < args_size; i++) {
> + arg = &args[i];
> +
> + if (!sse_test_can_inject_event(arg->evt))
> + continue;
> +
> + WRITE_ONCE(arg->called, false);
> + WRITE_ONCE(arg->next_evt_arg, NULL);
> + WRITE_ONCE(arg->event, NULL);
> + WRITE_ONCE(arg->enable_attempted, false);
> +
> + event = sse_test_event_register(arg->evt, arg->prio, handler,
> + (void *)arg);
[Severity: Medium]
Can calling sse_test_event_register() and the other SSE helpers inside
migrate_disable() deadlock with CPU hotplug?
migrate_disable() pins the task to target_cpu without blocking CPU
hotplug, while sse_event_register(), sse_event_set_target_cpu(),
sse_event_enable(), sse_event_disable(), and sse_event_unregister() each
acquire cpus_read_lock() internally:
CPU0 (target_cpu) CPU1
----------------- ----
sse_test_injection_priority_arg()
migrate_disable()
_cpu_down(target_cpu)
cpus_write_lock()
...
sched_cpu_wait_empty()
balance_hotplug_wait()
sse_test_event_register()
sse_event_register()
mutex_lock(&sse_mutex)
cpus_read_lock()
*** DEADLOCK ***
CPU1 holds cpus_write_lock() and waits in balance_hotplug_wait() for
pinned tasks on target_cpu to call migrate_enable(), while CPU0 is pinned
to target_cpu and blocks in cpus_read_lock() (also holding sse_mutex).
Surrounding the migrate_disable() section with cpu_hotplug_disable() and
cpu_hotplug_enable() avoids the lock inversion and prevents
sse_cpu_teardown() from tearing down SSE on target_cpu mid-test.
[ ... ]
> +release_events:
> +
> + for (i = 0; i < args_size; i++) {
> + arg = &args[i];
> + event = arg->event;
> + if (!event)
> + continue;
> +
> + ret = sse_test_wait_not_running_on_cpu(arg->evt, target_cpu);
> + if (ret)
> + sse_err("Event %s did not complete, err %d\n",
> + sse_evt_name(arg->evt), ret);
> +
> + if (arg->enable_attempted) {
> + ret = sse_event_disable(event);
> + if (ret) {
> + sse_err("Failed to disable event %s, err %d\n",
> + sse_evt_name(arg->evt), ret);
> + sse_test_queue_cleanup(event);
> + WRITE_ONCE(arg->event, NULL);
> + WRITE_ONCE(arg->enable_attempted, false);
> + continue;
> + }
> + }
> +
> + ret = sse_test_event_unregister(event);
> + if (ret) {
> + sse_err("Failed to unregister event %s, err %d\n",
> + sse_evt_name(arg->evt), ret);
> + continue;
> + }
> +
> + WRITE_ONCE(arg->event, NULL);
> + WRITE_ONCE(arg->enable_attempted, false);
> + }
[Severity: Low]
Does release_events leave stale pointers in priority_test_arg when disable
or unregister fails?
When sse_test_event_unregister() fails, it queues event for deferred
freeing via sse_test_queue_cleanup(), but the error branch jumps to the
next iteration before clearing arg->event and arg->enable_attempted.
Also, release_events never clears arg->next_evt_arg, so if an event fails
to disable or unregister and fires late after its successor in args[] has
been unregistered, the handler will read a non-NULL targ->next_evt_arg and
signal the unregistered successor event.
[ ... ]
> +static int sse_stress_test_layer(int layer)
> +{
[ ... ]
> + event = sse_test_event_register(stress_ctx.evt_id, 0,
> + stress_handlers[layer], &stress_ctx);
> + if (IS_ERR(event)) {
> + sse_err("Failed to register stress event, err %ld\n",
> + PTR_ERR(event));
> + return PTR_ERR(event);
> + }
[ ... ]
> +static void sse_stress_test_all_layers(void)
> +{
> + int i, ret;
> +
> + pr_info("Starting SSE stress tests: duration=%d ms, interval=%d ns\n",
> + STRESS_DURATION_MS, STRESS_INJECT_NS);
> +
> + for (i = 0; i < ARRAY_SIZE(stress_handlers); i++) {
> + ret = sse_stress_test_layer(i);
> + if (ret) {
> + sse_err("Stress layer %d failed, err %d\n", i, ret);
> + break;
> + }
[Severity: Medium]
Should sse_stress_test_layer() skip rather than fail when
sse_test_event_register() returns -EEXIST?
Unlike sse_test_injection_fast() and sse_test_injection_priority_arg(),
sse_stress_test_layer() and sse_stress_test_all_layers() log sse_err() on
-EEXIST. Because run_sse_test.sh checks for FAILED: before SKIP:,
running with stress=1 or stress=2 when
SBI_SSE_EVENT_LOCAL_SOFTWARE_INJECTED is already registered exits with
failure (1) instead of ksft_skip (4).
> diff --git a/tools/testing/selftests/riscv/sse/run_sse_test.sh b/tools/testing/selftests/riscv/sse/run_sse_test.sh
> new file mode 100644
> index 0000000000000..e70a2fd14b05e
> --- /dev/null
> +++ b/tools/testing/selftests/riscv/sse/run_sse_test.sh
> @@ -0,0 +1,59 @@
> +#!/bin/bash
> +# SPDX-License-Identifier: GPL-2.0
[Severity: Low]
Should run_sse_test.sh have mode 0755 instead of 0644?
Because the script is not executable, invoking ./run_sse_test.sh directly
fails with permission denied, and tools/testing/selftests/kselftest/runner.sh
logs a warning and takes its non-executable fallback path, which drops
kselftest_cmd_args instead of forwarding module arguments such as stress=1
to insmod.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119120824.13969-13-zhangzhanpeng.jasper@bytedance.com?part=10
next prev parent reply other threads:[~2026-11-19 12:37 UTC|newest]
Thread overview: 38+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-19 12:08 [PATCH v13 00/11] riscv: add SBI Supervisor Software Events support Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:08 ` [PATCH v13 01/11] riscv: add SBI SSE extension definitions Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:14 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 02/11] riscv: add support for SBI Supervisor Software Events extension Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:36 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 03/11] riscv: sse: mask events during shutdown and kexec Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:38 ` sashiko-bot
2026-11-19 13:44 ` Clement Leger
2026-11-19 13:44 ` Clement Leger
2026-11-19 12:08 ` [PATCH v13 04/11] drivers: firmware: add riscv SSE support Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:38 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 05/11] riscv: mm: avoid enabling interrupts for nofault page faults Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:27 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 06/11] riscv: enable NMI-safe lockdep irqflags tracking Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:21 ` sashiko-bot
2026-11-19 13:46 ` Clement Leger
2026-11-19 13:46 ` Clement Leger
2026-11-19 12:08 ` [PATCH v13 07/11] perf: RISC-V: support callchains with SSE delivery Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:45 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 08/11] perf: RISC-V: add support for SSE event Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:34 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 09/11] MAINTAINERS: add RISC-V SSE maintainers and file coverage Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:08 ` [PATCH v13 10/11] selftests/riscv: add SSE test module Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:37 ` sashiko-bot [this message]
2026-11-19 12:08 ` [PATCH v13 11/11] selftests/riscv: add perf user-stack SSE copy regression test Zhanpeng Zhang
2026-11-19 12:08 ` Zhanpeng Zhang
2026-11-19 12:34 ` sashiko-bot
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=sashiko-outbox-223098@kernel.org \
--to=sashiko-bot@kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=sashiko-reviews@lists.linux.dev \
--cc=zhangzhanpeng.jasper@bytedance.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.