Introduce a CoreSight configuration table format to allow dynamic configuration load at runtime. This allows provision of portable configurations that are not dependent on compilation into a kernel module.

Define a compact binary table format for configurations and features and provide a reader for that format that will expand and populate the internal configuration and feature structures use by the driver infrastructure.

Adds API to read tables and convert to internal structures to load into coresight infrastructure.

Signed-off-by: Mike Leach mike.leach@linaro.org --- drivers/hwtracing/coresight/Makefile | 3 +- .../coresight/coresight-config-table.c | 427 ++++++++++++++++++ .../coresight/coresight-config-table.h | 146 ++++++ .../hwtracing/coresight/coresight-config.h | 21 + 4 files changed, 596 insertions(+), 1 deletion(-) create mode 100644 drivers/hwtracing/coresight/coresight-config-table.c create mode 100644 drivers/hwtracing/coresight/coresight-config-table.h

diff --git a/drivers/hwtracing/coresight/Makefile b/drivers/hwtracing/coresight/Makefile index 4ba478211b31..a5c5b8bd61cb 100644 --- a/drivers/hwtracing/coresight/Makefile +++ b/drivers/hwtracing/coresight/Makefile @@ -26,7 +26,8 @@ obj-$(CONFIG_CORESIGHT) += coresight.o coresight-y := coresight-core.o coresight-etm-perf.o coresight-platform.o \ coresight-sysfs.o coresight-syscfg.o coresight-config.o \ coresight-cfg-preload.o coresight-cfg-afdo.o \ - coresight-syscfg-configfs.o coresight-trace-id.o + coresight-syscfg-configfs.o coresight-trace-id.o \ + coresight-config-table.o obj-$(CONFIG_CORESIGHT_LINK_AND_SINK_TMC) += coresight-tmc.o coresight-tmc-y := coresight-tmc-core.o coresight-tmc-etf.o \ coresight-tmc-etr.o diff --git a/drivers/hwtracing/coresight/coresight-config-table.c b/drivers/hwtracing/coresight/coresight-config-table.c new file mode 100644 index 000000000000..0a8f017d76d2 --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-config-table.c @@ -0,0 +1,427 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2020 Linaro Limited, All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +#include "coresight-config-table.h" + +#define cscfg_extract_u64(val64) { \ + val64 = *(u64 *)(buffer + used); \ + used += sizeof(u64); \ + } + +#define cscfg_extract_u32(val32) { \ + val32 = *(u32 *)(buffer + used); \ + used += sizeof(u32); \ + } + +#define cscfg_extract_u16(val16) { \ + val16 = *(u16 *)(buffer + used); \ + used += sizeof(u16); \ + } + +#define cscfg_extract_u8(val8) { \ + val8 = *(buffer + used); \ + used++; \ + } + +static int cscfg_table_read_hdr(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_table_header *hdr) +{ + /* table header always at the start of the buffer */ + int used = 0; + + if (buflen < sizeof(struct cscfg_table_header)) + return -EINVAL; + + cscfg_extract_u32(hdr->magic_version); + if (hdr->magic_version != CSCFG_TABLE_MAGIC_VERSION) + return -EINVAL; + + cscfg_extract_u16(hdr->length); + if (hdr->length > buflen) + return -EINVAL; + + cscfg_extract_u16(hdr->nr_configs); + cscfg_extract_u16(hdr->nr_features); + + *buf_used = used; + return 0; +} + +static int cscfg_table_read_elem_hdr(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_table_elem_header *elem_hdr) +{ + int used = *buf_used; + + if ((buflen - used) < (sizeof(u16) + sizeof(u8))) + return -EINVAL; + + /* read length and check enough buffer remains for this element */ + elem_hdr->elem_length = *(u16 *)(buffer + used); + if ((buflen - used) < elem_hdr->elem_length) + return -EINVAL; + /* don't use extract fn as we update used _after_ the comparison */ + used += sizeof(u16); + + /* read type and validate */ + cscfg_extract_u8(elem_hdr->elem_type); + if ((elem_hdr->elem_type < CSCFG_TABLE_ELEM_TYPE_FEAT) || + (elem_hdr->elem_type > CSCFG_TABLE_ELEM_TYPE_CFG)) + return -EINVAL; + + *buf_used = used; + return 0; +} + +static int cscfg_table_read_elem_str(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_table_elem_str *elem_str) +{ + int used = *buf_used; + + if ((buflen - used) < sizeof(u16)) + return -EINVAL; + + cscfg_extract_u16(elem_str->str_len); + + if ((buflen - used) < elem_str->str_len) + return -EINVAL; + + /* check for 0 termination */ + if (buffer[used + (elem_str->str_len - 1)] != 0) + return -EINVAL; + + elem_str->str = kstrdup((char *)(buffer + used), GFP_KERNEL); + used += elem_str->str_len; + + *buf_used = used; + return 0; +} + +static int cscfg_table_alloc_desc_arrays(struct cscfg_table_load_descs *desc_arrays, + int nr_features, int nr_configs) +{ + /* arrays are 0 terminated - nr_configs & nr_features elements */ + desc_arrays->config_descs = kcalloc(nr_configs + 1, sizeof(struct cscfg_config_desc *), + GFP_KERNEL); + if (!desc_arrays->config_descs) + return -ENOMEM; + desc_arrays->feat_descs = kcalloc(nr_features + 1, sizeof(struct cscfg_feature_desc *), + GFP_KERNEL); + if (!desc_arrays->feat_descs) + return -ENOMEM; + return 0; +} + +/* free up the data allocated to a config desc */ +static void cscfg_table_free_config_desc(struct cscfg_config_desc *config_desc) +{ + int i; + + if (!config_desc) + return; + + /* free presets */ + kfree(config_desc->presets); + + /* free feat ref strings */ + if (config_desc->nr_feat_refs) { + /* each string */ + for (i = 0; i < config_desc->nr_feat_refs; i++) + kfree(config_desc->feat_ref_names[i]); + + /* and the char * array */ + kfree(config_desc->feat_ref_names); + } + + /* next the strings */ + kfree(config_desc->name); + kfree(config_desc->description); + + /* finally the struct itself */ + kfree(config_desc); +} + +static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_table_load_descs *desc_arrays, + const int cfg_index) +{ + struct cscfg_table_elem_header elem_hdr; + struct cscfg_table_elem_str elem_str; + struct cscfg_config_desc *config_desc; + int used = *buf_used, nr_preset_vals, nr_preset_bytes, i; + int err = 0; + u64 *presets; + + /* + * read the header - if not config, then don't update buf_used + * pointer on return + */ + err = cscfg_table_read_elem_hdr(buffer, buflen, &used, &elem_hdr); + if (err) + return err; + if (elem_hdr.elem_type != CSCFG_TABLE_ELEM_TYPE_CFG) + return 0; + + /* we have a config - allocate the descriptor */ + config_desc = kzalloc(sizeof(struct cscfg_config_desc), GFP_KERNEL); + if (!config_desc) + return -ENOMEM; + + /* read the name string */ + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + config_desc->name = elem_str.str; + + /* allocate load name if not set */ + if (!desc_arrays->load_name) + desc_arrays->load_name = kstrdup(config_desc->name, GFP_KERNEL); + + /* read the description string */ + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + config_desc->description = elem_str.str; + + /* read in some values */ + if ((buflen - used) < sizeof(u64)) + return -EINVAL; + cscfg_extract_u16(config_desc->nr_presets); + cscfg_extract_u32(config_desc->nr_total_params); + cscfg_extract_u16(config_desc->nr_feat_refs); + + /* read the array of 64bit presets if present */ + nr_preset_vals = config_desc->nr_total_params * config_desc->nr_presets; + if (nr_preset_vals) { + presets = kcalloc(nr_preset_vals, sizeof(u64), GFP_KERNEL); + if (!presets) + return -ENOMEM; + + nr_preset_bytes = sizeof(u64) * nr_preset_vals; + if ((buflen - used) < nr_preset_bytes) + return -EINVAL; + + memcpy(presets, (buffer + used), nr_preset_bytes); + config_desc->presets = presets; + used += nr_preset_bytes; + } + + /* read the array of feature names referenced by the config */ + if (config_desc->nr_feat_refs) { + config_desc->feat_ref_names = kcalloc(config_desc->nr_feat_refs, + sizeof(char *), GFP_KERNEL); + if (!config_desc->feat_ref_names) + return -ENOMEM; + + for (i = 0; i < config_desc->nr_feat_refs; i++) { + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + config_desc->feat_ref_names[i] = elem_str.str; + } + } + + desc_arrays->config_descs[cfg_index] = config_desc; + *buf_used = used; + return 0; +} + +static int cscfg_table_read_elem_param(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_parameter_desc *param_desc) +{ + struct cscfg_table_elem_str elem_str; + int err = 0, used = *buf_used; + + /* parameter name */ + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + param_desc->name = elem_str.str; + + /* parameter value */ + if ((buflen - used) < sizeof(u64)) + return -EINVAL; + cscfg_extract_u64(param_desc->value); + + *buf_used = used; + return err; +} + +static void cscfg_table_free_feat_desc(struct cscfg_feature_desc *feat_desc) +{ + if (!feat_desc) + return; + + /* free up the register descriptor array */ + kfree(feat_desc->regs_desc); + + /* free up the parameters array */ + kfree(feat_desc->params_desc); + + /* name and description strings */ + kfree(feat_desc->name); + kfree(feat_desc->description); + + /* finally the struct itself */ + kfree(feat_desc); +} + +static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int *buf_used, + struct cscfg_table_load_descs *desc_arrays, + const int feat_idx) +{ + struct cscfg_table_elem_header elem_hdr; + struct cscfg_table_elem_str elem_str; + struct cscfg_feature_desc *feat_desc; + struct cscfg_regval_desc *p_reg_desc; + int used = *buf_used, err, i, nr_regs_bytes; + u32 val32; + + /* allocate the feature descriptor object */ + feat_desc = kzalloc(sizeof(struct cscfg_feature_desc), GFP_KERNEL); + if (!feat_desc) + return -ENOMEM; + + /* read and check the element header */ + err = cscfg_table_read_elem_hdr(buffer, buflen, &used, &elem_hdr); + if (err) + return err; + + if (elem_hdr.elem_type != CSCFG_TABLE_ELEM_TYPE_FEAT) + return -EINVAL; + + /* read the feature name */ + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + feat_desc->name = elem_str.str; + + /* allocate load name if not set previously by config */ + if (!desc_arrays->load_name) + desc_arrays->load_name = kstrdup(feat_desc->name, GFP_KERNEL); + + /* read the description string */ + err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); + if (err) + return err; + feat_desc->description = elem_str.str; + + /* + * read in some values + * [u32 value: match_flags] + * [u16 value: nr_regs] - number of registers. + * [u16 value: nr_params] - number of parameters. + */ + cscfg_extract_u32(feat_desc->match_flags); + cscfg_extract_u16(feat_desc->nr_regs); + cscfg_extract_u16(feat_desc->nr_params); + + /* register descriptors - 32 bit + 64 bit value */ + if (feat_desc->nr_regs) { + nr_regs_bytes = ((sizeof(u32) + sizeof(u64)) * feat_desc->nr_regs); + if ((buflen - used) < nr_regs_bytes) + return -EINVAL; + feat_desc->regs_desc = kcalloc(feat_desc->nr_regs, + sizeof(struct cscfg_regval_desc), GFP_KERNEL); + if (!feat_desc->regs_desc) + return -ENOMEM; + + for (i = 0; i < feat_desc->nr_regs; i++) { + cscfg_extract_u32(val32); + p_reg_desc = (struct cscfg_regval_desc *)&feat_desc->regs_desc[i]; + CSCFG_TABLE_U32_TO_REG_DESC_INFO(val32, p_reg_desc); + cscfg_extract_u64(feat_desc->regs_desc[i].val64); + } + } + + /* parameter descriptors - string + 64 bit value */ + if (feat_desc->nr_params) { + feat_desc->params_desc = kcalloc(feat_desc->nr_params, + sizeof(struct cscfg_parameter_desc), GFP_KERNEL); + if (!feat_desc->params_desc) + return -ENOMEM; + for (i = 0; i < feat_desc->nr_params; i++) { + err = cscfg_table_read_elem_param(buffer, buflen, &used, + &feat_desc->params_desc[i]); + if (err) + return err; + } + } + + desc_arrays->feat_descs[feat_idx] = feat_desc; + *buf_used = used; + return 0; +} + +/* + * Read the table from a buffer and create the internal configuration and + * feature descriptors to load into the cscfg system + */ +int cscfg_table_read_buffer(const u8 *buffer, const int buflen, + struct cscfg_table_load_descs *desc_arrays) +{ + struct cscfg_table_header hdr; + int used = 0, err, i; + + /* read in the table header */ + err = cscfg_table_read_hdr(buffer, buflen, &used, &hdr); + if (err) + return err; + + /* allocate the memory for the descriptor pointer arrays */ + err = cscfg_table_alloc_desc_arrays(desc_arrays, hdr.nr_features, hdr.nr_configs); + if (err) + return err; + + /* read elements */ + + /* first elements are configurations */ + for (i = 0; i < hdr.nr_configs; i++) { + err = cscfg_table_read_elem_config(buffer, buflen, &used, desc_arrays, i); + if (err) + return err; + } + + /* now read and populate all the feature descriptors */ + for (i = 0; i < hdr.nr_features; i++) { + err = cscfg_table_read_elem_feature(buffer, buflen, &used, desc_arrays, i); + if (err) + return err; + } + return 0; +} + +/* + * Need to free up the dynamically allocated descriptor arrays on unload + * as the memory used could be significant if many configurations are loaded + * and unloaded while the machine is operational. + * + * This frees up all the memory allocated by config during the load process. + */ +void cscfg_table_free_load_descs(struct cscfg_table_load_descs *desc_arrays) +{ + int i = 0; + + if (!desc_arrays) + return; + + /* free up each of the config descriptors */ + while (desc_arrays->config_descs[i]) { + cscfg_table_free_config_desc(desc_arrays->config_descs[i]); + i++; + } + + /* free up each of the feature descriptors */ + i = 0; + while (desc_arrays->feat_descs[i]) { + cscfg_table_free_feat_desc(desc_arrays->feat_descs[i]); + i++; + } + + /* finally free up the load descs pointer arrays */ + kfree(desc_arrays->config_descs); + kfree(desc_arrays->feat_descs); + kfree(desc_arrays->load_name); +} diff --git a/drivers/hwtracing/coresight/coresight-config-table.h b/drivers/hwtracing/coresight/coresight-config-table.h new file mode 100644 index 000000000000..2cd8fb0630e2 --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-config-table.h @@ -0,0 +1,146 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2020-2022 Linaro Limited, All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +#ifndef _CORESIGHT_CORESIGHT_CONFIG_TABLE_H +#define _CORESIGHT_CORESIGHT_CONFIG_TABLE_H + +#include <linux/sizes.h> + +#include "coresight-config.h" + +/* + * Configurations and features can be dynamically loaded at runtime + * using a table format that is converted on read into the internal + * structures used by the cscfg infrastructure. + * + * Table structure - for loading configuration(s) + feature(s) + * from configfs or other external sources. + * + * [cscfg_table_header] - mandatory + * [CONFIG_ELEM] * [cscfg_table_header.nr_configs] - optional. + * [FEATURE_ELEM] * [cscfg_table_header.nr_features] - optional. + * + * Table valid if it has both config(s) and feature(s), only config(s) + * or only feature(s). + * + * Invalid table if no config or features. + * + * Structure for [CONFIG_ELEM]: + * + * [cscfg_table_elem_header] - header length value to end of feature strings. + * [cscfg_table_elem_str] - name of the configuration + * [cscfg_table_elem_str] - description of configuration + * [u16 value - nr_presets] - number of sets of presets supplied + * [u32 value - nr_total_params] - total of all params in referenced features + * [u16 value - nr_feat_refs] - number of features selected by this configuration + * [u64 values] * (nr_presets * nr_total_params) + * [cscfg_table_elem_str] * nr_feat_refs - names of features selected by configuration. + * + * A configuration must reference at least one feature. + * Referenced features may be in this table, or have been loaded previously. + * + * Structure for a [FEATURE_ELEM] + * + * [cscfg_table_elem_header] - header length is total bytes to end of param structures. + * [cscfg_table_elem_str] - feature name. + * [cscfg_table_elem_str] - feature description. + * [u32 value: match_flags] + * [u16 value: nr_regs] - number of registers. + * [u16 value: nr_params] - number of parameters. + * [cscfg_regval_desc struct] * nr_regs + * [PARAM_ELEM] * nr_params + * + * Structure for [PARAM_ELEM] + * + * [cscfg_table_elem_str] - parameter name. + * [u64 value: param_value] - initial value. + */ + +/* major element types - configurations and features */ + +#define CSCFG_TABLE_ELEM_TYPE_FEAT 0x1 +#define CSCFG_TABLE_ELEM_TYPE_CFG 0x2 + +#define CSCFG_TABLE_MAGIC_VERSION 0xC5CF0001 + +#define CSCFG_TABLE_U32_TO_REG_DESC_INFO(val32, p_desc) \ + { \ + p_desc->type = (val32 >> 24) & 0xFF; \ + p_desc->offset = (val32 >> 12) & 0xFFF; \ + p_desc->hw_info = val32 & 0xFFF; \ + } + +#define CSCFG_TABLE_REG_DESC_INFO_TO_U32(val32, p_desc) \ + { \ + val32 = p_desc->hw_info & 0xFFF; \ + val32 |= ((p_desc->offset & 0xFFF) << 12); \ + val32 |= ((p_desc->type & 0xFF) << 24); \ + } + +/* + * Define a maximum size for any configuration table. + * + * Use a value that will reasonably cover all the usable & programmable + * registers in an ETM, the most complex device we have. + * + * This may also be used for the binary attributes in configfs which need a max + * size, as an internal buffer is declared, and will not be exceeded to prevent + * kernel OOM errors / attacks. + * + */ +#define CSCFG_TABLE_MAXSIZE SZ_16K + +/* limit string sizes - used for descriptions and names. */ +#define CSCFG_TABLE_STR_MAXSIZE SZ_1K + +/** + * Table header. + * + * @magic_version: magic number / version for table format. + * @length : total length of all data in the table. + * @nr_configs : total number of configs in the table. + * @nr_features : total number of features in the table. + */ +struct cscfg_table_header { + u32 magic_version; + u16 length; + u16 nr_configs; + u16 nr_features; +}; + +/** + * element header + * + * @elem_length: total length of this element + * @elem_type : type of this element - one of CSCFG_TABLE_ELEM_TYPE.. defines. + */ +struct cscfg_table_elem_header { + u16 elem_length; + u8 elem_type; +}; + +/** + * string table element. + * + * @str_len: length of string buffer including 0 terminator + * @str : string buffer - 0 terminated. + */ +struct cscfg_table_elem_str { + u16 str_len; + char *str; +}; + +/* + * Read a configuration programming table from the buffer and create the + * structures needed to load into the cscfg system + */ +int cscfg_table_read_buffer(const u8 *buffer, const int buflen, + struct cscfg_table_load_descs *desc_arrays); + +/* on unload we need to free up memory allocated on read */ +void cscfg_table_free_load_descs(struct cscfg_table_load_descs *desc_arrays); + +#endif /* _CORESIGHT_CORESIGHT_CONFIG_TABLE_H */ diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index 6ba013975741..ea3aaf0d129b 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -85,6 +85,27 @@ struct cscfg_regval_desc { }; };

