From nobody Wed Apr 8 19:14:18 2026 Received: from mx0b-0031df01.pphosted.com (mx0b-0031df01.pphosted.com [205.220.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CC2183002B9; Wed, 25 Feb 2026 06:25:50 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=205.220.180.131 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000757; cv=none; b=u0QL6gW2ydAk1Oqr2lSB8ELOt8nLYp4iZxS9GvmmQe+im6g7FiefXMm3nH+55QJQuVxgiOI2ubx5H+lyxSCHbkAoXbMtjst9FmKLWh+0L6JN7sahRCliswBsT0+pdLw8oaDpo1o9QNZ4RJcGSWZPiaSRu6EBySor9Pvs8WBI4aI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1772000757; c=relaxed/simple; bh=2xUWeNT1tSNCLeMbBs7n+QBD+1Su5L0EiPQYJw/OkDw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ELhw9WRkze3C+yk1Cqtk7+zbPnw/RGP87UcU3oD7LFlSgmgtIRPpTp+azeutY8I+waW90rEkpzsjWShjohcBX5nW5y5GdyBYQNmCvN6q1vq1cBnDUC+FEF5EWG9OhBbYg2RLaRdIxMv15BnGC8GVAAI3l4YIuwcTc/oqiS7QrEM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com; spf=pass smtp.mailfrom=qualcomm.com; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b=IH8LzGqU; arc=none smtp.client-ip=205.220.180.131 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=oss.qualcomm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=qualcomm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=qualcomm.com header.i=@qualcomm.com header.b="IH8LzGqU" Received: from pps.filterd (m0279869.ppops.net [127.0.0.1]) by mx0a-0031df01.pphosted.com (8.18.1.11/8.18.1.11) with ESMTP id 61P2TPlk583293; Wed, 25 Feb 2026 06:25:00 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=qualcomm.com; h= cc:content-transfer-encoding:date:from:in-reply-to:message-id :mime-version:references:subject:to; s=qcppdkim1; bh=4V8xwFf6TIw IWFZcVTEKulyPWH+m1hcR5fEkS8N/mO8=; b=IH8LzGqUFX6jXio7ZBhGbDpM5U3 taTUYLLdW0nvmlaRwCoZe5psMI++yQJHO6AKUOBEvKEgqNKwGcBETcPl6h4jhZet IwbFiFYtCr4mzqkNLUaM39ptKg9uSO4RznztUKf1Tsn6qnAxOPWmPDtqk5JnI2nB RK8CHk0iz12WqH5vVs/wBr7nxZJEXhJxmcKDzYXxCpG+MSDkG6nw5mq3GCxbOyJW AGiXv9edPUdrc7G6I9SqncEbm/xV4ugS72aGrxDXVYUY1UOxbB0sQrxUTSUlYCnS 79J5XYneOB3A1dKXrh4dNar0oRj2y/ZReGgMzvXArZbZJsL9p0KyX+84NJw== Received: from apblrppmta01.qualcomm.com (blr-bdr-fw-01_GlobalNAT_AllZones-Outside.qualcomm.com [103.229.18.19]) by mx0a-0031df01.pphosted.com (PPS) with ESMTPS id 4chg2gt5b7-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:25:00 +0000 (GMT) Received: from pps.filterd (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (8.18.1.2/8.18.1.2) with ESMTP id 61P6OMs6001164; Wed, 25 Feb 2026 06:24:56 GMT Received: from pps.reinject (localhost [127.0.0.1]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 4cf5sm83f0-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: from APBLRPPMTA01.qualcomm.com (APBLRPPMTA01.qualcomm.com [127.0.0.1]) by pps.reinject (8.17.1.5/8.17.1.5) with ESMTP id 61P6OuWg001356; Wed, 25 Feb 2026 06:24:56 GMT Received: from hu-devc-blr-u24-a.qualcomm.com (hu-anuppate-blr.qualcomm.com [10.131.36.165]) by APBLRPPMTA01.qualcomm.com (PPS) with ESMTPS id 61P6OtZL001305 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Wed, 25 Feb 2026 06:24:56 +0000 Received: by hu-devc-blr-u24-a.qualcomm.com (Postfix, from userid 486687) id D633224B4A; Wed, 25 Feb 2026 11:54:53 +0530 (+0530) From: Anup Patel To: Rob Herring , Krzysztof Kozlowski , Conor Dooley , Palmer Dabbelt , Paul Walmsley , Greg KH , Alexander Shishkin , Ian Rogers Cc: Alexandre Ghiti , Peter Zijlstra , Ingo Molnar , Namhyung Kim , Mark Rutland , Jiri Olsa , Adrian Hunter , Liang Kan , Mayuresh Chitale , Anup Patel , Atish Patra , Andrew Jones , Sunil V L , linux-riscv@lists.infradead.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, Mayuresh Chitale , Anup Patel Subject: [PATCH v3 09/12] rvtrace: Add perf driver for tracing using perf tool Date: Wed, 25 Feb 2026 11:54:45 +0530 Message-ID: <20260225062448.4027948-10-anup.patel@oss.qualcomm.com> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> References: <20260225062448.4027948-1-anup.patel@oss.qualcomm.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-QCInternal: smtphost X-QCInternal: smtphost X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-Virus-Version: vendor=nai engine=6200 definitions=5800 signatures=585085 X-Proofpoint-ORIG-GUID: iELcoQ1p8Uc2AVZNPWV_kZDEEQqEibRj X-Proofpoint-Spam-Details-Enc: AW1haW4tMjYwMjI1MDA2MSBTYWx0ZWRfX3T4gF/WaWhRi ohEAs3PvgkeMIqBlkf2x5OyN0cI2PoOVVNClviSFIHPDykRFUsLqjLEreYWM5iOkZIRdplj0AjH GNpsSUTcK9DhALtA8lXgFpRrK8KAwxy0obgufqZGgi21n3h1rZLYAsOosSA3jMRYloQwL0GEvym jUGFLU+QLdu6L11Vd6I87CQtUpHJghaymR/rrpPvgZjv79ibAvfYDznMsiqlFpTXnQgm3DRPJEm utkCX83SamryZgjb2IyaZHYY1EJy3C7mZiCzbFfaImzTDXsjXINNrBuQW6GtaCkYS6Fzj1GrSNQ Y7P7ynxAljHkosx/DqVTTR0ktI1rUntacIuhKC/7qyew7ce+EvBn9apVQkJra8if6v7dDl7RABD brKSxvoZTa/GnWJbdACxth2isHN1PngZTqy+LWmbzscATd1IfY9P/bwLjEBkGlXIo3d7yXSZHSo bTVMJV1u7ZuxkqzjlaA== X-Authority-Analysis: v=2.4 cv=ftHRpV4f c=1 sm=1 tr=0 ts=699e95bc cx=c_pps a=Ou0eQOY4+eZoSc0qltEV5Q==:117 a=Ou0eQOY4+eZoSc0qltEV5Q==:17 a=HzLeVaNsDn8A:10 a=VkNPw1HP01LnGYTKEx00:22 a=u7WPNUs3qKkmUXheDGA7:22 a=_glEPmIy2e8OvE2BGh3C:22 a=EUspDBNiAAAA:8 a=HURrUvzjhtnrdgnosHYA:9 X-Proofpoint-GUID: iELcoQ1p8Uc2AVZNPWV_kZDEEQqEibRj X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1121,Hydra:6.1.51,FMLib:17.12.100.49 definitions=2026-02-24_03,2026-02-23_03,2025-10-01_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 priorityscore=1501 malwarescore=0 suspectscore=0 clxscore=1015 spamscore=0 impostorscore=0 lowpriorityscore=0 phishscore=0 bulkscore=0 adultscore=0 classifier=typeunknown authscore=0 authtc= authcc= route=outbound adjust=0 reason=mlx scancount=1 engine=8.22.0-2602130000 definitions=main-2602250061 Content-Type: text/plain; charset="utf-8" From: Mayuresh Chitale Add perf driver for RISC-V tracing similar to ARM Coresight and Hisilicon PTT drivers. The driver adds 'rvtrace' event descriptor which can be used by the perf tool to record the RISC-V trace data. Co-developed-by: Anup Patel Signed-off-by: Anup Patel Signed-off-by: Mayuresh Chitale --- drivers/hwtracing/rvtrace/Kconfig | 1 + drivers/hwtracing/rvtrace/Makefile | 2 +- drivers/hwtracing/rvtrace/rvtrace-core.c | 8 + drivers/hwtracing/rvtrace/rvtrace-perf.c | 341 +++++++++++++++++++++++ include/linux/rvtrace.h | 3 + 5 files changed, 354 insertions(+), 1 deletion(-) create mode 100644 drivers/hwtracing/rvtrace/rvtrace-perf.c diff --git a/drivers/hwtracing/rvtrace/Kconfig b/drivers/hwtracing/rvtrace/= Kconfig index 0577f9acb858..ba11acf1117d 100644 --- a/drivers/hwtracing/rvtrace/Kconfig +++ b/drivers/hwtracing/rvtrace/Kconfig @@ -4,6 +4,7 @@ menuconfig RVTRACE tristate "RISC-V Trace Support" depends on RISCV depends on OF + select PERF_EVENTS default RISCV help This framework provides a kernel interface for the RISC-V trace diff --git a/drivers/hwtracing/rvtrace/Makefile b/drivers/hwtracing/rvtrace= /Makefile index 122e575da9fb..07403f4d94e3 100644 --- a/drivers/hwtracing/rvtrace/Makefile +++ b/drivers/hwtracing/rvtrace/Makefile @@ -1,6 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 =20 obj-$(CONFIG_RVTRACE) +=3D rvtrace.o -rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o +rvtrace-y :=3D rvtrace-core.o rvtrace-platform.o rvtrace-perf.o obj-$(CONFIG_RVTRACE_ENCODER) +=3D rvtrace-encoder.o obj-$(CONFIG_RVTRACE_RAMSINK) +=3D rvtrace-ramsink.o diff --git a/drivers/hwtracing/rvtrace/rvtrace-core.c b/drivers/hwtracing/r= vtrace/rvtrace-core.c index 1a1484c1eca4..159d3df0aa41 100644 --- a/drivers/hwtracing/rvtrace/rvtrace-core.c +++ b/drivers/hwtracing/rvtrace/rvtrace-core.c @@ -766,11 +766,19 @@ static int __init rvtrace_init(void) return ret; } =20 + ret =3D rvtrace_perf_init(); + if (ret) { + platform_driver_unregister(&rvtrace_platform_driver); + bus_unregister(&rvtrace_bustype); + return ret; + } + return 0; } =20 static void __exit rvtrace_exit(void) { + rvtrace_perf_exit(); platform_driver_unregister(&rvtrace_platform_driver); bus_unregister(&rvtrace_bustype); } diff --git a/drivers/hwtracing/rvtrace/rvtrace-perf.c b/drivers/hwtracing/r= vtrace/rvtrace-perf.c new file mode 100644 index 000000000000..dca83589c419 --- /dev/null +++ b/drivers/hwtracing/rvtrace/rvtrace-perf.c @@ -0,0 +1,341 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2026 Qualcomm Technologies, Inc. + * Author: Mayuresh Chitale + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define RVTRACE_PMU_NAME "rvtrace" +static struct pmu rvtrace_pmu; +static DEFINE_SPINLOCK(perf_buf_lock); + +/** + * struct rvtrace_event_data - RISC-V trace specific perf event data + * @work: Handle to free allocated memory outside IRQ context. + * @mask: Hold the CPU(s) this event was set for. + * @aux_hwid_done: Whether a CPU has emitted the TraceID packet or not. + * @path: An array of path, each slot for one CPU. + * @buf: Aux buffer / pages allocated by perf framework. + */ +struct rvtrace_event_data { + struct work_struct work; + cpumask_t mask; + cpumask_t aux_hwid_done; + struct rvtrace_path * __percpu *path; + struct rvtrace_perf_auxbuf buf; +}; + +struct rvtrace_ctxt { + struct perf_output_handle handle; + struct rvtrace_event_data *event_data; +}; + +static DEFINE_PER_CPU(struct rvtrace_ctxt, rvtrace_ctxt); + +static void *alloc_event_data(int cpu) +{ + struct rvtrace_event_data *event_data; + cpumask_t *mask; + + event_data =3D kzalloc(sizeof(*event_data), GFP_KERNEL); + if (!event_data) + return NULL; + + /* Update mask as per selected CPUs */ + mask =3D &event_data->mask; + if (cpu !=3D -1) + cpumask_set_cpu(cpu, mask); + else + cpumask_copy(mask, cpu_present_mask); + + event_data->path =3D alloc_percpu(struct rvtrace_path *); + return event_data; +} + +static void rvtrace_free_aux(void *data) +{ + struct rvtrace_event_data *event_data =3D data; + + schedule_work(&event_data->work); +} + +static struct rvtrace_path **rvtrace_event_cpu_path_ptr(struct rvtrace_eve= nt_data *data, + int cpu) +{ + return per_cpu_ptr(data->path, cpu); +} + +static void free_event_data(struct work_struct *work) +{ + struct rvtrace_event_data *event_data; + struct rvtrace_path *path; + cpumask_t *mask; + int cpu; + + event_data =3D container_of(work, struct rvtrace_event_data, work); + mask =3D &event_data->mask; + for_each_cpu(cpu, mask) { + path =3D *rvtrace_event_cpu_path_ptr(event_data, cpu); + rvtrace_destroy_path(path); + } + free_percpu(event_data->path); + kfree(event_data); +} + +static void *rvtrace_setup_aux(struct perf_event *event, void **pages, + int nr_pages, bool overwrite) +{ + struct rvtrace_event_data *event_data =3D NULL; + struct page **pagelist; + int cpu =3D event->cpu, i; + cpumask_t *mask; + + event_data =3D alloc_event_data(cpu); + if (!event_data) + return NULL; + + INIT_WORK(&event_data->work, free_event_data); + mask =3D &event_data->mask; + /* + * Create the path for each CPU in the mask. In case of any failure skip = the CPU + */ + for_each_cpu(cpu, mask) { + struct rvtrace_component *src; + struct rvtrace_path *path; + + src =3D rvtrace_cpu_source(cpu); + if (!src) + continue; + + path =3D rvtrace_create_path(src, NULL, RVTRACE_COMPONENT_MODE_PERF); + if (!path) + continue; + + *rvtrace_event_cpu_path_ptr(event_data, cpu) =3D path; + } + + /* If we don't have any CPUs ready for tracing, abort */ + cpu =3D cpumask_first(&event_data->mask); + if (cpu >=3D nr_cpu_ids) + goto err; + + pagelist =3D kcalloc(nr_pages, sizeof(*pagelist), GFP_KERNEL); + if (!pagelist) + goto err; + + for (i =3D 0; i < nr_pages; i++) + pagelist[i] =3D virt_to_page(pages[i]); + + event_data->buf.base =3D vmap(pagelist, nr_pages, VM_MAP, PAGE_KERNEL); + if (!event_data->buf.base) { + kfree(pagelist); + goto err; + } + + event_data->buf.nr_pages =3D nr_pages; + event_data->buf.length =3D nr_pages * PAGE_SIZE; + event_data->buf.pos =3D 0; + return event_data; +err: + rvtrace_free_aux(event_data); + return NULL; +} + +static void rvtrace_event_read(struct perf_event *event) +{ +} + +static void rvtrace_event_destroy(struct perf_event *event) +{ +} + +static int rvtrace_event_init(struct perf_event *event) +{ + if (event->attr.type !=3D rvtrace_pmu.type) + return -EINVAL; + + event->destroy =3D rvtrace_event_destroy; + return 0; +} + +static void rvtrace_event_start(struct perf_event *event, int flags) +{ + struct rvtrace_ctxt *ctxt =3D this_cpu_ptr(&rvtrace_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct rvtrace_event_data *event_data; + int cpu =3D smp_processor_id(); + struct rvtrace_path *path; + + if (WARN_ON(ctxt->event_data)) + goto fail; + + /* + * Deal with the ring buffer API and get a handle on the + * session's information. + */ + event_data =3D perf_aux_output_begin(handle, event); + if (!event_data) + goto fail; + + if (!cpumask_test_cpu(cpu, &event_data->mask)) + goto out; + + event_data->buf.pos =3D handle->head % event_data->buf.length; + path =3D *rvtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (rvtrace_path_start(path)) { + pr_err("Error. Tracing not started\n"); + return; + } + + /* + * output cpu / trace ID in perf record, once for the lifetime + * of the event. + */ + if (!cpumask_test_cpu(cpu, &event_data->aux_hwid_done)) { + cpumask_set_cpu(cpu, &event_data->aux_hwid_done); + perf_report_aux_output_id(event, cpu); + } + +out: + /* Tell the perf core the event is alive */ + event->hw.state =3D 0; + ctxt->event_data =3D event_data; + return; +fail: + event->hw.state =3D PERF_HES_STOPPED; +} + +static void rvtrace_event_stop(struct perf_event *event, int mode) +{ + struct rvtrace_ctxt *ctxt =3D this_cpu_ptr(&rvtrace_ctxt); + struct perf_output_handle *handle =3D &ctxt->handle; + struct rvtrace_event_data *event_data; + int ret, cpu =3D smp_processor_id(); + struct rvtrace_path *path; + size_t size; + + if (event->hw.state =3D=3D PERF_HES_STOPPED) + return; + + if (handle->event && + WARN_ON(perf_get_aux(handle) !=3D ctxt->event_data)) + return; + + event_data =3D ctxt->event_data; + ctxt->event_data =3D NULL; + + if (WARN_ON(!event_data)) + return; + + if (handle->event && (mode & PERF_EF_UPDATE) && !cpumask_test_cpu(cpu, &e= vent_data->mask)) { + event->hw.state =3D PERF_HES_STOPPED; + perf_aux_output_end(handle, 0); + return; + } + + /* stop tracing */ + path =3D *rvtrace_event_cpu_path_ptr(event_data, cpu); + if (!path) { + pr_err("Error. Path not found\n"); + return; + } + + if (rvtrace_path_stop(path)) { + pr_err("Error. Tracing not stopped\n"); + return; + } + + event->hw.state =3D PERF_HES_STOPPED; + if (handle->event && (mode & PERF_EF_UPDATE)) { + if (WARN_ON_ONCE(handle->event !=3D event)) + return; + spin_lock(&perf_buf_lock); + ret =3D rvtrace_path_copyto_auxbuf(path, &event_data->buf, &size); + spin_unlock(&perf_buf_lock); + WARN_ON_ONCE(ret); + if (READ_ONCE(handle->event)) + perf_aux_output_end(handle, size); + else + WARN_ON(size); + } +} + +static int rvtrace_event_add(struct perf_event *event, int mode) +{ + struct hw_perf_event *hwc =3D &event->hw; + int ret =3D 0; + + if (mode & PERF_EF_START) { + rvtrace_event_start(event, 0); + if (hwc->state & PERF_HES_STOPPED) + ret =3D -EINVAL; + } else { + hwc->state =3D PERF_HES_STOPPED; + } + + return ret; +} + +static void rvtrace_event_del(struct perf_event *event, int mode) +{ + rvtrace_event_stop(event, PERF_EF_UPDATE); +} + +PMU_FORMAT_ATTR(event, "config:0-0"); + +static struct attribute *rvtrace_pmu_formats_attr[] =3D { + &format_attr_event.attr, + NULL, +}; + +static struct attribute_group rvtrace_pmu_format_group =3D { + .name =3D "format", + .attrs =3D rvtrace_pmu_formats_attr, +}; + +static const struct attribute_group *rvtrace_pmu_attr_groups[] =3D { + &rvtrace_pmu_format_group, + NULL, +}; + +int __init rvtrace_perf_init(void) +{ + rvtrace_pmu.capabilities =3D (PERF_PMU_CAP_EXCLUSIVE | PERF_PMU_CAP_ITRAC= E); + rvtrace_pmu.attr_groups =3D rvtrace_pmu_attr_groups; + rvtrace_pmu.task_ctx_nr =3D perf_sw_context; + rvtrace_pmu.read =3D rvtrace_event_read; + rvtrace_pmu.event_init =3D rvtrace_event_init; + rvtrace_pmu.setup_aux =3D rvtrace_setup_aux; + rvtrace_pmu.free_aux =3D rvtrace_free_aux; + rvtrace_pmu.start =3D rvtrace_event_start; + rvtrace_pmu.stop =3D rvtrace_event_stop; + rvtrace_pmu.add =3D rvtrace_event_add; + rvtrace_pmu.del =3D rvtrace_event_del; + rvtrace_pmu.module =3D THIS_MODULE; + + return perf_pmu_register(&rvtrace_pmu, RVTRACE_PMU_NAME, -1); +} + +void __exit rvtrace_perf_exit(void) +{ + perf_pmu_unregister(&rvtrace_pmu); +} diff --git a/include/linux/rvtrace.h b/include/linux/rvtrace.h index 36663c7b3e30..0cb3bd474c2b 100644 --- a/include/linux/rvtrace.h +++ b/include/linux/rvtrace.h @@ -346,4 +346,7 @@ static inline int rvtrace_comp_poll_empty(struct rvtrac= e_component *comp) comp->pdata->control_poll_timeout_usecs); } =20 +int rvtrace_perf_init(void); +void rvtrace_perf_exit(void); + #endif --=20 2.43.0