From nobody Tue Dec 16 21:52:45 2025 Received: from mail-pl1-f171.google.com (mail-pl1-f171.google.com [209.85.214.171]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 42D9F2D9EC8 for ; Wed, 5 Nov 2025 08:29:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762331363; cv=none; b=A4I0JmH0O6dYVAxxJ+8p3GiNXwsgtfnK/ii+rhkutxBH4PSBULktZaEEt2JY5luQRtfkbgYonYpZSjevvcv2LEyYKCuqmg6xhhsWrxGGQj+oFa8P5mN1VssoNeYtdPoYecNE5PYzXav5txjDyuLxX8m9FwPQrjq3Oq3Qzz2ngBw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1762331363; c=relaxed/simple; bh=rko0iUJF0zDKww/HfwrbBNAFt59i3B+7ifqQ30itxtc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=UeLrqaHFrULj2cJabvWgVgpp2u5cThB2zYNTSPQeuG+hGxVPMrWRHwGO3reUfIDWcprfWS74ZnIYaRlPQGhKobSi84SYc4iKHlNaSutdx/B0UCyto/QpZBOaHr5wK6E+3gIeSzCzWOrHoh28Hg4e0LSIFuQbXEcQ7rO9mKQM5so= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=rivosinc.com; spf=pass smtp.mailfrom=rivosinc.com; dkim=pass (2048-bit key) header.d=rivosinc.com header.i=@rivosinc.com header.b=ZPoTlw0S; arc=none smtp.client-ip=209.85.214.171 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=rivosinc.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=rivosinc.com header.i=@rivosinc.com header.b="ZPoTlw0S" Received: by mail-pl1-f171.google.com with SMTP id d9443c01a7336-2957850c63bso6891665ad.0 for ; Wed, 05 Nov 2025 00:29:21 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc.com; s=google; t=1762331360; x=1762936160; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=UpAlHv9OQWYvUlKWgP1gdNckfEi918WeQvUwQAzIeaA=; b=ZPoTlw0Skc3bVUQAODr1x5Vj5I4QA2l0s/6koDHSZuxHTx2zChsGAEbUe4inVbHS0n 2iiyEgqtSPdYl4Arq0EKcjHpCYLaiLhS32f8oFC0RBsku/JrDnGjLeuGa+/cySRcZ3fA +kIIWTNFq7cezsKV8wZ2hGLeZ7qFglqhHq05BE4LvEje2FNcoVmj32HjPLLF4d+qoxEd 2y2s1RJ3JNpyeKul+HSBCejfdu50wt7pZ4qLAL5vXN63SwaNIfRJOMaZnEDFVoZGyCsb Kgo/kpucsh7Q18G8ytcdABzeAKnKuzyphYI9ydEx9YfEXuiI1I0inraEQosKXghkDCe+ AgSw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1762331360; x=1762936160; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=UpAlHv9OQWYvUlKWgP1gdNckfEi918WeQvUwQAzIeaA=; b=Oj1INvCYw1hYkHVEI4jEe9EHiqJxhcItS12FRXuu4TK+iTHNHvVpVApKRg6ArkoVrt lnwKce51WCmGQ1c3uhp6LtTHUy8Mx64rNOoJOj8Y9nPddeHfj4iWFLqxTQgUzKT/O8G4 vCSdrx4za8+hx94H5OsdwOiz3t/buaIe1pUOdy+luat2I+8u/Eqr4mWsbSj7dkCeAjlu ctxC1Ns+DEKLaz4XherSnpeNqfdXrMp4dQzKwBpgz8bNXqkDtORkXyd6TLsXDQoLzx5L 2/Iuncxc4lDR2i5nmuAcpGIn9gBM1Hjz738/FB4wphY6bXSLhhdLuBAEvvQtwGkuNSm/ QwXg== X-Forwarded-Encrypted: i=1; AJvYcCVlGAMlx+NziPa4+nRC4r+ckecmB2xAgQvGL0PMJaKg8ZzKP9+qUvprVDYjBQEfAc2nR/kUwlQM3+sWOUQ=@vger.kernel.org X-Gm-Message-State: AOJu0YyJ0eLFINWCg2LREDehhlNPueuLjtszesrUYFPrRv+9NCv6TijT ktqtR6XLsmhlx7Lf1NrKTqKysn6FZgVB7CLXOrrXys12fh9lEGkkOpmicamczbjrsMg= X-Gm-Gg: ASbGncuJdPTO9bLCBhbHLdz+n70BA/6JlE9cXWwjCcek0vvknPEa/Ae1lw0Yn+Rwa7s Vrqdx4XM9TH8bHzzgWW+TeURHIwFfkovcCwtf6P/LQyTiXqpZkN6UUxn5gtmo5+dTjxwHwThZ6h xbOFzyW60iErCIdteeg0VgwhZU3Cr4lQ3imIEWKmUVlCM98hbxQgA+kYmL8bXU+F0/qIHRx3pbz 98OHZ94/I1T+RWgav7hjU46jyL8lhl7yFaL7wuMEpeffEmUrPDzxexU0QCTi0CRI8zlcydH3tJB xQi3HFasl+cSIzBUjSw9jlHF5T+rZBCMG5K4rpLrXll49utIKeYfcXZOY7XHFSv1VjgScMX2Dyi HseZIfVOA13NxN32joh7eaRnsa0gvX1lufyxZc8Une/XiAQkuec5UzrPK X-Google-Smtp-Source: AGHT+IF2Z6homljqV5rqhE78buYnfAbixEFj/1q40usfOdn/g6EqgmSRtkgSbkwfy2jLGxHxkCHQEw== X-Received: by 2002:a17:902:e5cb:b0:273:ef4c:60f3 with SMTP id d9443c01a7336-295f937c8a7mr84723755ad.4.1762331360459; Wed, 05 Nov 2025 00:29:20 -0800 (PST) Received: from cleger.eu.int ([2001:41d0:420:f300::]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29601a741e3sm51870875ad.98.2025.11.05.00.29.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 05 Nov 2025 00:29:19 -0800 (PST) From: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= To: Paul Walmsley , Palmer Dabbelt , linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Cc: =?UTF-8?q?Cl=C3=A9ment=20L=C3=A9ger?= , Himanshu Chauhan , Anup Patel , Xu Lu , Atish Patra , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Yunhui Cui Subject: [PATCH v8 4/5] perf: RISC-V: add support for SSE event Date: Wed, 5 Nov 2025 08:26:36 +0000 Message-ID: <20251105082639.342973-5-cleger@rivosinc.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20251105082639.342973-1-cleger@rivosinc.com> References: <20251105082639.342973-1-cleger@rivosinc.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable In order to use SSE within PMU drivers, register a SSE handler for the local PMU event. Reuse the existing overflow IRQ handler and pass appropriate pt_regs. Add a config option RISCV_PMU_SSE to select event delivery via SSE events. Signed-off-by: Cl=C3=A9ment L=C3=A9ger --- drivers/perf/Kconfig | 10 +++++ drivers/perf/riscv_pmu.c | 23 +++++++++++ drivers/perf/riscv_pmu_sbi.c | 71 +++++++++++++++++++++++++++++----- include/linux/perf/riscv_pmu.h | 5 +++ 4 files changed, 99 insertions(+), 10 deletions(-) diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig index 638321fc9800..d6ffc2b036e5 100644 --- a/drivers/perf/Kconfig +++ b/drivers/perf/Kconfig @@ -105,6 +105,16 @@ config RISCV_PMU_SBI full perf feature support i.e. counter overflow, privilege mode filtering, counter configuration. =20 +config RISCV_PMU_SBI_SSE + depends on RISCV_PMU && RISCV_SBI_SSE + bool "RISC-V PMU SSE events" + default n + help + Say y if you want to use SSE events to deliver PMU interrupts. This + provides a way to profile the kernel at any level by using NMI-like + SSE events. SSE events being really intrusive, this option allows + to select it only if needed. + config STARFIVE_STARLINK_PMU depends on ARCH_STARFIVE || COMPILE_TEST depends on 64BIT diff --git a/drivers/perf/riscv_pmu.c b/drivers/perf/riscv_pmu.c index 7644147d50b4..dda2814801c0 100644 --- a/drivers/perf/riscv_pmu.c +++ b/drivers/perf/riscv_pmu.c @@ -13,6 +13,7 @@ #include #include #include +#include #include #include =20 @@ -254,6 +255,24 @@ void riscv_pmu_start(struct perf_event *event, int fla= gs) perf_event_update_userpage(event); } =20 +#ifdef CONFIG_RISCV_PMU_SBI_SSE +static void riscv_pmu_disable(struct pmu *pmu) +{ + struct riscv_pmu *rvpmu =3D to_riscv_pmu(pmu); + + if (rvpmu->sse_evt) + sse_event_disable_local(rvpmu->sse_evt); +} + +static void riscv_pmu_enable(struct pmu *pmu) +{ + struct riscv_pmu *rvpmu =3D to_riscv_pmu(pmu); + + if (rvpmu->sse_evt) + sse_event_enable_local(rvpmu->sse_evt); +} +#endif + static int riscv_pmu_add(struct perf_event *event, int flags) { struct riscv_pmu *rvpmu =3D to_riscv_pmu(event->pmu); @@ -411,6 +430,10 @@ struct riscv_pmu *riscv_pmu_alloc(void) .event_mapped =3D riscv_pmu_event_mapped, .event_unmapped =3D riscv_pmu_event_unmapped, .event_idx =3D riscv_pmu_event_idx, +#ifdef CONFIG_RISCV_PMU_SBI_SSE + .pmu_enable =3D riscv_pmu_enable, + .pmu_disable =3D riscv_pmu_disable, +#endif .add =3D riscv_pmu_add, .del =3D riscv_pmu_del, .start =3D riscv_pmu_start, diff --git a/drivers/perf/riscv_pmu_sbi.c b/drivers/perf/riscv_pmu_sbi.c index e255c1b069ec..c852f64a5022 100644 --- a/drivers/perf/riscv_pmu_sbi.c +++ b/drivers/perf/riscv_pmu_sbi.c @@ -17,6 +17,7 @@ #include #include #include +#include #include #include #include @@ -1038,10 +1039,10 @@ static void pmu_sbi_start_overflow_mask(struct risc= v_pmu *pmu, pmu_sbi_start_ovf_ctrs_sbi(cpu_hw_evt, ctr_ovf_mask); } =20 -static irqreturn_t pmu_sbi_ovf_handler(int irq, void *dev) +static irqreturn_t pmu_sbi_ovf_handler(struct cpu_hw_events *cpu_hw_evt, + struct pt_regs *regs, bool from_sse) { struct perf_sample_data data; - struct pt_regs *regs; struct hw_perf_event *hw_evt; union sbi_pmu_ctr_info *info; int lidx, hidx, fidx; @@ -1049,7 +1050,6 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, void = *dev) struct perf_event *event; u64 overflow; u64 overflowed_ctrs =3D 0; - struct cpu_hw_events *cpu_hw_evt =3D dev; u64 start_clock =3D sched_clock(); struct riscv_pmu_snapshot_data *sdata =3D cpu_hw_evt->snapshot_addr; =20 @@ -1059,13 +1059,15 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, voi= d *dev) /* Firmware counter don't support overflow yet */ fidx =3D find_first_bit(cpu_hw_evt->used_hw_ctrs, RISCV_MAX_COUNTERS); if (fidx =3D=3D RISCV_MAX_COUNTERS) { - csr_clear(CSR_SIP, BIT(riscv_pmu_irq_num)); + if (!from_sse) + csr_clear(CSR_SIP, BIT(riscv_pmu_irq_num)); return IRQ_NONE; } =20 event =3D cpu_hw_evt->events[fidx]; if (!event) { - ALT_SBI_PMU_OVF_CLEAR_PENDING(riscv_pmu_irq_mask); + if (!from_sse) + ALT_SBI_PMU_OVF_CLEAR_PENDING(riscv_pmu_irq_mask); return IRQ_NONE; } =20 @@ -1080,16 +1082,16 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, voi= d *dev) =20 /* * Overflow interrupt pending bit should only be cleared after stopping - * all the counters to avoid any race condition. + * all the counters to avoid any race condition. When using SSE, + * interrupt is cleared when stopping counters. */ - ALT_SBI_PMU_OVF_CLEAR_PENDING(riscv_pmu_irq_mask); + if (!from_sse) + ALT_SBI_PMU_OVF_CLEAR_PENDING(riscv_pmu_irq_mask); =20 /* No overflow bit is set */ if (!overflow) return IRQ_NONE; =20 - regs =3D get_irq_regs(); - for_each_set_bit(lidx, cpu_hw_evt->used_hw_ctrs, RISCV_MAX_COUNTERS) { struct perf_event *event =3D cpu_hw_evt->events[lidx]; =20 @@ -1145,6 +1147,51 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, void= *dev) return IRQ_HANDLED; } =20 +static irqreturn_t pmu_sbi_ovf_irq_handler(int irq, void *dev) +{ + return pmu_sbi_ovf_handler(dev, get_irq_regs(), false); +} + +#ifdef CONFIG_RISCV_PMU_SBI_SSE +static int pmu_sbi_ovf_sse_handler(u32 evt, void *arg, struct pt_regs *reg= s) +{ + struct cpu_hw_events __percpu *hw_events =3D arg; + struct cpu_hw_events *hw_event =3D raw_cpu_ptr(hw_events); + + pmu_sbi_ovf_handler(hw_event, regs, true); + + return 0; +} + +static int pmu_sbi_setup_sse(struct riscv_pmu *pmu) +{ + int ret; + struct sse_event *evt; + struct cpu_hw_events __percpu *hw_events =3D pmu->hw_events; + + evt =3D sse_event_register(SBI_SSE_EVENT_LOCAL_PMU_OVERFLOW, 0, + pmu_sbi_ovf_sse_handler, hw_events); + if (IS_ERR(evt)) + return PTR_ERR(evt); + + ret =3D sse_event_enable(evt); + if (ret) { + sse_event_unregister(evt); + return ret; + } + + pr_info("using SSE for PMU event delivery\n"); + pmu->sse_evt =3D evt; + + return ret; +} +#else +static int pmu_sbi_setup_sse(struct riscv_pmu *pmu) +{ + return -EOPNOTSUPP; +} +#endif + static int pmu_sbi_starting_cpu(unsigned int cpu, struct hlist_node *node) { struct riscv_pmu *pmu =3D hlist_entry_safe(node, struct riscv_pmu, node); @@ -1195,6 +1242,10 @@ static int pmu_sbi_setup_irqs(struct riscv_pmu *pmu,= struct platform_device *pde struct cpu_hw_events __percpu *hw_events =3D pmu->hw_events; struct irq_domain *domain =3D NULL; =20 + ret =3D pmu_sbi_setup_sse(pmu); + if (!ret) + return 0; + if (riscv_isa_extension_available(NULL, SSCOFPMF)) { riscv_pmu_irq_num =3D RV_IRQ_PMU; riscv_pmu_use_irq =3D true; @@ -1229,7 +1280,7 @@ static int pmu_sbi_setup_irqs(struct riscv_pmu *pmu, = struct platform_device *pde return -ENODEV; } =20 - ret =3D request_percpu_irq(riscv_pmu_irq, pmu_sbi_ovf_handler, "riscv-pmu= ", hw_events); + ret =3D request_percpu_irq(riscv_pmu_irq, pmu_sbi_ovf_irq_handler, "riscv= -pmu", hw_events); if (ret) { pr_err("registering percpu irq failed [%d]\n", ret); return ret; diff --git a/include/linux/perf/riscv_pmu.h b/include/linux/perf/riscv_pmu.h index f82a28040594..08fdcf6baf4e 100644 --- a/include/linux/perf/riscv_pmu.h +++ b/include/linux/perf/riscv_pmu.h @@ -28,6 +28,8 @@ =20 #define RISCV_PMU_CONFIG1_GUEST_EVENTS 0x1 =20 +struct sse_event; + struct cpu_hw_events { /* currently enabled events */ int n_events; @@ -54,6 +56,9 @@ struct riscv_pmu { char *name; =20 irqreturn_t (*handle_irq)(int irq_num, void *dev); +#ifdef CONFIG_RISCV_PMU_SBI_SSE + struct sse_event *sse_evt; +#endif =20 unsigned long cmask; u64 (*ctr_read)(struct perf_event *event); --=20 2.43.0