+/** + * Dynamically loaded descriptor arrays. + * + * For builtin or module loaded configurations / features these are + * statically defined at compile time. + + * For a dynamic load at runtime, using a config table, (e.g. load from + * configfs) we create the arrays dynamically so need a structure to + * manage these. + * + * @config_descs: array of config descriptor pointers. + * @feat_descs: array of feature descriptor pointers. + * @load_name: user readable name which may be used to unload later. + * Will be name of first config if present, or first feature. + */ +struct cscfg_table_load_descs { + struct cscfg_config_desc **config_descs; + struct cscfg_feature_desc **feat_descs; + char *load_name; +}; + /** * Device feature descriptor - combination of registers and parameters to * program a device to implement a specific complex function.

Add API functions and helpers to runtime / dynamically load and unload configuration tables.

Provides locking to ensure simutaneous load / unload from different sources cannot occur.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../coresight/coresight-syscfg-configfs.c | 365 ++++++++++++++++++ .../hwtracing/coresight/coresight-syscfg.c | 103 ++++- .../hwtracing/coresight/coresight-syscfg.h | 19 +- 3 files changed, 480 insertions(+), 7 deletions(-)

diff --git a/drivers/hwtracing/coresight/coresight-syscfg-configfs.c b/drivers/hwtracing/coresight/coresight-syscfg-configfs.c index 6e8c8db52d39..d0aaecb0f4c7 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg-configfs.c +++ b/drivers/hwtracing/coresight/coresight-syscfg-configfs.c @@ -5,10 +5,369 @@ */

