All of lore.kernel.org
 help / color / mirror / Atom feed
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

  reply	other threads:[~2026-11-19 12:38 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 [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: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
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-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 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.