From nobody Fri Dec 19 20:38:04 2025 Received: from mail-pf1-f174.google.com (mail-pf1-f174.google.com [209.85.210.174]) (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 861EB1D5160 for ; Fri, 16 May 2025 15:24:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.174 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747409080; cv=none; b=DuZIdEszkLiRF4KAxz1RYB7NKn22EpHm3g6T4Mq/1cZqjmGCOGAhHODKzQIkFVJZ8HIuizWQzJYWrGQgXoUDyNFbjupyouRrPqgcBCVFGXg5kqo/PEvJXX/yRhVnOqvIXeavq2XqB9iWD5GWX8bghV4SBjal0jGFKfOdPn+1NuE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1747409080; c=relaxed/simple; bh=DKtHqS6JwUi0roBeJugt2YK7lKXK5d5b4PNW1NAkqGw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=B6NnBs5NBJnBrgG2RFhsh5az/HjpYzBpbTodJRjvZDIq7R7PdyvyxDsfPW5snsMjkj4FSRaJIOOIyy0ynpXvTcLyrfnvwvOoC4U276Cpu345I/hmkzDipOur0FHH8afCAG2rWHgxFX5Yq64wFLQfEAcpgbYvz9ZIx81Lhzi8cA4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=none (p=none dis=none) header.from=rivosinc.com; spf=pass smtp.mailfrom=rivosinc.com; dkim=pass (2048-bit key) header.d=rivosinc-com.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b=icBb8MaF; arc=none smtp.client-ip=209.85.210.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=none (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.20230601.gappssmtp.com header.i=@rivosinc-com.20230601.gappssmtp.com header.b="icBb8MaF" Received: by mail-pf1-f174.google.com with SMTP id d2e1a72fcca58-74237a74f15so3193485b3a.0 for ; Fri, 16 May 2025 08:24:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=rivosinc-com.20230601.gappssmtp.com; s=20230601; t=1747409078; x=1748013878; 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=NerZz78UKlNpCoQw7YCJwOy+/WEK1liVP1A2MrZ/GSg=; b=icBb8MaF+OH95Dm3qMzdbMCFo7HKyqR0cuaaa3/T1MZgmPEUTi9GnNRKr7YE26kY80 fIX2zHhJzA1CJyJ5hWFSHU7i1LuXZimHpz2sDdVm1I9a7c6A7+DrKZlpoAcLsXYHLoxY Q617EFthJndLtJ0b/hyMjOGyub45XBIvr0ZhoFUleh9hs3Uw8hdIBK1i08oa6yIZNuw8 h6PaCTLJtnGn1RiMpvpK3rsG9YUDgI7196dd4WrfVSwAQglJIGxyKFJm5kj/Q4S36GCg zbxYzI653XYzRyTpZCNY85Dx8D1+B59mTSG8M+YlPfyO2JuKAK/YeRC2bKrLw0YkD3ZI j6HQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1747409078; x=1748013878; 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=NerZz78UKlNpCoQw7YCJwOy+/WEK1liVP1A2MrZ/GSg=; b=gGNTk/RZdACEUaP99O4fYDhHb8jz4PucfUpIR30+Ue8G65m3lFfdCwim2vAHeBKRDU PqMEjY5Y5NplNU8ptycOo8mGapZf3J/oVZgjmqt8h6n4LQg2jWf+5KTsCQxq8Bxctvyz ZkWucqWegEiTsuTEzqfEKUTBs0KOiBtwU+canIpIrGZo0duG9gjkZxIO7MMEeD1hGTyx L+yy9Kwf0+LScWs5rWP2liljjleLarwiLwegOcgJeiYc7MKxcrJFmcVTCUrChL9xbk7n 0XVkRwQKRVPXuxabco76hnx8lFLt35MQyRlvbJzz1Js4I2FKJrIj4WlU+Tw/LezA6x/N rqow== X-Forwarded-Encrypted: i=1; AJvYcCVSvaewK1UyrkdH/Af1Ijeik/LkJGgjXecEBPffKAukBO5aGX2NhO249r985FND+XvkF32C2CGwMecjKdU=@vger.kernel.org X-Gm-Message-State: AOJu0YzMDH8o+R6b8rrWD4BDuqzLBtjPUDByByjI301Ji74v+yC307NP LADmNKhddqX5glrycAXcf2JYzKZtoI1ffmQzIsrZHpVyhQGy1swOOifr7U8VTcAa7p8= X-Gm-Gg: ASbGnct3lLCZ2bhqnlLwpyBKREXodviryKFsZCvEu7+P9GbrHldh5y54ie0nTXlQ66Y Nqv7awiyu/SN1XlNe8hoR/f2sjwBxPZE+gX7ocOZaUfYXRzKmXVoZLmGoKEM405LwGGsjAIHLQy J109wVa9gI4Zkvm9qw89iOzmn3xk+T5OWYqry5bTtZV+E4o8QHkK+7vp3/RN2NBZM36/NMH1Uvj MGd4i10Ct4cwNZ4tfMi479Tm29D29ADZdUvljb1W5u9hsCiLmggjdZe/B15JavEw7VNPULTNHZe sgoKJFiJQcHa/KhrAzjZDosDY+KmwNNWRZadWbdHUkaasn651INQbhecR8pb/F0= X-Google-Smtp-Source: AGHT+IHYlU3K8uJcfIKClp5Bxki/RMRZaz2vq2bBhQewH+zC4/99iinUqM/hNNbn+4ClvSR7T9fjoA== X-Received: by 2002:a05:6a20:6f8a:b0:218:c01:ddce with SMTP id adf61e73a8af0-2180c01de06mr3257419637.40.1747409077715; Fri, 16 May 2025 08:24:37 -0700 (PDT) Received: from carbon-x1.. ([2a01:e0a:e17:9700:16d2:7456:6634:9626]) by smtp.gmail.com with ESMTPSA id d2e1a72fcca58-742a96def68sm1666997b3a.30.2025.05.16.08.24.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 16 May 2025 08:24:37 -0700 (PDT) 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 Subject: [PATCH v4 4/4] perf: RISC-V: add support for SSE event Date: Fri, 16 May 2025 17:23:42 +0200 Message-ID: <20250516152355.560448-5-cleger@rivosinc.com> X-Mailer: git-send-email 2.49.0 In-Reply-To: <20250516152355.560448-1-cleger@rivosinc.com> References: <20250516152355.560448-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 | 9 +++++ drivers/perf/riscv_pmu.c | 19 +++++++++ drivers/perf/riscv_pmu_sbi.c | 72 +++++++++++++++++++++++++++++----- include/linux/perf/riscv_pmu.h | 3 ++ 4 files changed, 93 insertions(+), 10 deletions(-) diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig index 4e268de351c4..3462f3a21e5f 100644 --- a/drivers/perf/Kconfig +++ b/drivers/perf/Kconfig @@ -105,6 +105,15 @@ config RISCV_PMU_SBI full perf feature support i.e. counter overflow, privilege mode filtering, counter configuration. =20 +config RISCV_PMU_SSE + depends on RISCV_PMU && RISCV_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. + 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..1eb28381b80f 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,22 @@ void riscv_pmu_start(struct perf_event *event, int fla= gs) perf_event_update_userpage(event); } =20 +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); +} + static int riscv_pmu_add(struct perf_event *event, int flags) { struct riscv_pmu *rvpmu =3D to_riscv_pmu(event->pmu); @@ -411,6 +428,8 @@ 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, + .pmu_enable =3D riscv_pmu_enable, + .pmu_disable =3D riscv_pmu_disable, .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 698de8ddf895..885d04a2c338 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 @@ -948,10 +949,10 @@ static void pmu_sbi_start_overflow_mask(struct riscv_= 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; @@ -959,7 +960,6 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, void *d= ev) 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 @@ -969,13 +969,15 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, void = *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 @@ -990,16 +992,16 @@ static irqreturn_t pmu_sbi_ovf_handler(int irq, void = *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 @@ -1055,6 +1057,52 @@ 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_SSE +static int pmu_sbi_ovf_sse_handler(uint32_t evt, void *arg, + struct pt_regs *regs) +{ + 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); @@ -1105,6 +1153,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; @@ -1139,7 +1191,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 701974639ff2..d4a5c55fe077 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,7 @@ struct riscv_pmu { char *name; =20 irqreturn_t (*handle_irq)(int irq_num, void *dev); + struct sse_event *sse_evt; =20 unsigned long cmask; u64 (*ctr_read)(struct perf_event *event); --=20 2.49.0