#include <linux/configfs.h> +#include <linux/module.h> +#include <linux/workqueue.h>

#include "coresight-config.h" +#include "coresight-config-table.h" #include "coresight-syscfg-configfs.h"

+/* prevent race in load / unload operations */ +static DEFINE_MUTEX(cfs_mutex); + +/* + * need to enable / disable dynamic table load when + * initialising / shutting down the subsystem, or + * loading / unloading configurations via module. + */ +static bool cscfg_dyn_load_enabled; + +/* + * Lockdep issues occur if deleting the config directory as part + * of the unload operation triggered by configfs. + * Therefore we schedule the main part of the unload to be completed as a work item + * & save the owner info for the scheduled unload + */ +static struct cscfg_load_owner_info *cscfg_sched_dyn_unload_owner; + + +/* determine if load / unload ops are currently permitted. */ +inline bool cscfg_load_ops_permitted(void) +{ + return (cscfg_dyn_load_enabled && !cscfg_sched_dyn_unload_owner); +} + +/* do the main unload operations. Called with cfs_mutex held */ +static int cscfg_do_unload(struct cscfg_load_owner_info *unload_owner) +{ + int err = 0; + + if (!cscfg_dyn_load_enabled) { + pr_warn("cscfg: skipping unload completion\n"); + return -EINVAL; + } + + err = cscfg_unload_config_sets(unload_owner); + if (!err) + cscfg_free_dyn_load_owner_info(unload_owner); + else + pr_err("cscfg: dynamic configuration unload error\n"); + + return err; +} + +/* complete the unload operation as work item */ +static void cscfg_complete_unload(struct work_struct *work) +{ + mutex_lock(&cfs_mutex); + + if (cscfg_sched_dyn_unload_owner) + cscfg_do_unload(cscfg_sched_dyn_unload_owner); + cscfg_sched_dyn_unload_owner = NULL; + + mutex_unlock(&cfs_mutex); + kfree(work); +} + +static int cscfg_schedule_unload(void) +{ + struct work_struct *work; + + work = kzalloc(sizeof(struct work_struct), GFP_KERNEL); + if (!work) + return -ENOMEM; + + INIT_WORK(work, cscfg_complete_unload); + schedule_work(work); + return 0; +} + +/* create a string representing a loaded config based on owner info */ +static ssize_t cscfg_get_owner_info_str(struct cscfg_load_owner_info *owner_info, + char *buffer, ssize_t size) +{ + struct cscfg_table_load_descs *load_descs; + ssize_t size_used = 0; + int i; + static const char * const load_type[] = { + "Built in driver", + "Loadable module", + "Runtime Dynamic table load", + }; + + /* limited info for none dynamic loaded stuff */ + if (owner_info->type != CSCFG_OWNER_DYNLOAD) { + size_used = scnprintf(buffer, size, + "load name: [Not Set]\nload type: %s\n", + load_type[owner_info->type]); + goto buffer_done; + } + + /* dynamic loaded type will have all the info */ + load_descs = (struct cscfg_table_load_descs *)owner_info->owner_handle; + + /* first is the load name and type - need for unload request */ + size_used = scnprintf(buffer, size, "load name: %s\nload type: %s\n", + load_descs->load_name, + load_type[owner_info->type]); + + /* list of configurations loaded by this owner element */ + size_used += scnprintf(buffer + size_used, size - size_used, + "(configurations: "); + if (!(size_used < size)) + goto buffer_done; + + if (!load_descs->config_descs[0]) { + size_used += scnprintf(buffer + size_used, size - size_used, + " None )\n"); + if (!(size_used < size)) + goto buffer_done; + } else { + i = 0; + while (load_descs->config_descs[i] && (size_used < size)) { + size_used += scnprintf(buffer + size_used, + size - size_used, " %s", + load_descs->config_descs[i]->name); + i++; + } + size_used += + scnprintf(buffer + size_used, size - size_used, " )\n"); + } + if (!(size_used < size)) + goto buffer_done; + + /* list of features loaded by this owner element */ + size_used += scnprintf(buffer + size_used, size - size_used, "(features: "); + if (!(size_used < size)) + goto buffer_done; + + if (!load_descs->feat_descs[0]) { + size_used += + scnprintf(buffer + size_used, size - size_used, " None )\n"); + if (!(size_used < size)) + goto buffer_done; + } else { + i = 0; + while (load_descs->feat_descs[i] && (size_used < size)) { + size_used += scnprintf(buffer + size_used, + size - size_used, " %s", + load_descs->feat_descs[i]->name); + i++; + } + size_used += + scnprintf(buffer + size_used, size - size_used, " )\n"); + } + + /* done or buffer full */ +buffer_done: + return size_used; +} + +void cscfg_enable_dyn_load(void) +{ + mutex_lock(&cfs_mutex); + cscfg_dyn_load_enabled = true; + mutex_unlock(&cfs_mutex); +} + +/* disable dynamic load / unload if no current unload scheduled */ +bool cscfg_disable_dyn_load(void) +{ + mutex_lock(&cfs_mutex); + if (!cscfg_sched_dyn_unload_owner) + cscfg_dyn_load_enabled = false; + mutex_unlock(&cfs_mutex); + return !cscfg_dyn_load_enabled; +} + +void cscfg_at_exit_dyn_load(void) +{ + mutex_lock(&cfs_mutex); + cscfg_dyn_load_enabled = false; + cscfg_sched_dyn_unload_owner = NULL; + mutex_unlock(&cfs_mutex); +} + + +struct cscfg_load_owner_info *cscfg_create_dyn_load_owner_info(void) +{ + struct cscfg_table_load_descs *load_descs = 0; + struct cscfg_load_owner_info *owner_info = 0; + + load_descs = kzalloc(sizeof(struct cscfg_table_load_descs), GFP_KERNEL); + if (!load_descs) + return owner_info; + + owner_info = kzalloc(sizeof(struct cscfg_load_owner_info), GFP_KERNEL); + if (owner_info) { + owner_info->owner_handle = load_descs; + owner_info->type = CSCFG_OWNER_DYNLOAD; + } else + kfree(load_descs); + + return owner_info; +} + +/* free memory associated with a dynamically loaded configuration & descriptors */ +void cscfg_free_dyn_load_owner_info(struct cscfg_load_owner_info *owner_info) +{ + struct cscfg_table_load_descs *load_descs = 0; + + if (!owner_info) + return; + + if (owner_info->type != CSCFG_OWNER_DYNLOAD) + return; + + load_descs = (struct cscfg_table_load_descs *)(owner_info->owner_handle); + + if (load_descs) { + /* free the data allocated on table load, pointed to by load_descs */ + cscfg_table_free_load_descs(load_descs); + kfree(load_descs); + } + + kfree(owner_info); +} + +/* return load name if dynamic load owned element */ +const char *cscfg_get_dyn_load_name(struct cscfg_load_owner_info *owner_info) +{ + const char *name = "unknown"; + struct cscfg_table_load_descs *load_descs; + + if (!owner_info) + return name; + + load_descs = (struct cscfg_table_load_descs *)(owner_info->owner_handle); + if (owner_info->type == CSCFG_OWNER_DYNLOAD) + return load_descs->load_name; + + return name; +} + +/* + * Dynamic load and unload configuration table API + */ + +/* dynamically load a configuration and features from a config table + */ +int cscfg_dyn_load_cfg_table(const void *table, size_t table_size) +{ + struct cscfg_table_load_descs *load_descs = 0; + struct cscfg_load_owner_info *owner_info = 0; + int err = -EINVAL; + + /* ensure we cannot simultaneously load and unload */ + if (!mutex_trylock(&cfs_mutex)) { + err = -EBUSY; + goto exit_unlock; + } + + /* check configfs load / unload ops are permitted */ + if (!cscfg_load_ops_permitted()) { + err = -EBUSY; + goto exit_unlock; + } + + if (table_size > CSCFG_TABLE_MAXSIZE) { + pr_err("cscfg: Load error - Input file too large.\n"); + goto exit_unlock; + } + + /* create owner info as dyn load type with descriptor tables to be filled */ + owner_info = cscfg_create_dyn_load_owner_info(); + if (owner_info) + load_descs = (struct cscfg_table_load_descs *)(owner_info->owner_handle); + else { + err = -ENOMEM; + goto exit_unlock; + } + + /* convert table into internal data structures */ + err = cscfg_table_read_buffer(table, table_size, load_descs); + if (err) { + pr_err("cscfg: Load error - Failed to read input buffer.\n"); + goto exit_memfree; + } + + err = cscfg_load_config_sets(load_descs->config_descs, load_descs->feat_descs, owner_info); + if (err) { + pr_err("cscfg: Load error - Failed to load configuaration table.\n"); + goto exit_memfree; + } + + /* load success */ + goto exit_unlock; + +exit_memfree: + /* frees up owner_info and load_descs */ + cscfg_free_dyn_load_owner_info(owner_info); + +exit_unlock: + mutex_unlock(&cfs_mutex); + return err; +} +EXPORT_SYMBOL_GPL(cscfg_dyn_load_cfg_table); + +/* + * schedule the unload of the last dynamically loaded table. + * load / unload ordering is strictly enforced. + */ +int cscfg_sched_dyn_unload_cfg_table(void) +{ + struct cscfg_load_owner_info *owner_info = 0; + int err = -EINVAL; + + /* ensure we cannot simultaneously load and unload */ + if (!mutex_trylock(&cfs_mutex)) { + err = -EBUSY; + goto exit_unlock; + } + + /* check dyn load / unload ops are permitted & no ongoing unload */ + if (!cscfg_load_ops_permitted()) { + err = -EBUSY; + goto exit_unlock; + } + + /* find the last loaded owner info block */ + owner_info = cscfg_find_last_loaded_cfg_owner(); + if (!owner_info) { + pr_err("cscfg: Unload error: Failed to find any loaded configuration\n"); + goto exit_unlock; + } + + if (owner_info->type != CSCFG_OWNER_DYNLOAD) { + pr_err("cscfg: Unload error: Last loaded configuration not dynamic loaded item\n"); + goto exit_unlock; + } + + /* set cscfg state as starting an unload operation */ + err = cscfg_set_unload_start(); + if (err) { + pr_err("Config unload %s: failed to set unload start flag\n", + cscfg_get_dyn_load_name(owner_info)); + goto exit_unlock; + } + + /* + * actual unload is scheduled as a work item to avoid + * lockdep issues when triggered from configfs + */ + cscfg_sched_dyn_unload_owner = owner_info; + err = cscfg_schedule_unload(); + +exit_unlock: + mutex_unlock(&cfs_mutex); + return err; +} +EXPORT_SYMBOL_GPL(cscfg_sched_dyn_unload_cfg_table); + +/* + * configfs object and directory operations + */ + /* create a default ci_type. */ static inline struct config_item_type *cscfg_create_ci_type(void) { @@ -517,6 +876,12 @@ int cscfg_configfs_init(struct cscfg_manager *cscfg_mgr) if (!ci_type) return -ENOMEM;

+ /* dyncamic load and unload initially disabled */ + cscfg_dyn_load_enabled = false; + + /* no current scheduled unload operation in progress */ + cscfg_sched_dyn_unload_owner = NULL; + subsys = &cscfg_mgr->cfgfs_subsys; config_item_set_name(&subsys->su_group.cg_item, CSCFG_FS_SUBSYS_NAME); subsys->su_group.cg_item.ci_type = ci_type; diff --git a/drivers/hwtracing/coresight/coresight-syscfg.c b/drivers/hwtracing/coresight/coresight-syscfg.c index 11138a9762b0..6379e29a3aa0 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.c +++ b/drivers/hwtracing/coresight/coresight-syscfg.c @@ -554,6 +554,23 @@ static int cscfg_fs_register_cfgs_feats(struct cscfg_config_desc **config_descs, return 0; }

+/* + * check owner info and if module owner, disable / enable + * configfs managed dynamic load ops to prevent parallel load attempts. + */ +static bool cscfg_check_disable_dyn_load(struct cscfg_load_owner_info *owner_info) +{ + if (owner_info->type == CSCFG_OWNER_MODULE) + return cscfg_disable_dyn_load(); + return true; +} + +static void cscfg_check_enable_dyn_load(struct cscfg_load_owner_info *owner_info) +{ + if (owner_info->type == CSCFG_OWNER_MODULE) + cscfg_enable_dyn_load(); +} + /** * cscfg_load_config_sets - API function to load feature and config sets. * @@ -578,10 +595,14 @@ int cscfg_load_config_sets(struct cscfg_config_desc **config_descs, { int err = 0;

+ /* if this load is by module owner, need to disable dynamic load/unload */ + if (!cscfg_check_disable_dyn_load(owner_info)) + return -EBUSY; + mutex_lock(&cscfg_mutex); if (cscfg_mgr->load_state != CSCFG_NONE) { - mutex_unlock(&cscfg_mutex); - return -EBUSY; + err = -EBUSY; + goto exit_unlock; } cscfg_mgr->load_state = CSCFG_LOAD;

@@ -616,7 +637,7 @@ int cscfg_load_config_sets(struct cscfg_config_desc **config_descs,

/* mark any new configs as available for activation */ cscfg_set_configs_available(config_descs); - goto exit_unlock; + goto exit_clear_state;

err_clean_cfs: /* cleanup after error registering with configfs */ @@ -631,9 +652,13 @@ int cscfg_load_config_sets(struct cscfg_config_desc **config_descs, err_clean_load: cscfg_unload_owned_cfgs_feats(owner_info);

-exit_unlock: +exit_clear_state: cscfg_mgr->load_state = CSCFG_NONE; + +exit_unlock: mutex_unlock(&cscfg_mutex); + + cscfg_check_enable_dyn_load(owner_info); return err; } EXPORT_SYMBOL_GPL(cscfg_load_config_sets); @@ -659,8 +684,13 @@ int cscfg_unload_config_sets(struct cscfg_load_owner_info *owner_info) int err = 0; struct cscfg_load_owner_info *load_list_item = NULL;

+ /* if this unload is by module owner, need to disable dynamic load/unload */ + if (!cscfg_check_disable_dyn_load(owner_info)) + return -EBUSY; + mutex_lock(&cscfg_mutex); - if (cscfg_mgr->load_state != CSCFG_NONE) { + if ((cscfg_mgr->load_state != CSCFG_NONE) && + (cscfg_mgr->load_state != CSCFG_UNLOAD_START)) { mutex_unlock(&cscfg_mutex); return -EBUSY; } @@ -705,10 +735,43 @@ int cscfg_unload_config_sets(struct cscfg_load_owner_info *owner_info) exit_unlock: cscfg_mgr->load_state = CSCFG_NONE; mutex_unlock(&cscfg_mutex); + + cscfg_check_enable_dyn_load(owner_info); return err; } EXPORT_SYMBOL_GPL(cscfg_unload_config_sets);

+int cscfg_set_unload_start(void) +{ + int ret = 0; + + mutex_lock(&cscfg_mutex); + if (cscfg_mgr->load_state != CSCFG_NONE) + ret = -EBUSY; + else + cscfg_mgr->load_state = CSCFG_UNLOAD_START; + mutex_unlock(&cscfg_mutex); + + return ret; +} + +/* find the last loaded config owner info */ +struct cscfg_load_owner_info *cscfg_find_last_loaded_cfg_owner(void) +{ + struct cscfg_load_owner_info *owner_info = NULL; + + mutex_lock(&cscfg_mutex); + + if (!list_empty(&cscfg_mgr->load_order_list)) + owner_info = list_last_entry(&cscfg_mgr->load_order_list, + struct cscfg_load_owner_info, item); + + + mutex_unlock(&cscfg_mutex); + return owner_info; + +} + /* Handle coresight device registration and add configs and features to devices */

/* iterate through config lists and load matching configs to device */ @@ -881,7 +944,7 @@ static int _cscfg_activate_config(unsigned long cfg_hash) struct cscfg_config_desc *config_desc; int err = -EINVAL;

- if (cscfg_mgr->load_state == CSCFG_UNLOAD) + if (cscfg_mgr->load_state >= CSCFG_UNLOAD) return -EBUSY;

list_for_each_entry(config_desc, &cscfg_mgr->config_desc_list, item) { @@ -1206,6 +1269,7 @@ static int cscfg_create_device(void) static void cscfg_unload_cfgs_on_exit(void) { struct cscfg_load_owner_info *owner_info = NULL; + bool free_dynload_owner = false;

/* * grab the mutex - even though we are exiting, some configfs files @@ -1240,6 +1304,23 @@ static void cscfg_unload_cfgs_on_exit(void) */ pr_err("cscfg: ERROR: prior module failed to unload configuration\n"); goto list_remove; + + case CSCFG_OWNER_DYNLOAD: + /* + * dynamically loaded items may still be present if the user did not + * unload them during the session. These have dynamically allocated + * descriptor tables (unlike the two types above that are statically + * allocated at compile time) + */ + pr_info("cscfg: unloading dynamically loaded configuration %s\n", + cscfg_get_dyn_load_name(owner_info)); + + /* + * as this is not being unloaded by configfs, need to flag the + * requirement to free up the owner info and descriptors. + */ + free_dynload_owner = true; + break; }

/* remove from configfs - outside the scope of the list mutex */ @@ -1253,6 +1334,12 @@ static void cscfg_unload_cfgs_on_exit(void) list_remove: /* remove from load order list */ list_del(&owner_info->item); + + /* dynamic loaded config, free memory now */ + if (free_dynload_owner) { + cscfg_free_dyn_load_owner_info(owner_info); + free_dynload_owner = false; + } } mutex_unlock(&cscfg_mutex); } @@ -1284,6 +1371,9 @@ int __init cscfg_init(void) if (err) goto exit_err;

+ /* can now allow dynamic table load / unload */ + cscfg_enable_dyn_load(); + dev_info(cscfg_device(), "CoreSight Configuration manager initialised"); return 0;

@@ -1294,5 +1384,6 @@ int __init cscfg_init(void)

void cscfg_exit(void) { + cscfg_at_exit_dyn_load(); cscfg_clear_device(); } diff --git a/drivers/hwtracing/coresight/coresight-syscfg.h b/drivers/hwtracing/coresight/coresight-syscfg.h index 66e2db890d82..ba137b092992 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg.h +++ b/drivers/hwtracing/coresight/coresight-syscfg.h @@ -20,7 +20,8 @@ enum cscfg_load_ops { CSCFG_NONE, CSCFG_LOAD, - CSCFG_UNLOAD + CSCFG_UNLOAD, + CSCFG_UNLOAD_START, /* unload started by fs, will be completed later */ };

/** @@ -79,6 +80,7 @@ struct cscfg_registered_csdev { enum cscfg_load_owner_type { CSCFG_OWNER_PRELOAD, CSCFG_OWNER_MODULE, + CSCFG_OWNER_DYNLOAD, /* dynamic loading at runtime */ };

