From: sashiko-bot@kernel.org
To: "Zhanpeng Zhang" <zhangzhanpeng.jasper@bytedance.com>
Cc: linux-perf-users@vger.kernel.org
Subject: Re: [PATCH v13 04/11] drivers: firmware: add riscv SSE support
Date: Thu, 19 Nov 2026 12:38:39 +0000 [thread overview]
Message-ID: <sashiko-outbox-223100@kernel.org> (raw)
In-Reply-To: <20261119120824.13969-17-zhangzhanpeng.jasper@bytedance.com>
Thank you for your contribution! Sashiko AI review found 8 potential
issues to consider:
- [High] firmware: riscv_sbi_sse: sse_pm_notifier() unmasks SSE on
unready or offlining CPUs
- [High] firmware: riscv_sbi_sse: sse_event_cleanup() leaks retained SSE
events
- [High] firmware: riscv_sbi_sse: missing IRQ and teardown sync in
sse_event_*_local()
- [High] firmware: riscv_sbi_sse: sse_cpu_teardown() mishandles CPU-up
rollback
- [Medium] firmware: riscv_sbi_sse: missing hart and CPU bounds check in
sse_event_register()
- [Medium] firmware: riscv_sbi_sse: sse_event_setup_all_cpus() can
return -EOPNOTSUPP with enabled state
- [Medium] firmware: riscv_sbi_sse: sse_reboot_notifier() races with CPU
hotplug callbacks
- [Medium] firmware: riscv_sbi_sse: broken rollback in
sse_event_set_target_cpu_nolock()
--
commit 62013a3fca4c71adabe66ac29e99aa0bab92f5a1
Author: Clément Léger <cleger@rivosinc.com>
drivers: firmware: add riscv SSE support
This commit adds a driver-level interface for RISC-V Supervisor Software
Events (SSE) to manage global and per-CPU event registration, enabling,
disabling, and CPU hotplug and reboot teardown.
> diff --git a/drivers/firmware/riscv/riscv_sbi_sse.c b/drivers/firmware/riscv/riscv_sbi_sse.c
> new file mode 100644
> index 0000000000000..0cb738bab6c39
> --- /dev/null
> +++ b/drivers/firmware/riscv/riscv_sbi_sse.c
> @@ -0,0 +1,1219 @@
[ ... ]
> +static int sse_sbi_event_func(struct sse_event *event, unsigned long func)
> +{
> + struct sbiret ret;
> + u32 evt = event->evt_id;
> + struct sse_registered_event *reg_evt = sse_get_reg_evt(event);
> +
> + ret = sbi_ecall(SBI_EXT_SSE, func, evt, 0, 0, 0, 0, 0);
> + if (ret.error) {
> + pr_warn("Failed to execute func %lx, event %x, error %ld\n",
> + func, evt, ret.error);
> + return sse_err_map_linux_errno(ret.error);
> + }
> +
> + if (func == SBI_SSE_EVENT_DISABLE)
> + reg_evt->is_enabled = false;
> + else if (func == SBI_SSE_EVENT_ENABLE)
> + reg_evt->is_enabled = true;
> +
> + return 0;
> +}
> +
> +int sse_event_disable_local(struct sse_event *event)
> +{
> + if (!sse_event_is_global(event->evt_id))
> + lockdep_assert_preemption_disabled();
> +
> + if (!sse_get_reg_evt(event)->is_enabled)
> + return 0;
> +
> + return sse_sbi_event_func(event, SBI_SSE_EVENT_DISABLE);
> +}
> +EXPORT_SYMBOL_GPL(sse_event_disable_local);
> +
> +int sse_event_enable_local(struct sse_event *event)
> +{
> + struct sse_registered_event *reg_evt = sse_get_reg_evt(event);
> + int ret;
> +
> + if (!sse_event_is_global(event->evt_id))
> + lockdep_assert_preemption_disabled();
> +
> + rcu_read_lock();
> + if (READ_ONCE(sse_shutting_down)) {
> + ret = -ESHUTDOWN;
> + goto out;
> + }
> +
> + if (!reg_evt->is_registered) {
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + if (reg_evt->is_enabled) {
> + ret = 0;
> + goto out;
> + }
> +
> + ret = sse_sbi_event_func(event, SBI_SSE_EVENT_ENABLE);
> +out:
> + rcu_read_unlock();
> +
> + return ret;
> +}
> +EXPORT_SYMBOL_GPL(sse_event_enable_local);
[Severity: High]
Can a hardirq interrupting sse_event_disable_local(),
sse_event_enable_local(), or sse_teardown_event() observe stale
reg_evt->is_enabled state and issue conflicting SBI calls?
sse_event_disable_local(), sse_event_enable_local(), and
sse_cpu_teardown() run with local interrupts enabled, and
sse_sbi_event_func() updates reg_evt->is_enabled only after sbi_ecall()
returns:
sse_cpu_teardown()
sse_teardown_event()
if (reg_evt->is_enabled)
sse_event_disable_local()
<hardirq>
perf_mux_hrtimer_handler()
...
sse_event_disable_local()
sbi_ecall(..., SBI_SSE_EVENT_DISABLE, ...)
reg_evt->is_enabled = false;
sse_sbi_event_func(..., SBI_SSE_EVENT_DISABLE)
sbi_ecall(..., SBI_SSE_EVENT_DISABLE, ...) <-- returns -EINVAL
During reboot or kexec, sse_reboot_nb runs at default priority 0 while
CPUHP_AP_PERF_ONLINE and perf timer interrupts are still active. When the
second SBI_SSE_EVENT_DISABLE fails with -EINVAL, sse_teardown_event()
aborts before unregistering the event and sets sse_teardown_failed,
causing sse_reboot_notifier() to panic on kexec.
The same window exists when an interrupt nests inside normal
sse_event_disable_local() or sse_event_enable_local() calls, or when an
interrupt calls sse_event_enable_local() after sse_teardown_event() (on
normal CPU offline where sse_shutting_down is false) or
sse_event_set_target_cpu_nolock() disables an event while
reg_evt->is_registered is still true.
Also, sse_event_enable_local() calls sse_get_reg_evt(event) (which calls
smp_processor_id() for local events) before
lockdep_assert_preemption_disabled(), and sse_restore_local_events()
restores local events from event->enable_requested rather than the
per-CPU reg_evt->is_enabled state that was active before
sse_cpu_teardown() began.
[ ... ]
> +static int sse_event_set_target_cpu_nolock(struct sse_event *event,
> + unsigned int cpu)
> +{
> + unsigned long hart_id, old_hart_id;
> + struct sse_registered_event *reg_evt = event->global;
> + u32 evt = event->evt_id;
> + unsigned int old_cpu;
> + bool was_enabled;
> + int ret;
> +
> + if (!sse_event_is_global(evt))
> + return -EINVAL;
> +
> + if (cpu >= nr_cpu_ids || !cpu_online(cpu))
> + return -EINVAL;
> + hart_id = cpuid_to_hartid_map(cpu);
> + old_cpu = event->cpu;
> + old_hart_id = cpuid_to_hartid_map(old_cpu);
> +
> + was_enabled = reg_evt->is_enabled;
> + if (was_enabled) {
> + ret = sse_event_disable_local(event);
> + if (ret)
> + return ret;
> + }
> +
> + ret = sse_event_attr_set_nolock(reg_evt, SBI_SSE_ATTR_PREFERRED_HART,
> + hart_id);
> + if (ret == 0)
> + sse_global_event_update_cpu(event, cpu);
> +
> + if (was_enabled) {
> + int enable_ret;
> +
> + enable_ret = sse_event_enable_local(event);
> + if (enable_ret) {
> + int rollback_ret;
> +
> + /*
> + * The preferred hart was already changed. Restore both the
> + * firmware attribute and Linux's cached target before reporting
> + * the failed migration.
> + */
> + rollback_ret = sse_event_attr_set_nolock(reg_evt,
> + SBI_SSE_ATTR_PREFERRED_HART,
> + old_hart_id);
> + if (!rollback_ret) {
> + sse_global_event_update_cpu(event, old_cpu);
> + rollback_ret = sse_event_enable_local(event);
> + }
> + if (!rollback_ret)
> + return enable_ret;
> +
> + pr_warn("Failed to restore global event %x to CPU %u: %d\n",
> + evt, old_cpu, rollback_ret);
> + event->enable_requested = false;
> + return enable_ret;
> + }
> + }
> +
> + return ret;
> +}
[Severity: Medium]
Does the rollback in sse_event_set_target_cpu_nolock() misbehave when
setting SBI_SSE_ATTR_PREFERRED_HART or rolling it back fails?
If sse_event_attr_set_nolock() fails (ret != 0) on an enabled event and
re-enabling the event also fails (enable_ret != 0), the code enters the
rollback block even though the preferred hart was never changed,
redundantly writing old_hart_id and returning enable_ret instead of ret.
Conversely, if setting the new preferred hart succeeds (ret == 0),
sse_global_event_update_cpu(event, cpu) updates event->cpu to the new
CPU. If both sse_event_enable_local() and the rollback
sse_event_attr_set_nolock(..., old_hart_id) then fail, event->cpu remains
set to the new CPU while the function returns enable_ret, causing
sse_cpu_teardown() to abort the CPU offline even though the event has
already been moved to next_cpu and disabled.
[ ... ]
> +void sse_event_cleanup(struct sse_event *event)
> +{
> + guard(mutex)(&sse_mutex);
> + guard(cpus_read_lock)();
> +
> + if (event->cleanup_pending)
> + return;
> +
> + /*
> + * Firmware may still enter the old callback after disable or unregister
> + * fails. Publish a core-owned callback, then wait before the client frees
> + * its callback data.
> + */
> + event->cleanup_pending = true;
> + rcu_assign_pointer(event->handler, sse_cleanup_event_handler);
> + synchronize_rcu();
> +}
> +EXPORT_SYMBOL_GPL(sse_event_cleanup);
> +
> +static void sse_release_cleanup_event(struct sse_event *event)
> +{
> + if (!event->cleanup_pending || sse_event_is_registered(event))
> + return;
> +
> + list_del(&event->list);
> + sse_event_free(event);
> +}
> +
> +static int sse_event_setup_all_cpus(struct sse_event *event,
> + unsigned long func,
> + unsigned long rollback_func)
> +{
> + struct sse_per_cpu_evt cpu_evt;
> + int rollback_ret;
> + int ret;
> +
> + cpu_evt.event = event;
> + atomic_set(&cpu_evt.first_error, 0);
> + atomic_set(&cpu_evt.nonfallback_error, 0);
> + cpumask_clear(&cpu_evt.changed);
> + cpu_evt.func = func;
> + on_each_cpu(sse_event_per_cpu_func, &cpu_evt, 1);
> + /* IRQ fallback is safe only if every failing CPU reports unsupported. */
> + ret = atomic_read(&cpu_evt.nonfallback_error);
> + if (!ret)
> + ret = atomic_read(&cpu_evt.first_error);
> + /*
> + * A previous attempt may already have changed some CPUs. Roll back only
> + * instances changed by this invocation.
> + */
> + if (ret) {
> + cpu_evt.func = rollback_func;
> + atomic_set(&cpu_evt.first_error, 0);
> + atomic_set(&cpu_evt.nonfallback_error, 0);
> + on_each_cpu_mask(&cpu_evt.changed, sse_event_per_cpu_func, &cpu_evt, 1);
> +
> + rollback_ret = atomic_read(&cpu_evt.nonfallback_error);
> + if (!rollback_ret)
> + rollback_ret = atomic_read(&cpu_evt.first_error);
> +
> + /* A rollback failure leaves the firmware state uncertain. */
> + return rollback_ret ?: ret;
> + }
> +
> + return 0;
> +}
[Severity: High]
Does sse_event_cleanup() leak struct sse_event and leave its evt_id
permanently blocked on the events list?
sse_event_cleanup() sets event->cleanup_pending = true and swaps the
handler, but never tears down remaining registrations or calls
sse_release_cleanup_event(event).
If all registrations were already removed before cleanup_pending was set
(for example, when sse_reboot_notifier() tore down all events and a
client's later sse_event_unregister() returned -ESHUTDOWN, or when the
failing CPU went offline in the window between sse_event_unregister()
dropping sse_mutex and sse_event_cleanup() acquiring it),
sse_release_cleanup_event() during sse_cpu_teardown() saw
!event->cleanup_pending and did nothing. Once sse_event_cleanup() sets
cleanup_pending = true, nothing calls sse_release_cleanup_event(event)
again, leaking event and causing future sse_event_register() calls for
that evt_id to fail with -EEXIST.
Similarly, if a client calls sse_event_cleanup(event) directly after
sse_event_disable(event) fails on one CPU without calling
sse_event_unregister(event), sse_event_cleanup() neither clears
event->enable_requested nor unregisters the event on the online CPUs
where disabling succeeded, leaving those CPUs registered and preventing
sse_release_cleanup_event() from ever freeing the event.
[Severity: Medium]
Can sse_event_setup_all_cpus() return -EOPNOTSUPP to sse_event_enable()
while leaving the event enabled on some CPUs?
If the forward enable pass fails with a non-fallback error (such as -EIO)
after enabling the event on CPUs in cpu_evt.changed, and the rollback
disable pass fails with -EOPNOTSUPP, "return rollback_ret ?: ret;"
overwrites ret with -EOPNOTSUPP. Likewise, if any CPU was already
enabled before sse_event_enable() ran (so changed was false on that CPU)
and another CPU fails with -EOPNOTSUPP, only cpu_evt.changed is rolled
back. Unlike sse_event_register(), sse_event_enable() does not check
sse_event_is_enabled(event), so it returns -EOPNOTSUPP and allows the
client to select an IRQ fallback while firmware still has SSE enabled.
[ ... ]
> + if (sse_event_is_global(evt)) {
> + unsigned long preferred_hart;
> +
> + ret = sse_event_attr_get_no_lock(event->global,
> + SBI_SSE_ATTR_PREFERRED_HART,
> + &preferred_hart);
> + if (ret)
> + return sse_register_failed(event, ret);
> +
> + cpu = riscv_hartid_to_cpuid(preferred_hart);
> + if (cpu < 0 || !cpu_online(cpu)) {
> + cpu = cpumask_first(cpu_online_mask);
[Severity: Medium]
Can cpu_online(cpu) read past nr_cpu_ids when firmware reports an invalid
or unpopulated preferred_hart?
In arch/riscv/kernel/smp.c, __cpuid_to_hartid_map[NR_CPUS] initializes
all NR_CPUS slots to INVALID_HARTID, and riscv_hartid_to_cpuid() scans up
to NR_CPUS:
arch/riscv/kernel/smp.c:riscv_hartid_to_cpuid() {
for (i = 0; i < NR_CPUS; i++)
if (cpuid_to_hartid_map(i) == hartid)
return i;
}
When nr_cpu_ids < NR_CPUS and firmware returns preferred_hart ==
INVALID_HARTID (or a hart mapped at index >= nr_cpu_ids),
riscv_hartid_to_cpuid() returns an index >= nr_cpu_ids. Passing that cpu
to cpu_online(cpu) without checking preferred_hart == INVALID_HARTID or
cpu >= nr_cpu_ids (unlike sse_event_set_target_cpu_nolock()) reads past
nr_cpu_ids in cpu_online_mask and triggers the WARN_ON_ONCE() in
cpumask_check() when CONFIG_DEBUG_PER_CPU_MAPS is enabled.
[ ... ]
> +static int sse_cpu_teardown(unsigned int cpu)
> +{
> + /* Only a regular CPU-offline callback may abort the CPUHP operation. */
> + bool regular_offline = READ_ONCE(sse_available) &&
> + !READ_ONCE(sse_shutting_down);
> + unsigned int next_cpu;
> + struct sse_event *event, *tmp;
> + int first_error = 0;
> + int ret;
> +
> + /* Do not dismantle CPU state while firmware can still deliver SSE. */
> + ret = sse_events_mask();
> + if (ret) {
> + pr_warn("Failed to mask SSE on CPU %u during teardown: %d\n",
> + cpu, ret);
> + if (READ_ONCE(sse_shutting_down))
> + atomic_set(&sse_teardown_failed, 1);
> + /* CPUHP installation rollback and state removal cannot fail. */
> + return regular_offline ? ret : 0;
> + }
> +
> + list_for_each_entry_safe(event, tmp, &events, list) {
> + if (sse_event_is_global(event->evt_id))
> + continue;
> +
> + scoped_guard(preempt)
> + ret = sse_teardown_event(event, cpu);
> + if (ret && !first_error)
> + first_error = ret;
> + sse_release_cleanup_event(event);
> + if (ret && regular_offline)
> + goto restore_cpu;
> + }
> +
> + list_for_each_entry_safe(event, tmp, &events, list) {
> + if (!sse_event_is_global(event->evt_id) || event->cpu != cpu)
> + continue;
> +
> + /*
> + * cpuhp_remove_state() invokes teardown while every CPU remains
> + * online. Do not migrate to a CPU whose callback may have run.
> + */
> + if (READ_ONCE(sse_shutting_down) || event->cleanup_pending) {
> + ret = sse_teardown_event(event, cpu);
> + } else {
> + next_cpu = cpumask_any_but(cpu_online_mask, cpu);
> + if (next_cpu >= nr_cpu_ids) {
> + ret = sse_teardown_event(event, cpu);
> + } else {
> + ret = sse_event_set_target_cpu_nolock(event, next_cpu);
> + if (ret)
> + pr_warn("Failed to migrate global event %x from CPU %u: %d\n",
> + event->evt_id, cpu, ret);
> + }
> + }
> +
> + if (ret && !first_error)
> + first_error = ret;
> + sse_release_cleanup_event(event);
> + if (ret && regular_offline)
> + goto restore_cpu;
> + }
> +
> + if (first_error) {
> + /* An offline CPU is not revisited when this CPUHP state is removed. */
> + atomic_set(&sse_teardown_failed, 1);
> + }
> +
> + return 0;
> +
> +restore_cpu:
> + /*
> + * CPUHP leaves this CPU online when teardown returns an error. Restore
> + * every client-owned local event before making SSE delivery visible again.
> + */
> + ret = sse_restore_local_events(cpu);
> + if (!ret)
> + ret = sse_events_unmask();
> + if (ret) {
> + atomic_set(&sse_teardown_failed, 1);
> + pr_warn("Failed to restore SSE after aborting CPU %u offline: %d\n",
> + cpu, ret);
> + } else {
> + pr_warn("Aborted CPU %u offline after SSE teardown failed: %d\n",
> + cpu, first_error);
> + }
> +
> + return first_error;
> +}
[Severity: High]
What happens if sse_cpu_teardown() is invoked during a post-boot
_cpu_up() rollback after a later CPUHP state fails?
Because sse_available is true and sse_shutting_down is false after boot,
regular_offline evaluates to true even when sse_cpu_teardown() is rolling
back a failed CPU bringup. If sse_teardown_event() or migration fails,
sse_cpu_teardown() jumps to restore_cpu, re-registers and re-enables
local events, unmasks SSE on the hart, leaves sse_teardown_failed unset
when restore succeeds, and returns first_error (triggering
WARN_ON_ONCE(st->rollback) in cpuhp_thread_fun()), while
cpuhp_up_callbacks() proceeds to take the CPU down via takedown_cpu()
with SSE still unmasked and events active in firmware. Likewise, if
sse_events_mask() fails during a _cpu_up() rollback, sse_cpu_teardown()
returns a non-zero error without setting sse_teardown_failed.
> +
> +static int sse_pm_notifier(struct notifier_block *nb, unsigned long action,
> + void *data)
> +{
> + int ret;
> +
> + WARN_ON_ONCE(preemptible());
> +
> + switch (action) {
> + case CPU_PM_ENTER:
> + ret = sse_events_mask();
> + break;
> + case CPU_PM_EXIT:
> + case CPU_PM_ENTER_FAILED:
> + if (READ_ONCE(sse_shutting_down))
> + return NOTIFY_OK;
> + ret = sse_events_unmask();
> + break;
> + default:
> + return NOTIFY_DONE;
> + }
> +
> + if (ret)
> + return notifier_from_errno(ret);
> +
> + return NOTIFY_OK;
> +}
[Severity: High]
Can sse_pm_notifier() unmask SSE on a CPU where SSE has already been torn
down, has not been initialized yet, or was intentionally left masked?
CPU_PM_EXIT and CPU_PM_ENTER_FAILED only check sse_shutting_down before
calling sse_events_unmask(), without tracking whether SSE is currently
online and unmasked on this CPU.
During normal CPU hot-unplug, sse_cpu_teardown() masks SSE and tears down
events at CPUHP_AP_RISCV_SSE_ONLINE, after which the cpuhp thread parks
at CPUHP_AP_ONLINE_IDLE and the offlining CPU enters do_idle() ->
cpuidle_idle_call() while waiting for takedown_cpu() at
CPUHP_TEARDOWN_CPU. Exiting a CPU_PM idle state in that window calls
sse_events_unmask(), re-enabling SSE delivery on the dying hart after its
events have been torn down.
The same unconditional unmask can happen on a CPU exiting a CPU_PM idle
state before CPUHP_AP_RISCV_SSE_ONLINE has run arch_sse_init_cpu() (during
sse_init() where cpu_pm_register_notifier() runs before
cpuhp_setup_state(), or during _cpu_up()), or after restore_cpu in
sse_cpu_teardown() intentionally left SSE masked because
sse_restore_local_events() failed.
[ ... ]
> +static int sse_reboot_notifier(struct notifier_block *nb, unsigned long action,
> + void *data)
> +{
> + int ret;
> +
> + scoped_guard(mutex, &sse_mutex) {
> + if (!sse_shutting_down) {
> + WRITE_ONCE(sse_shutting_down, true);
> + ret = cpu_pm_unregister_notifier(&sse_pm_nb);
> + if (ret) {
> + pr_warn("Failed to unregister CPU PM notifier: %d\n",
> + ret);
> + atomic_set(&sse_teardown_failed, 1);
> + }
> + /* Drain CPU PM callbacks and client enables before teardown. */
> + synchronize_rcu();
> + cpuhp_remove_state(CPUHP_AP_RISCV_SSE_ONLINE);
> + }
> + }
> +
> + /* Normal kexec preserves firmware state but discards old kernel memory. */
> + if (kexec_in_progress && atomic_read(&sse_teardown_failed))
> + panic("SSE teardown failed; refusing unsafe kexec");
> +
> + return NOTIFY_OK;
> +}
[Severity: Medium]
Can sse_reboot_notifier() setting sse_shutting_down without
cpus_read_lock() race with an in-progress sse_cpu_teardown() and trigger
the kexec panic?
Normal CPU hotplug callbacks run under cpus_write_lock() without holding
sse_mutex, while reboot notifiers run before migrate_to_reboot_cpu()
disables CPU hotplug:
CPU0 CPU1
_cpu_down()
sse_cpu_teardown()
regular_offline = true;
sse_reboot_notifier()
mutex_lock(&sse_mutex)
WRITE_ONCE(sse_shutting_down, true)
sse_event_set_target_cpu_nolock()
sse_event_enable_local()
if (READ_ONCE(sse_shutting_down))
return -ESHUTDOWN;
goto restore_cpu;
sse_restore_local_events()
sse_event_enable_local()
return -ESHUTDOWN;
atomic_set(&sse_teardown_failed, 1)
cpuhp_remove_state(...)
if (kexec_in_progress &&
atomic_read(&sse_teardown_failed))
panic(...) <-- false-positive panic
Holding cpus_read_lock() across the sse_shutting_down transition (or
using __cpuhp_remove_state_cpuslocked() under cpus_read_lock()) would
serialize sse_reboot_notifier() against active CPU hotplug callbacks.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261119120824.13969-13-zhangzhanpeng.jasper@bytedance.com?part=4
next prev parent reply other threads:[~2026-11-19 12:38 UTC|newest]
Thread overview: 22+ 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 ` [PATCH v13 01/11] riscv: add SBI SSE extension definitions 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: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:38 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 04/11] drivers: firmware: add riscv SSE support Zhanpeng Zhang
2026-11-19 12:38 ` sashiko-bot [this message]
2026-11-19 12:08 ` [PATCH v13 05/11] riscv: mm: avoid enabling interrupts for nofault page faults 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:21 ` sashiko-bot
2026-11-19 12:08 ` [PATCH v13 07/11] perf: RISC-V: support callchains with SSE delivery 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: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 ` [PATCH v13 10/11] selftests/riscv: add SSE test module Zhanpeng Zhang
2026-11-19 12:37 ` sashiko-bot
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: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-223100@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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox