[PATCH 18/24] gtrace: Add sink-specific buffer alloc/free callbacks

[Zane Leung <liangzhen@linux.spacemit.com>]

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);
-- 
2.34.1