/** @@ -108,6 +110,17 @@ int cscfg_update_feat_param_val(struct cscfg_feature_desc *feat_desc, int cscfg_config_sysfs_activate(struct cscfg_config_desc *cfg_desc, bool activate); void cscfg_config_sysfs_set_preset(int preset);

+struct cscfg_load_owner_info *cscfg_find_last_loaded_cfg_owner(void); +int cscfg_set_unload_start(void); + +void cscfg_enable_dyn_load(void); +bool cscfg_disable_dyn_load(void); +void cscfg_at_exit_dyn_load(void); + +struct cscfg_load_owner_info *cscfg_create_dyn_load_owner_info(void); +void cscfg_free_dyn_load_owner_info(struct cscfg_load_owner_info *owner_info); +const char *cscfg_get_dyn_load_name(struct cscfg_load_owner_info *owner_info); + /* syscfg manager external API */ int cscfg_load_config_sets(struct cscfg_config_desc **cfg_descs, struct cscfg_feature_desc **feat_descs, @@ -124,4 +137,8 @@ int cscfg_csdev_enable_active_config(struct coresight_device *csdev, void cscfg_csdev_disable_active_config(struct coresight_device *csdev); void cscfg_config_sysfs_get_active_cfg(unsigned long *cfg_hash, int *preset);

+/* Dynamic load and unload configuration table API */ +int cscfg_dyn_load_cfg_table(const void *table, size_t table_size); +int cscfg_sched_dyn_unload_cfg_table(void); + #endif /* CORESIGHT_SYSCFG_H */

Add attributes to view last loaded configuration, and to unload last loaded configuration, if it was loaded as a dynamic config table.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../coresight/coresight-syscfg-configfs.c | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+)

diff --git a/drivers/hwtracing/coresight/coresight-syscfg-configfs.c b/drivers/hwtracing/coresight/coresight-syscfg-configfs.c index 83da4820be6d..d7883fe802b5 100644 --- a/drivers/hwtracing/coresight/coresight-syscfg-configfs.c +++ b/drivers/hwtracing/coresight/coresight-syscfg-configfs.c @@ -790,9 +790,71 @@ static void cscfg_destroy_feature_group(struct config_group *feat_group) kfree(feat_view); }

