Extend gtrace_driver with alloc_buf() and free_buf() so a sink can allocate its own buffer (e.g. an ETR SG table) during perf setup and release it when the event data is freed. Store the resulting buffer in gtrace_perf_auxbuf along with the event pid and snapshot mode.
Signed-off-by: Zane Leung liangzhen@linux.spacemit.com --- drivers/hwtracing/gtrace/gtrace-perf.c | 34 ++++++++++++++++++++++++++ include/linux/gtrace.h | 12 +++++++++ 2 files changed, 46 insertions(+)
diff --git a/drivers/hwtracing/gtrace/gtrace-perf.c b/drivers/hwtracing/gtrace/gtrace-perf.c index 9b874daa807f..e05a833aa6a4 100644 --- a/drivers/hwtracing/gtrace/gtrace-perf.c +++ b/drivers/hwtracing/gtrace/gtrace-perf.c @@ -86,6 +86,27 @@ static struct gtrace_path **gtrace_event_cpu_path_ptr(struct gtrace_event_data * return per_cpu_ptr(data->path, cpu); }
+static void free_sink_buffer(struct gtrace_event_data *event_data) +{ + int cpu; + cpumask_t *mask = &event_data->mask; + struct gtrace_path *path; + struct gtrace_component *sink; + struct gtrace_driver *sinkdrv; + + if (!event_data->buf.buf) + return; + + if (WARN_ON(cpumask_empty(mask))) + return; + + cpu = cpumask_first(mask); + path = *gtrace_event_cpu_path_ptr(event_data, cpu); + sink = gtrace_path_sink(path); + sinkdrv = to_gtrace_driver(sink->dev.driver); + sinkdrv->free_buf(event_data->buf.buf); +} + static void free_event_data(struct work_struct *work) { struct gtrace_event_data *event_data; @@ -95,6 +116,7 @@ static void free_event_data(struct work_struct *work)
event_data = container_of(work, struct gtrace_event_data, work); mask = &event_data->mask; + free_sink_buffer(event_data); for_each_cpu(cpu, mask) { path = *gtrace_event_cpu_path_ptr(event_data, cpu); gtrace_destroy_path(path); @@ -110,6 +132,7 @@ static void *gtrace_setup_aux(struct perf_event *event, void **pages, { struct gtrace_event_data *event_data = NULL; struct gtrace_component *sink = NULL; + struct gtrace_driver *sinkdrv = NULL; struct page **pagelist; int cpu = event->cpu, i; cpumask_t *mask; @@ -175,6 +198,17 @@ static void *gtrace_setup_aux(struct perf_event *event, void **pages, event_data->buf.nr_pages = nr_pages; event_data->buf.length = nr_pages * PAGE_SIZE; event_data->buf.pos = 0; + event_data->buf.snapshot = overwrite; + event_data->buf.pages = pages; + + sinkdrv = to_gtrace_driver(sink->dev.driver); + if (sinkdrv && sinkdrv->alloc_buf) { + event_data->buf.buf = sinkdrv->alloc_buf(sink, event, pages, + nr_pages, overwrite); + if (!event_data->buf.buf) + goto err; + } + return event_data; err: gtrace_free_aux(event_data); diff --git a/include/linux/gtrace.h b/include/linux/gtrace.h index 39ae13701615..a3d125882ec9 100644 --- a/include/linux/gtrace.h +++ b/include/linux/gtrace.h @@ -355,12 +355,18 @@ int gtrace_path_stop(struct gtrace_path *path); * @nr_pages: Number of pages of the AUX buffer. * @base: Start address of AUX buffer. * @pos: Position in the AUX buffer to commit traced data. + * @snapshot: Is this run in snapshot mode. + * @pages: a handle to the ring buffer. + * @buf: Optional sink-specific buffer. */ struct gtrace_perf_auxbuf { size_t length; int nr_pages; void *base; long pos; + bool snapshot; + void **pages; + void *buf; };
int gtrace_path_copyto_auxbuf(struct gtrace_path *path, @@ -371,6 +377,8 @@ int gtrace_path_copyto_auxbuf(struct gtrace_path *path, /** * struct gtrace_driver - Representation of a trace driver. * @id_table: Table to match components handled by the driver. + * @alloc_buf: Callback to alloc sink-specific buffer. + * @free_buf: Callback to free sink-specific buffer. * @copyto_auxbuf: Callback to copy data into perf AUX buffer. The driver * reports the PMU specific trace format of the copied data * via @handle (see PERF_AUX_FLAG_PMU_FORMAT_TYPE_MASK). @@ -386,6 +394,10 @@ int gtrace_path_copyto_auxbuf(struct gtrace_path *path, */ struct gtrace_driver { const struct gtrace_component_id *id_table; + void *(*alloc_buf)(struct gtrace_component *comp, + struct perf_event *event, void **pages, + int nr_pages, bool overwrite); + void (*free_buf)(void *buf); size_t (*copyto_auxbuf)(struct gtrace_component *comp, struct perf_output_handle *handle, struct gtrace_perf_auxbuf *buf);