sof/tools/logger/filter.c

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2020 Intel Corporation. All rights reserved.
 *
 * Author: Karol Trzcinski	<karolx.trzcinski@linux.intel.com>
 */

#include <ipc/trace.h>
#include <smex/ldc.h>
#include <sof/lib/uuid.h>
#include <sof/list.h>
#include <user/trace.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "convert.h"
#include "filter.h"
#include "misc.h"

#define COMPONENTS_SEPARATOR ','
#define COMPONENT_NAME_SCAN_STRING_LENGTH 32

extern struct convert_config *global_config;

/** map between log level given by user and enum value */
static const struct {
	const char name[16];
	int32_t log_level;
} log_level_dict[] = {
	{"verbose",	LOG_LEVEL_VERBOSE},
	{"debug",	LOG_LEVEL_DEBUG},
	{"info",	LOG_LEVEL_INFO},
	{"warning",	LOG_LEVEL_WARNING},
	{"error",	LOG_LEVEL_ERROR},
	{"critical",	LOG_LEVEL_CRITICAL},
	{"v",		LOG_LEVEL_VERBOSE},
	{"d",		LOG_LEVEL_DEBUG},
	{"i",		LOG_LEVEL_INFO},
	{"w",		LOG_LEVEL_WARNING},
	{"e",		LOG_LEVEL_ERROR},
	{"c",		LOG_LEVEL_CRITICAL},
};

struct filter_element {
	struct list_item list;
	int32_t uuid_id;	/**< type id, or -1 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 */
};

/**
 * Search for uuid entry with given component name in given uids dictionary
 * @param name of uuid entry
 * @return pointer to sof_uuid_entry with given name
 */
static struct sof_uuid_entry *get_uuid_by_name(const char *name)
{
	const struct snd_sof_uids_header *uids_dict = global_config->uids_dict;
	uintptr_t beg = (uintptr_t)uids_dict + uids_dict->data_offset;
	uintptr_t end = beg + uids_dict->data_length;
	struct sof_uuid_entry *ptr = (struct sof_uuid_entry *)beg;

	while ((uintptr_t)ptr < end) {
		if (strcmp(name, ptr->name) == 0)
			return ptr;
		++ptr;
	}
	return NULL;
}

/**
 * Parse log level name (from log_level_dict) to enum value.
 * Take care about possible whitespace at the begin.
 * @param value_start pointer to the begin of range to search
 * @return enum value for given log level, or -1 for invalid value
 */
static int filter_parse_log_level(const char *value_start)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(log_level_dict); ++i) {
		if (!strcmp(log_level_dict[i].name, value_start))
			return log_level_dict[i].log_level;
	}
	return -1;
}

static char *filter_parse_component_name(char *input_str, struct filter_element *out)
{
	static char scan_format_string[COMPONENT_NAME_SCAN_STRING_LENGTH] = "";
	char comp_name[UUID_NAME_MAX_LEN];
	struct sof_uuid_entry *uuid_entry;
	int ret;

	/* if component name is not specified, stay with default out->uuid_id value */
	if (input_str[0] == '*')
		return &input_str[1];

	/*
	 * Take care about buffer overflows when dealing with input from
	 * user, so scan no more than UUID_NAME_MAX_LEN bytes to
	 * `comp_name` variable. Only once initialise scan_format_string.
	 */
	if (strlen(scan_format_string) == 0) {
		ret = snprintf(scan_format_string, sizeof(scan_format_string),
				"%%%d[^0-9* ]s", UUID_NAME_MAX_LEN);
		if (ret <= 0)
			return NULL;
	}
	ret = sscanf(input_str, scan_format_string, comp_name);
	if (ret <= 0)
		return NULL;

	/* find component uuid key */
	uuid_entry = get_uuid_by_name(comp_name);
	if (!uuid_entry) {
		log_err("unknown component name `%s`\n", comp_name);
		return NULL;
	}
	out->uuid_id = get_uuid_key(uuid_entry);
	return strstr(input_str, comp_name) + strlen(comp_name);
}

/**
 * Parse component definition from input_str.
 *
 * Possible input_str formats:
 *   `name pipe_id.comp_id`
 *   `name pipe_id.*`
 *   `name *`
 *   `name`
 *   `* pipe_id.comp_id`
 *   `* pipe_id.*`
 *   `*`
 * Whitespace is possible at the begin, end and after `name`.
 * `name` must refer to values from given UUID dictionary,
 *        (so name comes from DECLARE_SOF_UUID macro usage)

 * @param input_str formatted component definition
 * @param out element where component definition should be saved
 */