+/* Attributes in configfs that allow load and unload of configuration tables */ + +static ssize_t +cscfg_cfg_unload_last_table_store(struct config_item *item, const char *page, size_t count) +{ + int err; + unsigned long val; + + err = kstrtoul(page, 0, &val); + if (err) + return err; + + if (val > 0) { + /* schedule unload of last dynamic loaded configuration */ + err = cscfg_sched_dyn_unload_cfg_table(); + if (!err) + err = count; + } else + err = -EINVAL; + + return err; +} +CONFIGFS_ATTR_WO(cscfg_cfg_, unload_last_table); + +static ssize_t cscfg_cfg_show_last_load_show(struct config_item *item, char *page) +{ + struct cscfg_load_owner_info *owner_info = 0; + ssize_t size = 0; + + /* ensure we cannot read last load while loading / unloading */ + if (!mutex_trylock(&cfs_mutex)) + return -EBUSY; + + /* check dyn load / unload ops are permitted & no ongoing unload */ + if (!cscfg_load_ops_permitted()) { + size = -EBUSY; + goto exit_unlock; + } + + /* find the last loaded owner info block */ + owner_info = cscfg_find_last_loaded_cfg_owner(); + if (!owner_info) { + size = scnprintf(page, PAGE_SIZE, + "Failed to find any loaded configuration\n"); + goto exit_unlock; + } + + /* get string desc of last unload configuration from owner info */ + size = cscfg_get_owner_info_str(owner_info, page, PAGE_SIZE); + +exit_unlock: + mutex_unlock(&cfs_mutex); + return size; +} +CONFIGFS_ATTR_RO(cscfg_cfg_, show_last_load); + +static struct configfs_attribute *cscfg_config_configfs_attrs[] = { + &cscfg_cfg_attr_unload_last_table, + &cscfg_cfg_attr_show_last_load, + NULL, +};

static struct config_item_type cscfg_configs_load_type = { .ct_owner = THIS_MODULE, + .ct_attrs = cscfg_config_configfs_attrs, };

/* configurations group */

Extract shared user space and kernel common structures from coresight-config.h into common header file coresight-config-desc.h

Abstract memory allocation in coresight-config-table.c to allow read table functions to be run in userspace and kernel drivers.

Signed-off-by: Mike Leach mike.leach@linaro.org --- .../coresight/coresight-config-desc.h | 105 ++++++++++++++++ .../coresight/coresight-config-table.c | 66 +++++----- .../hwtracing/coresight/coresight-config.h | 119 ++++-------------- 3 files changed, 165 insertions(+), 125 deletions(-) create mode 100644 drivers/hwtracing/coresight/coresight-config-desc.h

