trace: Runtime filter message handler

src/include/ipc/header.h

@@ -266,6 +266,7 @@
 #define SOF_IPC_TRACE_DMA_PARAMS SOF_CMD_TYPE(0x001)
 #define SOF_IPC_TRACE_DMA_POSITION SOF_CMD_TYPE(0x002)
 #define SOF_IPC_TRACE_DMA_PARAMS_EXT SOF_CMD_TYPE(0x003)
+#define SOF_IPC_TRACE_FILTER_UPDATE SOF_CMD_TYPE(0x004) /**< ABI3.17 */
 
 /** @} */
 

src/include/ipc/trace.h

@@ -11,6 +11,7 @@
  * \brief IPC definitions
  * \author Liam Girdwood <liam.r.girdwood@linux.intel.com>
  * \author Keyon Jie <yang.jie@linux.intel.com>
+ * \author Karol Trzcinski <karolx.trzcinski@linux.intel.com>
  */
 
 #ifndef __IPC_TRACE_H__
@@ -51,6 +52,35 @@ struct sof_ipc_dma_trace_posn {
 	uint32_t messages;	/* total trace messages */
 } __attribute__((packed));
 
+/* Values used in sof_ipc_trace_filter_elem */
+
+/* bits 6..0 */
+#define SOF_IPC_TRACE_FILTER_ELEM_SET_LEVEL	0x01	/**< trace level for selected components */
+#define SOF_IPC_TRACE_FILTER_ELEM_BY_UUID	0x02	/**< filter by uuid key */
+#define SOF_IPC_TRACE_FILTER_ELEM_BY_COMP	0x03	/**< filter by component id */
+#define SOF_IPC_TRACE_FILTER_ELEM_BY_PIPE	0x04	/**< filter by pipeline */
+#define SOF_IPC_TRACE_FILTER_ELEM_TYPE_MASK	0x7F	/**< filter element type mask */
+
+/* bit 7 */
+#define SOF_IPC_TRACE_FILTER_ELEM_FIN	0x80	/**< mark last filter in set */
+
+/* bits 31..8: Unused */
+
+/** part of sof_ipc_trace_filter, ABI3.17 */
+struct sof_ipc_trace_filter_elem {
+	int32_t key; /**< SOF_IPC_TRACE_FILTER_ELEM_ {LEVEL, UUID, COMP, PIPE} */
+	int32_t value; /**< element value */
+} __attribute__((packed));
+
+/** Runtime tracing filtration data - SOF_IPC_TRACE_FILTER_UPDATE, ABI3.17 */
+struct sof_ipc_trace_filter {
+	struct sof_ipc_cmd_hdr hdr;	/**< IPC command header */
+	uint32_t elem_cnt; /**< number of entries in elems[] array */
+	uint32_t reserved[8]; /**< reserved for future usage */
+	/** variable size array with new filtering settings */
+	struct sof_ipc_trace_filter_elem elems[];
+} __attribute__((packed));
+
 /*
  * Commom debug
  */

src/include/sof/trace/trace.h

@@ -5,6 +5,7 @@
  * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
  * Keyon Jie <yang.jie@linux.intel.com>
  * Artur Kloniecki <arturx.kloniecki@linux.intel.com>
+ * Karol Trzcinski <karolx.trzcinski@linux.intel.com>
  */
 
 #ifndef __SOF_TRACE_TRACE_H__
@@ -86,6 +87,13 @@ static inline struct trace *trace_get(void)
 #define trace_unused(class, ctx, id_1, id_2, format, ...) \
 	UNUSED(ctx, id_1, id_2, ##__VA_ARGS__)
 
+struct trace_filter {
+	uint32_t uuid_id;	/**< type id, or 0 when not important */
+	int32_t comp_id;	/**< component id or -1 when not important */
+	int32_t pipe_id;	/**< pipeline id or -1 when not important */
+	int32_t log_level;	/**< new log level value */
+};
+
 #if CONFIG_TRACE
 
 /*
@@ -131,6 +139,10 @@ void trace_init(struct sof *sof);
 void trace_log(bool send_atomic, const void *log_entry,
  const struct tr_ctx *ctx, uint32_t lvl, uint32_t id_1,
  uint32_t id_2, int arg_count, ...);
+struct sof_ipc_trace_filter_elem *trace_filter_fill(struct sof_ipc_trace_filter_elem *elem,
+ struct sof_ipc_trace_filter_elem *end,
+ struct trace_filter *filter);
+int trace_filter_update(const struct trace_filter *elem);
 
 #define _trace_event_with_ids(lvl, class, ctx, id_1, id_2, format, ...)	\
 	_log_message(false, lvl, class, ctx, id_1, id_2, \
@@ -222,6 +234,8 @@ static inline void trace_flush(void) { }
 static inline void trace_on(void) { }
 static inline void trace_off(void) { }
 static inline void trace_init(struct sof *sof) { }
+static inline int trace_filter_update(const struct trace_filter *filter)
+	{ return 0; }
 
 #endif /* CONFIG_TRACE */
 

src/include/user/abi_dbg.h

@@ -19,7 +19,7 @@
 #define __USER_ABI_DBG_H__
 
 #define SOF_ABI_DBG_MAJOR 5
-#define SOF_ABI_DBG_MINOR 1
+#define SOF_ABI_DBG_MINOR 2
 #define SOF_ABI_DBG_PATCH 0
 
 #define SOF_ABI_DBG_VERSION SOF_ABI_VER(SOF_ABI_DBG_MAJOR, \

src/ipc/handler.c

@@ -747,6 +747,55 @@ static int ipc_dma_trace_config(uint32_t header)
 	return err;
 }
 