static int filter_parse_component(char *input_str, struct filter_element *out)
{
	char *instance_info;
	int ret;

	/* trim whitespaces, to easily check first and last char */
	input_str = trim(input_str);

	/* assign default values */
	out->uuid_id = 0;
	out->pipe_id = -1;
	out->comp_id = -1;

	/* parse component name and store pointer after component name, pointer to instance info */
	instance_info = filter_parse_component_name(input_str, out);
	if (!instance_info) {
		log_err("component name parsing `%s`\n", input_str);
		return -EINVAL;
	}

	/* if instance is not specified then stop parsing */
	instance_info = ltrim(instance_info);
	if (instance_info[0] == '\0' ||
	    (instance_info[0] == '*' && instance_info[1] == '\0')) {
		return 0;
	}

	/* now parse last part: `number.x` where x is a number or `*` */
	ret = sscanf(instance_info, "%d.%d", &out->pipe_id, &out->comp_id);
	if (ret == 2)
		return 0;
	else if (ret != 1)
		return -EINVAL;

	/* pipeline id parsed but component id is not a number */
	if (instance_info[strlen(instance_info) - 1] == '*')
		return 0;
	log_err("Use * to specify each component on particular pipeline\n");
	return -EINVAL;
}

/**
 * Convert argument from -F flag to sof_ipc_dma_trace_filter_elem struct values.
 *
 * Possible log_level - see filter_parse_log_level() documentation
 * Possible component - list of components separated by `COMPONENTS_SEPARATOR`,
 *                      for single component definition description look at
 *                      filter_parse_component() documentation
 *
 * Examples:
 *   `debug="pipe1"` - set debug log level for components from pipeline1
 *   `d="pipe1, dai2.3"` - as above, but also for dai2.3
 *   `error="FIR*"` - for each FIR component set log level to error
 *
 * @param input_str log level settings in format `log_level=component`
 * @param out_list output list with filter_element elements
 */
static int filter_parse_entry(char *input_str, struct list_item *out_list)
{
	struct filter_element *filter;
	char *comp_fmt_end;
	int32_t log_level;
	char *comp_fmt;
	int ret;

	/*
	 * split string on '=' char, left part describes log level,
	 * the right one is for component description.
	 */
	comp_fmt = strchr(input_str, '=');
	if (!comp_fmt) {
		log_err("unable to find `=` in `%s`\n", input_str);
		return -EINVAL;
	}
	*comp_fmt = 0;
	++comp_fmt;

	/* find correct log level in given conf string - string before `=` */
	log_level = filter_parse_log_level(input_str);
	if (log_level < 0) {
		log_err("unable to parse log level from `%s`\n", input_str);
		return log_level;
	}

	/*
	 * now parse list of components name and optional instance identifier,
	 * split string on `COMPONENTS_SEPARATOR`
	 */
	while (comp_fmt) {
		filter = malloc(sizeof(struct filter_element));
		if (!filter) {
			log_err("unable to malloc memory\n");
			return -ENOMEM;
		}

		comp_fmt_end = strchr(comp_fmt, COMPONENTS_SEPARATOR);
		if (comp_fmt_end)
			*comp_fmt_end = '\0';
		ret = filter_parse_component(comp_fmt, filter);
		if (ret < 0) {
			log_err("unable to parse component from `%s`\n", comp_fmt);
			free(filter);
			return ret;
		}
		filter->log_level = log_level;

		list_item_append(&filter->list, out_list);
		comp_fmt = comp_fmt_end ? comp_fmt_end + 1 : 0;
	}

	return 0;
}

/**
 * Parse `input_str` content and send it to FW via debugFS.
 *
 * `input_str` contain single filter definition element per line.
 * Each line is parsed by `filter_parse_entry`, and saved in list.
 * List of `sof_ipc_dma_trace_filter_elem` is writend to debugFS,
 * and then send as IPC to FW (this action is implemented in driver).
 * Each line in debugFS represents single IPC message.
 */
int filter_update_firmware(void)
{
	char *input_str = global_config->filter_config;
	struct filter_element *filter;
	struct list_item filter_list;
	struct list_item *list_elem;
	struct list_item *list_temp;
	char *line_end;
	FILE *out_fd = NULL;
	int ret = 0;

	list_init(&filter_list);

	/* parse `input_str` line by line */
	line_end = strchr(input_str, '\n');
	while (line_end) {
		line_end[0] = '\0';
		ret = filter_parse_entry(input_str, &filter_list);
		if (ret < 0)
			goto err;
		input_str = line_end + 1;
		line_end = strchr(input_str, '\n');
	}

	/* write output to debugFS */
	out_fd = fopen(FILTER_KERNEL_PATH, "w");
	if (!out_fd) {
		log_err("Unable to open out file '%s'\n", FILTER_KERNEL_PATH);
		ret = -errno;
		goto err;
	}

	list_for_item(list_elem, &filter_list) {
		filter = container_of(list_elem, struct filter_element, list);
		fprintf(out_fd, "%d %X %d %d;", filter->log_level,
			filter->uuid_id, filter->pipe_id, filter->comp_id);
	}
	fprintf(out_fd, "\n");

err:
	if (out_fd)
		fclose(out_fd);

	/* free each component from parsed element list */
	list_for_item_safe(list_elem, list_temp, &filter_list) {
		filter = container_of(list_elem, struct filter_element, list);
		free(filter);
	}

	return ret;
}