diff --git a/drivers/hwtracing/coresight/coresight-config-desc.h b/drivers/hwtracing/coresight/coresight-config-desc.h new file mode 100644 index 000000000000..4a487743d7e2 --- /dev/null +++ b/drivers/hwtracing/coresight/coresight-config-desc.h @@ -0,0 +1,105 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2020-2022 Linaro Limited, All rights reserved. + * Author: Mike Leach mike.leach@linaro.org + */ + +#ifndef _CORESIGHT_CORESIGHT_CONFIG_DESC_H +#define _CORESIGHT_CORESIGHT_CONFIG_DESC_H + +/* Coresight Descriptors common to kernel and userspace applications */ +/* + * Register type flags for register value descriptor: + * describe how the value is interpreted, and handled. + */ +#define CS_CFG_REG_TYPE_STD 0x80 /* reg is standard reg */ +#define CS_CFG_REG_TYPE_RESOURCE 0x40 /* reg is a resource */ +#define CS_CFG_REG_TYPE_VAL_PARAM 0x08 /* reg value uses param */ +#define CS_CFG_REG_TYPE_VAL_MASK 0x04 /* reg value bit masked */ +#define CS_CFG_REG_TYPE_VAL_64BIT 0x02 /* reg value 64 bit */ +#define CS_CFG_REG_TYPE_VAL_SAVE 0x01 /* reg value save on disable */ + +/* + * flags defining what device class a feature will match to when processing a + * system configuration - used by config data and devices. + */ +#define CS_CFG_MATCH_CLASS_SRC_ALL 0x0001 /* match any source */ +#define CS_CFG_MATCH_CLASS_SRC_ETM4 0x0002 /* match any ETMv4 device */ + +/* flags defining device instance matching - used in config match desc data. */ +#define CS_CFG_MATCH_INST_ANY 0x80000000 /* any instance of a class */ + +/* + * Limit number of presets in a configuration + * This is related to the number of bits (4) we use to select the preset on + * the perf command line. Preset 0 is always none selected. + * See PMU_FORMAT_ATTR(preset, "config:0-3") in coresight-etm-perf.c + */ +#define CS_CFG_CONFIG_PRESET_MAX 15 + +/** + * Parameter descriptor for a device feature. + * + * @name: Name of parameter. + * @value: Initial or default value. + */ +struct cscfg_parameter_desc { + const char *name; + u64 value; +}; + +/** + * Representation of register value and a descriptor of register usage. + * + * Used as a descriptor in the feature descriptors. + * Used as a value in when in a feature loading into a csdev. + * + * Supports full 64 bit register value, or 32 bit value with optional mask + * value. + * + * @type: define register usage and interpretation. + * @offset: the address offset for register in the hardware device (per device specification). + * @hw_info: optional hardware device type specific information. (ETM / CTI specific etc) + * @val64: 64 bit value. + * @val32: 32 bit value. + * @mask32: 32 bit mask when using 32 bit value to access device register - if mask type. + * @param_idx: parameter index value into parameter array if param type. + */ +struct cscfg_regval_desc { + struct { + u32 type:8; + u32 offset:12; + u32 hw_info:12; + }; + union { + u64 val64; + struct { + u32 val32; + u32 mask32; + }; + u32 param_idx; + }; +}; + +/** + * Dynamically loaded descriptor arrays. + * + * For builtin or module loaded configurations / features these are + * statically defined at compile time. + + * For a dynamic load at runtime, using a config table, (e.g. load from + * configfs) we create the arrays dynamically so need a structure to + * manage these. + * + * @config_descs: array of config descriptor pointers. + * @feat_descs: array of feature descriptor pointers. + * @load_name: user readable name which may be used to unload later. + * Will be name of first config if present, or first feature. + */ +struct cscfg_table_load_descs { + struct cscfg_config_desc **config_descs; + struct cscfg_feature_desc **feat_descs; + char *load_name; +}; + +#endif /* _CORESIGHT_CORESIGHT_CONFIG_DESC_H */ diff --git a/drivers/hwtracing/coresight/coresight-config-table.c b/drivers/hwtracing/coresight/coresight-config-table.c index 0a8f017d76d2..6216dffc9f9e 100644 --- a/drivers/hwtracing/coresight/coresight-config-table.c +++ b/drivers/hwtracing/coresight/coresight-config-table.c @@ -79,6 +79,7 @@ static int cscfg_table_read_elem_str(const u8 *buffer, const int buflen, int *bu struct cscfg_table_elem_str *elem_str) { int used = *buf_used; + const u8 *str;

if ((buflen - used) < sizeof(u16)) return -EINVAL; @@ -88,11 +89,13 @@ static int cscfg_table_read_elem_str(const u8 *buffer, const int buflen, int *bu if ((buflen - used) < elem_str->str_len) return -EINVAL;

+ str = buffer + used; + /* check for 0 termination */ - if (buffer[used + (elem_str->str_len - 1)] != 0) + if (str[elem_str->str_len - 1] != 0) return -EINVAL;

- elem_str->str = kstrdup((char *)(buffer + used), GFP_KERNEL); + elem_str->str = cscfg_strdup((char *)str); used += elem_str->str_len;

*buf_used = used; @@ -103,12 +106,13 @@ static int cscfg_table_alloc_desc_arrays(struct cscfg_table_load_descs *desc_arr int nr_features, int nr_configs) { /* arrays are 0 terminated - nr_configs & nr_features elements */ - desc_arrays->config_descs = kcalloc(nr_configs + 1, sizeof(struct cscfg_config_desc *), - GFP_KERNEL); + desc_arrays->config_descs = cscfg_calloc(nr_configs + 1, + sizeof(struct cscfg_config_desc *)); if (!desc_arrays->config_descs) return -ENOMEM; - desc_arrays->feat_descs = kcalloc(nr_features + 1, sizeof(struct cscfg_feature_desc *), - GFP_KERNEL); + + desc_arrays->feat_descs = cscfg_calloc(nr_features + 1, + sizeof(struct cscfg_feature_desc *)); if (!desc_arrays->feat_descs) return -ENOMEM; return 0; @@ -123,24 +127,24 @@ static void cscfg_table_free_config_desc(struct cscfg_config_desc *config_desc) return;

/* free presets */ - kfree(config_desc->presets); + cscfg_free((void *)config_desc->presets);

/* free feat ref strings */ if (config_desc->nr_feat_refs) { /* each string */ for (i = 0; i < config_desc->nr_feat_refs; i++) - kfree(config_desc->feat_ref_names[i]); + cscfg_free((void *)config_desc->feat_ref_names[i]);

/* and the char * array */ - kfree(config_desc->feat_ref_names); + cscfg_free((void *)config_desc->feat_ref_names); }

/* next the strings */ - kfree(config_desc->name); - kfree(config_desc->description); + cscfg_free((void *)config_desc->name); + cscfg_free((void *)config_desc->description);

/* finally the struct itself */ - kfree(config_desc); + cscfg_free((void *)config_desc); }

static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int *buf_used, @@ -165,7 +169,7 @@ static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int return 0;

/* we have a config - allocate the descriptor */ - config_desc = kzalloc(sizeof(struct cscfg_config_desc), GFP_KERNEL); + config_desc = cscfg_zalloc(sizeof(struct cscfg_config_desc)); if (!config_desc) return -ENOMEM;

@@ -177,7 +181,7 @@ static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int

/* allocate load name if not set */ if (!desc_arrays->load_name) - desc_arrays->load_name = kstrdup(config_desc->name, GFP_KERNEL); + desc_arrays->load_name = cscfg_strdup(config_desc->name);

/* read the description string */ err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); @@ -195,7 +199,7 @@ static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int /* read the array of 64bit presets if present */ nr_preset_vals = config_desc->nr_total_params * config_desc->nr_presets; if (nr_preset_vals) { - presets = kcalloc(nr_preset_vals, sizeof(u64), GFP_KERNEL); + presets = cscfg_calloc(nr_preset_vals, sizeof(u64)); if (!presets) return -ENOMEM;

@@ -210,8 +214,8 @@ static int cscfg_table_read_elem_config(const u8 *buffer, const int buflen, int

/* read the array of feature names referenced by the config */ if (config_desc->nr_feat_refs) { - config_desc->feat_ref_names = kcalloc(config_desc->nr_feat_refs, - sizeof(char *), GFP_KERNEL); + config_desc->feat_ref_names = cscfg_calloc(config_desc->nr_feat_refs, + sizeof(char *)); if (!config_desc->feat_ref_names) return -ENOMEM;

@@ -255,17 +259,17 @@ static void cscfg_table_free_feat_desc(struct cscfg_feature_desc *feat_desc) return;

/* free up the register descriptor array */ - kfree(feat_desc->regs_desc); + cscfg_free((void *)feat_desc->regs_desc);

/* free up the parameters array */ - kfree(feat_desc->params_desc); + cscfg_free((void *)feat_desc->params_desc);

/* name and description strings */ - kfree(feat_desc->name); - kfree(feat_desc->description); + cscfg_free((void *)feat_desc->name); + cscfg_free((void *)feat_desc->description);

/* finally the struct itself */ - kfree(feat_desc); + cscfg_free((void *)feat_desc); }

static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int *buf_used, @@ -280,7 +284,7 @@ static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int u32 val32;

/* allocate the feature descriptor object */ - feat_desc = kzalloc(sizeof(struct cscfg_feature_desc), GFP_KERNEL); + feat_desc = cscfg_zalloc(sizeof(struct cscfg_feature_desc)); if (!feat_desc) return -ENOMEM;

@@ -300,7 +304,7 @@ static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int

/* allocate load name if not set previously by config */ if (!desc_arrays->load_name) - desc_arrays->load_name = kstrdup(feat_desc->name, GFP_KERNEL); + desc_arrays->load_name = cscfg_strdup(feat_desc->name);

/* read the description string */ err = cscfg_table_read_elem_str(buffer, buflen, &used, &elem_str); @@ -323,8 +327,8 @@ static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int nr_regs_bytes = ((sizeof(u32) + sizeof(u64)) * feat_desc->nr_regs); if ((buflen - used) < nr_regs_bytes) return -EINVAL; - feat_desc->regs_desc = kcalloc(feat_desc->nr_regs, - sizeof(struct cscfg_regval_desc), GFP_KERNEL); + feat_desc->regs_desc = cscfg_calloc(feat_desc->nr_regs, + sizeof(struct cscfg_regval_desc)); if (!feat_desc->regs_desc) return -ENOMEM;

@@ -338,8 +342,8 @@ static int cscfg_table_read_elem_feature(const u8 *buffer, const int buflen, int

/* parameter descriptors - string + 64 bit value */ if (feat_desc->nr_params) { - feat_desc->params_desc = kcalloc(feat_desc->nr_params, - sizeof(struct cscfg_parameter_desc), GFP_KERNEL); + feat_desc->params_desc = cscfg_calloc(feat_desc->nr_params, + sizeof(struct cscfg_parameter_desc)); if (!feat_desc->params_desc) return -ENOMEM; for (i = 0; i < feat_desc->nr_params; i++) { @@ -421,7 +425,7 @@ void cscfg_table_free_load_descs(struct cscfg_table_load_descs *desc_arrays) }

/* finally free up the load descs pointer arrays */ - kfree(desc_arrays->config_descs); - kfree(desc_arrays->feat_descs); - kfree(desc_arrays->load_name); + cscfg_free(desc_arrays->config_descs); + cscfg_free(desc_arrays->feat_descs); + cscfg_free(desc_arrays->load_name); } diff --git a/drivers/hwtracing/coresight/coresight-config.h b/drivers/hwtracing/coresight/coresight-config.h index ea3aaf0d129b..8b298e9a3776 100644 --- a/drivers/hwtracing/coresight/coresight-config.h +++ b/drivers/hwtracing/coresight/coresight-config.h @@ -10,101 +10,10 @@ #include <linux/coresight.h> #include <linux/types.h>

-/* CoreSight Configuration Management - component and system wide configuration */ - -/* - * Register type flags for register value descriptor: - * describe how the value is interpreted, and handled. - */ -#define CS_CFG_REG_TYPE_STD 0x80 /* reg is standard reg */ -#define CS_CFG_REG_TYPE_RESOURCE 0x40 /* reg is a resource */ -#define CS_CFG_REG_TYPE_VAL_PARAM 0x08 /* reg value uses param */ -#define CS_CFG_REG_TYPE_VAL_MASK 0x04 /* reg value bit masked */ -#define CS_CFG_REG_TYPE_VAL_64BIT 0x02 /* reg value 64 bit */ -#define CS_CFG_REG_TYPE_VAL_SAVE 0x01 /* reg value save on disable */ - -/* - * flags defining what device class a feature will match to when processing a - * system configuration - used by config data and devices. - */ -#define CS_CFG_MATCH_CLASS_SRC_ALL 0x0001 /* match any source */ -#define CS_CFG_MATCH_CLASS_SRC_ETM4 0x0002 /* match any ETMv4 device */ - -/* flags defining device instance matching - used in config match desc data. */ -#define CS_CFG_MATCH_INST_ANY 0x80000000 /* any instance of a class */ - -/* - * Limit number of presets in a configuration - * This is related to the number of bits (4) we use to select the preset on - * the perf command line. Preset 0 is always none selected. - * See PMU_FORMAT_ATTR(preset, "config:0-3") in coresight-etm-perf.c - */ -#define CS_CFG_CONFIG_PRESET_MAX 15 - -/** - * Parameter descriptor for a device feature. - * - * @name: Name of parameter. - * @value: Initial or default value. - */ -struct cscfg_parameter_desc { - const char *name; - u64 value; -}; - -/** - * Representation of register value and a descriptor of register usage. - * - * Used as a descriptor in the feature descriptors. - * Used as a value in when in a feature loading into a csdev. - * - * Supports full 64 bit register value, or 32 bit value with optional mask - * value. - * - * @type: define register usage and interpretation. - * @offset: the address offset for register in the hardware device (per device specification). - * @hw_info: optional hardware device type specific information. (ETM / CTI specific etc) - * @val64: 64 bit value. - * @val32: 32 bit value. - * @mask32: 32 bit mask when using 32 bit value to access device register - if mask type. - * @param_idx: parameter index value into parameter array if param type. - */ -struct cscfg_regval_desc { - struct { - u32 type:8; - u32 offset:12; - u32 hw_info:12; - }; - union { - u64 val64; - struct { - u32 val32; - u32 mask32; - }; - u32 param_idx; - }; -}; - -/** - * Dynamically loaded descriptor arrays. - * - * For builtin or module loaded configurations / features these are - * statically defined at compile time. +/* common descriptor definitions */ +#include "coresight-config-desc.h"

- * For a dynamic load at runtime, using a config table, (e.g. load from - * configfs) we create the arrays dynamically so need a structure to - * manage these. - * - * @config_descs: array of config descriptor pointers. - * @feat_descs: array of feature descriptor pointers. - * @load_name: user readable name which may be used to unload later. - * Will be name of first config if present, or first feature. - */ -struct cscfg_table_load_descs { - struct cscfg_config_desc **config_descs; - struct cscfg_feature_desc **feat_descs; - char *load_name; -}; +/* CoreSight Configuration Management - component and system wide configuration */

/** * Device feature descriptor - combination of registers and parameters to @@ -280,4 +189,26 @@ void cscfg_csdev_disable_config(struct cscfg_config_csdev *config_csdev); /* reset a feature to default values */ void cscfg_reset_feat(struct cscfg_feature_csdev *feat_csdev);

+ +/* Kernel allocators for descriptors in common config table read code */ +static inline void *cscfg_calloc(size_t num, size_t size) +{ + return kcalloc(num, size, GFP_KERNEL); +} + +static inline char *cscfg_strdup(const char *str) +{ + return kstrdup(str, GFP_KERNEL); +} + +static inline void *cscfg_zalloc(size_t size) +{ + return kzalloc(size, GFP_KERNEL); +} + +static inline void cscfg_free(void *mem) +{ + kfree(mem); +} + #endif /* _CORESIGHT_CORESIGHT_CONFIG_H */

Add documentation covering the updates that allow configuration tables to be loaded and unloaded via configfs, along with the demonstration programs in tools/coresight.

Cc: Jonathan Corbet corbet@lwn.net Cc: linux-doc@vger.kernel.org Signed-off-by: Mike Leach mike.leach@linaro.org --- .../trace/coresight/coresight-config.rst | 287 ++++++++++++++++-- 1 file changed, 264 insertions(+), 23 deletions(-)

diff --git a/Documentation/trace/coresight/coresight-config.rst b/Documentation/trace/coresight/coresight-config.rst index 6d5ffa6f7347..235cc6443a86 100644 --- a/Documentation/trace/coresight/coresight-config.rst +++ b/Documentation/trace/coresight/coresight-config.rst @@ -109,20 +109,20 @@ Operation

The following steps take place in the operation of a configuration.

-1) In this example, the configuration is 'autofdo', which has an - associated feature 'strobing' that works on ETMv4 CoreSight Devices. +1) In this example, the configuration is ``autofdo``, which has an + associated feature ``strobing`` that works on ETMv4 CoreSight Devices.

-2) The configuration is enabled. For example 'perf' may select the +2) The configuration is enabled. For example ``perf`` may select the configuration as part of its command line::