+static int ipc_trace_filter_update(uint32_t header)
+{
+	struct sof_ipc_trace_filter_elem *next_elem;
+	struct sof_ipc_trace_filter_elem *elem;
+	struct sof_ipc_trace_filter_elem *end;
+	struct sof_ipc_trace_filter *packet;
+	struct trace_filter filter;
+	struct ipc *ipc = ipc_get();
+	int ret = 0;
+	int cnt;
+
+	packet = ipc->comp_data;
+	elem = packet->elems;
+	end = &packet->elems[packet->elem_cnt];
+
+	/* validation, packet->hdr.size has already been compared with SOF_IPC_MSG_MAX_SIZE */
+	if (sizeof(*packet) + sizeof(*elem) * packet->elem_cnt != packet->hdr.size) {
+ tr_err(&ipc_tr, "trace_filter_update failed, elem_cnt %d is inconsistent with hdr.size %d",
+ packet->elem_cnt, packet->hdr.size);
+ return -EINVAL;
+	}
+
+	tr_info(&ipc_tr, "ipc: trace_filter_update received, size %d elems",
+ packet->elem_cnt);
+
+	/* read each filter set and update selected components trace settings */
+	while (elem != end) {
+ next_elem = trace_filter_fill(elem, end, &filter);
+ if (!next_elem)
+ return -EINVAL;
+
+ cnt = trace_filter_update(&filter);
+ if (cnt < 0) {
+ tr_err(&ipc_tr, "trace_filter_update failed for UUID key 0x%X, comp %d.%d and log level %d",
+ filter.uuid_id, filter.pipe_id, filter.comp_id,
+ filter.log_level);
+ ret = cnt;
+ } else {
+ tr_info(&ipc_tr, "trace_filter_update for UUID key 0x%X, comp %d.%d affected %d components",
+ filter.uuid_id, filter.pipe_id, filter.comp_id,
+ cnt);
+ }
+
+ elem = next_elem;
+	}
+
+	return ret;
+}
+
 static int ipc_glb_debug_message(uint32_t header)
 {
 	uint32_t cmd = iCS(header);
@@ -757,6 +806,8 @@ static int ipc_glb_debug_message(uint32_t header)
 	case SOF_IPC_TRACE_DMA_PARAMS:
 	case SOF_IPC_TRACE_DMA_PARAMS_EXT:
  return ipc_dma_trace_config(header);
+	case SOF_IPC_TRACE_FILTER_UPDATE:
+ return ipc_trace_filter_update(header);
 	default:
  tr_err(&ipc_tr, "ipc: unknown debug cmd 0x%x", cmd);
  return -EINVAL;

src/trace/trace.c

@@ -4,8 +4,10 @@
 //
 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
 // Artur Kloniecki <arturx.kloniecki@linux.intel.com>
+// Karol Trzcinski <karolx.trzcinski@linux.intel.com>
 
 #include <sof/debug/panic.h>
+#include <sof/drivers/ipc.h>
 #include <sof/drivers/timer.h>
 #include <sof/lib/alloc.h>
 #include <sof/lib/cache.h>
@@ -155,6 +157,147 @@ void trace_log(bool send_atomic, const void *log_entry,
 #endif /* CONFIG_TRACEM */
 }
 
+struct sof_ipc_trace_filter_elem *trace_filter_fill(struct sof_ipc_trace_filter_elem *elem,
+ struct sof_ipc_trace_filter_elem *end,
+ struct trace_filter *filter)
+{
+	filter->log_level = -1;
+	filter->uuid_id = 0;
+	filter->comp_id = -1;
+	filter->pipe_id = -1;
+
+	while (elem <= end) {
+ switch (elem->key & SOF_IPC_TRACE_FILTER_ELEM_TYPE_MASK) {
+ case SOF_IPC_TRACE_FILTER_ELEM_SET_LEVEL:
+ filter->log_level = elem->value;
+ break;
+ case SOF_IPC_TRACE_FILTER_ELEM_BY_UUID:
+ filter->uuid_id = elem->value;
+ break;
+ case SOF_IPC_TRACE_FILTER_ELEM_BY_COMP:
+ filter->comp_id = elem->value;
+ break;
+ case SOF_IPC_TRACE_FILTER_ELEM_BY_PIPE:
+ filter->pipe_id = elem->value;
+ break;
+ default:
+ tr_err(&ipc_tr, "Invalid SOF_IPC_TRACE_FILTER_ELEM 0x%x",
+ elem->key);
+ return NULL;
+ }
+
+ /* each filter set must be terminated with FIN flag and have new log level */
+ if (elem->key & SOF_IPC_TRACE_FILTER_ELEM_FIN) {
+ if (filter->log_level < 0) {
+ tr_err(&ipc_tr, "Each trace filter set must specify new log level");
+ return NULL;
+ } else {
+ return elem + 1;
+ }
+ }
+
+ ++elem;
+	}
+
+	tr_err(&ipc_tr, "Trace filter elements set is not properly terminated");
+	return NULL;
+}
+
+/* update global components, which tr_ctx is stored inside special section */
+static int trace_filter_update_global(int32_t log_level, uint32_t uuid_id)
+{
+	extern void *_trace_ctx_start;
+	extern void *_trace_ctx_end;
+	struct tr_ctx *ptr = (struct tr_ctx *)&_trace_ctx_start;
+	struct tr_ctx *end = (struct tr_ctx *)&_trace_ctx_end;
+	int cnt = 0;
+
+	/* iterate over global `tr_ctx` entries located in their own section */
+	while (ptr < end) {
+ /*
+ * when looking for specific uuid element,
+ * then find, update and stop searching
+ */
+ if ((uint32_t)ptr->uuid_p == uuid_id) {
+ ptr->level = log_level;
+ return 1;
+ }
+ /* otherwise each element should be updated */
+ if (!ptr->uuid_p) {
+ ptr->level = log_level;
+ ++cnt;
+ }
+ ++ptr;
+	}
+
+	return cnt;
+}
+
+/* return trace context from any ipc component type */
+static struct tr_ctx *trace_filter_ipc_comp_context(struct ipc_comp_dev *icd)
+{
+	switch (icd->type) {
+	case COMP_TYPE_COMPONENT:
+ return &icd->cd->tctx;
+	case COMP_TYPE_BUFFER:
+ return &icd->cb->tctx;
+	case COMP_TYPE_PIPELINE:
+ return &icd->pipeline->tctx;
+	/* each COMP_TYPE must be specified */
+	default:
+ tr_err(&ipc_tr, "Unknown trace context for ipc component type 0x%X",
+ icd->type);
+ return NULL;
+	}
+}
+
+/* update ipc components, wchich tr_ctx may be read from ipc_comp_dev structure */
+static int trace_filter_update_instances(int32_t log_level, uint32_t uuid_id,
+ int32_t pipe_id, int32_t comp_id)
+{
+	struct ipc *ipc = ipc_get();
+	struct ipc_comp_dev *icd;
+	struct list_item *clist;
+	struct tr_ctx *ctx;
+	bool correct_comp;
+	int cnt = 0;
+
+	/* compare each ipc component with filter settings and update log level after pass */
+	list_for_item(clist, &ipc->comp_list) {
+ icd = container_of(clist, struct ipc_comp_dev, list);
+ ctx = trace_filter_ipc_comp_context(icd);
+ correct_comp = comp_id == -1 || icd->id == comp_id; /* todo: icd->topo_id */
+ correct_comp &= uuid_id == 0 || (uint32_t)ctx->uuid_p == uuid_id;
+ correct_comp &= pipe_id == -1 || ipc_comp_pipe_id(icd) == pipe_id;
+ if (correct_comp) {
+ ctx->level = log_level;
+ ++cnt;
+ }
+
+ platform_shared_commit(icd, sizeof(*icd));
+	}
+	return cnt;
+}
+
+int trace_filter_update(const struct trace_filter *filter)
+{
+	int ret = 0;
+
+	/* validate log level, LOG_LEVEL_CRITICAL has low value, LOG_LEVEL_VERBOSE high */
+	if (filter->log_level < LOG_LEVEL_CRITICAL ||
+ filter->log_level > LOG_LEVEL_VERBOSE)
+ return -EINVAL;
+
+	/* update `*`, `name*` or global `name` */
+	if (filter->pipe_id == -1 && filter->comp_id == -1)
+ ret = trace_filter_update_global(filter->log_level, filter->uuid_id);
+
+	/* update `*`, `name*`, `nameX.*` or `nameX.Y`, `name` may be '*' */
+	ret += trace_filter_update_instances(filter->log_level, filter->uuid_id,
+ filter->pipe_id, filter->comp_id);
+	return ret > 0 ? ret : -EINVAL;
+}
+
 void trace_flush(void)
 {
 	struct trace *trace = trace_get();