perf record -e cs_etm/autofdo/ myapp

- which will enable the 'autofdo' configuration. + which will enable the ``autofdo`` configuration.

3) perf starts tracing on the system. As each ETMv4 that perf uses for trace is enabled, the configuration manager will check if the ETMv4 has a feature that relates to the currently active configuration. - In this case 'strobing' is enabled & programmed into the ETMv4. + In this case ``strobing`` is enabled & programmed into the ETMv4.

4) When the ETMv4 is disabled, any registers marked as needing to be saved will be read back. @@ -136,18 +136,18 @@ Viewing Configurations and Features The set of configurations and features that are currently loaded into the system can be viewed using the configfs API.

-Mount configfs as normal and the 'cs-syscfg' subsystem will appear:: +Mount configfs as normal and the ``cs-syscfg`` subsystem will appear::

$ ls /config cs-syscfg stp-policy

-This has two sub-directories:: +This has two sub-directories, with the load and unload attribute files::

$ cd cs-syscfg/ $ ls - configurations features + configurations features load unload

-The system has the configuration 'autofdo' built in. It may be examined as +The system has the configuration ``autofdo`` built in. It may be examined as follows::

$ cd configurations/ @@ -162,7 +162,7 @@ follows:: $ cat feature_refs strobing

-Each preset declared has a 'preset<n>' subdirectory declared. The values for +Each preset declared has a ``preset<n>`` subdirectory declared. The values for the preset can be examined::

$ cat preset1/values @@ -170,7 +170,7 @@ the preset can be examined:: $ cat preset2/values strobing.window = 0x1388 strobing.period = 0x4

-The 'enable' and 'preset' files allow the control of a configuration when +The ``enable`` and ``preset`` files allow the control of a configuration when using CoreSight with sysfs.

The features referenced by the configuration can be examined in the features @@ -210,18 +210,18 @@ Using Configurations in perf ============================

The configurations loaded into the CoreSight configuration management are -also declared in the perf 'cs_etm' event infrastructure so that they can +also declared in the perf ``cs_etm`` event infrastructure so that they can be selected when running trace under perf::

$ ls /sys/devices/cs_etm cpu0 cpu2 events nr_addr_filters power subsystem uevent cpu1 cpu3 format perf_event_mux_interval_ms sinks type

-The key directory here is 'events' - a generic perf directory which allows +The key directory here is ``events`` - a generic perf directory which allows selection on the perf command line. As with the sinks entries, this provides a hash of the configuration name.

-The entry in the 'events' directory uses perfs built in syntax generator +The entry in the ``events`` directory uses perfs built in syntax generator to substitute the syntax for the name when evaluating the command::

$ ls events/ @@ -229,7 +229,7 @@ to substitute the syntax for the name when evaluating the command:: $ cat events/autofdo configid=0xa7c3dddd

-The 'autofdo' configuration may be selected on the perf command line:: +The ``autofdo`` configuration may be selected on the perf command line::

$ perf record -e cs_etm/autofdo/u --per-thread <application>

@@ -246,7 +246,7 @@ Using Configurations in sysfs Coresight can be controlled using sysfs. When this is in use then a configuration can be made active for the devices that are used in the sysfs session.

-In a configuration there are 'enable' and 'preset' files. +In a configuration there are ``enable`` and ``preset`` files.

To enable a configuration for use with sysfs::

@@ -256,13 +256,13 @@ To enable a configuration for use with sysfs:: This will then use any default parameter values in the features - which can be adjusted as described above.

-To use a preset<n> set of parameter values:: +To use a ``preset<n>`` set of parameter values::

$ echo 3 > preset

This will select preset3 for the configuration. The valid values for preset are 0 - to deselect presets, and any value of -<n> where a preset<n> sub-directory is present. +<n> where a ``preset<n>`` sub-directory is present.

Note that the active sysfs configuration is a global parameter, therefore only a single configuration can be active for sysfs at any one time. @@ -278,9 +278,28 @@ Creating and Loading Custom Configurations ==========================================

Custom configurations and / or features can be dynamically loaded into the -system by using a loadable module. +system by using a loadable module, or by loading a configuration table +through in configfs.

-An example of a custom configuration is found in ./samples/coresight. +Loaded configurations can use previously loaded features. The system will +ensure that it is not possible to unload a feature that is currently in +use, by enforcing the unload order as the strict reverse of the load order. + + +Using a Loadable Module +----------------------- + +A new configuration or set of features can be created using the internal +structures used in the drivers, by writing a loadable module that defines +the configuration, and loading this into the kernel at runtime. + +Creating a custom configuration in this way requires the user to compile the +module for the specific kernel in use, which limits portability. + +Module Example +~~~~~~~~~~~~~~ + +An example of a custom configuration module is found in ``./samples/coresight``.

This creates a new configuration that uses the existing built in strobing feature, but provides a different set of presets. @@ -289,6 +308,228 @@ When the module is loaded, then the configuration appears in the configfs file system and is selectable in the same way as the built in configuration described above.

-Configurations can use previously loaded features. The system will ensure -that it is not possible to unload a feature that is currently in use, by -enforcing the unload order as the strict reverse of the load order. +The file ``coresight-cfg-sample.c`` contains the configuration and module +initialisation code needed to create the loadable module. + +This will be built alongside the kernel modules if selected in KConfig. +(select ``CONFIG_SAMPLE_CORESIGHT_SYSCFG``). + + +Using a Configuration Table File +-------------------------------- + +Configurations and features can also be dynamically loaded at runtime +using a compact binary table format described below. + +Upon load, this table is validated, expanded into the internal structures +needed for load into the CoreSight subsystem, and loaded into the relevant +CoreSight devices. + +There are additional attributes in the cs-syscfg directory - ``load_table`` +and ``unload_last_table`` that can be used to load and unload configuration +tables. + +As described above, in order to respect configuration dependencies, unload +order is scrictly enforced to be the reverse of load order. + +Load and unload cannot be done if trace is in progress using a configuration. + +To load, 'cat' the table file into the load attribute:: + + $ ls /config/cs-syscfg + configurations features load_table show_last_load unload_last_table + $ cat example1.cscfg > /config/cs-syscfg/load_table + $ ls /config/cs-syscfg/configurations/ + autofdo autofdo3 + +``unload_last_table`` can be used to unload the last loaded configuration, +but only if this was loaded as a configuration table. + +To unload, write a non-zero value to ``unload_last_table``. This will unload +the last loaded table - unless another configuration or feature has been +loaded as a loadable module after the last table load:: + + $ echo 1 > /config/cs-syscfg/unload_last_table + ls /config/cs-syscfg/configurations/ + autofdo + +The type of the last loaded configuration can be determined by reading the +``show_last_load`` attribute:: + + $ cat /config/cs-syscfg/show_last_load + load name: autofdo3 + load type: Runtime Dynamic table load + (configurations: autofdo3 ) + (features: None ) + +This shows the key elements of the loaded configuration - the type of load, +load name, and any configurations and features loaded by the table. + +Unload will fail if the last loaded item was not a dynamic loaded table. +When using ``show_last_load`` a non table load will show:: + + cat /config/cs-syscfg/show_last_load + load name: [Not Set] + load type: Loadable module + + +Generation tools and table examples +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +The ``./tools/coresight`` directory contains example programs to generate and +read and print binary configuration table files. + +Building the tools creates the ``coresight-cfg-file-gen`` program that will +generate a configuration binary ``example1.cscfg`` that can be loaded into the +system using configfs. The configuration declared in the source file +``coresight-cfg-example1.c`` is named ``autofdo3`` - the name that will be used +once loaded. + +The source files ``coresight-cfg-bufw.h`` and ``coresight-cfg-bufw.c`` provide a +standard function to convert a configuration declared in 'C' into the correct +binary buffer format. These files can be re-used to create new custom +configurations. Alternatively, additional examples can be added to the +``coresight-cfg-file-gen`` program:: + + $ ./coresight-cfg-file-gen + Coresight Configuration file Generator + + Generating example1 example + Generating example2 example + +The program ``coresight-cfg-file-read`` can read back and print a configuration +binary. This is built using the file reader from the driver code +(``coresight-config-file.c``), which is copied over into ``./tools/coresight`` at +build time.:: + + ./coresight-cfg-file-read example1.cscfg + CoreSight Configuration file reader + ============================================ + + Configuration 1 + Name:- autofdo3 + Description:- + Setup ETMs with strobing for autofdo + Supplied presets allow experimentation with mark-space ratio for various loads + + Uses 1 features:- + Feature-1: strobing + + Provides 4 sets of preset values, 2 presets per set + set[0]: 0x7d0, 0x64, + set[1]: 0x7d0, 0x3e8, + set[2]: 0x7d0, 0x1388, + set[3]: 0x7d0, 0x2710, + + ============================================ + File contains no features + + +CoreSight Configuration Table Format +------------------------------------ + +The file format is defined in the source file ``coresight-config-table.h`` + +The source reader and generator examples use/produce a table in this format, +as a binary file. + +This arrangement is reproduced below:- + +Overall Table structure +~~~~~~~~~~~~~~~~~~~~~~~ + +:: + + [cscfg_table_header] // Mandatory + [CONFIG_ELEM]* // Optional - multiple, defined by cscfg_table_header.nr_configs + [FEATURE_ELEM]* // Optional - multiple, defined by cscfg_table_header.nr_features + +Table is invalid if both [CONFIG_ELEM] and [FEATURE_ELEM] are omitted. + +A table that contains only [FEATURE_ELEM] may be loaded, and the features used +by subsequently loaded files with [CONFIG_ELEM] elements. + +Element Name Strings +~~~~~~~~~~~~~~~~~~~~ + +Configuration name strings are required to consist of alphanumeric characters and '_' only. Other special characters are not permitted. + +For example ``my_config_2`` is a valid name, while ``this-bad-config#5`` will not work. + +This is in order to comply with the requirements of the perf command line. + +It is recommended that Feature and Parameter names use the same convention to allow for future enhancements to the command line syntax. + +CONFIG_ELEM element +~~~~~~~~~~~~~~~~~~~ + +:: + + [cscfg_table_elem_header] // header length value to end of feature strings. + [cscfg_table_elem_str] // name of the configuration. + // (see element string name requirements) + [cscfg_table_elem_str] // description of configuration. + [u16 value](nr_presets) // number of defined sets presets values. + [u32 value](nr_total_params) // total parameters defined by all used features. + [u16 value](nr_feat_refs) // number of features referenced by the configuration + [u64 values] * (nr_presets * nr_total_params) // the preset values. + [cscfg_table_elem_str] * (nr_feat_refs) // names of features used in the configurations. + +FEATURE_ELEM element +~~~~~~~~~~~~~~~~~~~~ + +:: + + [cscfg_table_elem_header] // header length is total bytes to end of param structures. + [cscfg_table_elem_str] // feature name. + [cscfg_table_elem_str] // feature description. + [u32 value](match_flags) // flags to associate the feature with a device. + [u16 value](nr_regs) // number of registers. + [u16 value](nr_params) // number of parameters. + [cscfg_regval_desc struct] * (nr_regs) // register definitions + [PARAM_ELEM] * (nr_params) // parameters definitions + +PARAM_ELEM element +~~~~~~~~~~~~~~~~~~ + +:: + + [cscfg_table_elem_str] // parameter name. + [u64 value](param_value) // initial value. + +Additional definitions +~~~~~~~~~~~~~~~~~~~~~~ + +The following structures are defined in ``coresight-config-file.h`` + + * ``struct cscfg_table_header`` : This structure contains an initial magic number, the total + length of the table, and the number of configurations and features in the table. + * ``struct cscfg_table_elem_header``: This defines the total length and type of a CONFIG_ELEM + or a FEATURE_ELEM. + * ``struct cscfg_table_elem_str``: This defines a string and its length. + +The magic number in cscfg_table_header is defined as two bitfields:: + + [31:8] Fixed magic number to identify table type. + [7:0] Current table format version. + +The following defines determine the maximum overall table size and maximum individual +string size + + * ``CSCFG_TABLE_MAXSIZE`` : maximum overall table size. + * ``CSCFG_TABLE_STR_MAXSIZE`` : maximum individual string size. + +Load Dependencies +~~~~~~~~~~~~~~~~~ + +Files may be unloaded only in the strict reverse order of loading. This is enforced by the +configuration system. + +This is to ensure that any load dependencies are maintained. + +A configuration table that contains a CONFIG_ELEM that references named features "feat_A" and "feat_B" will load only if either:- + +a) "feat_A" and/or "feat_B" has been loaded previously, or are present as built-in / module loaded features. +b) "feat_A" and/or "feat_B" are declared as FEAT_ELEM in the same table as the CONFIG_ELEM. + +Tables that contain features or configurations with the same names as those already loaded will fail to load.