ext_manifest: Add UUID dictionary

Such a dictionary will be used in kernel code to translate UUID value
to memory address used in DSP in runtime.
Translation will be used for the process component creation and
runtime trace filtering.

Signed-off-by: Karol Trzcinski <karolx.trzcinski@linux.intel.com>

Author: ktrzcinx

src/ext_manifest.c

@@ -13,6 +13,11 @@
 #include "kernel/ext_manifest.h"
 #include "rimage.h"
 
+#ifndef ALIGN_UP
+#define ALIGN_UP(size, alignment) \
+	((size) + (((alignment) - ((size) % (alignment))) % (alignment)))
+#endif
+
 const struct ext_man_header ext_man_template = {
 	.magic = EXT_MAN_MAGIC_NUMBER,
 	.header_version = EXT_MAN_VERSION,
@@ -81,53 +86,129 @@ static int ext_man_validate(uint32_t section_size, const void *section_data)
 	}
 }
 
+/*
+ * Insert `section_name` content after `elem_type` header.
+ * Save result in new buffer, then replace `meta_section_data`.
+ * Return `section_name` size or error code.
+ */
+static int ext_man_update_element_with_list(const struct module *module,
+					    uint32_t* meta_section_size,
+					    uint8_t **meta_section_data,
+					    enum ext_man_elem_type elem_type,
+					    const char *section_name)
+{
+	struct ext_man_elem_header* head = NULL;
+	uint8_t *msd_buff = *meta_section_data;
+	uint8_t *sec_buffer = NULL;
+	const Elf32_Shdr *section;
+	uint32_t offset = 0;
+	uint32_t extra_size;
+	uint8_t *temp_buff;
+	int ret;
+
+	/* find `elem_type` in meta_section */
+	while (offset < *meta_section_size) {
+		head = (struct ext_man_elem_header*)&msd_buff[offset];
+		if (head->type == elem_type || !head->elem_size)
+			break;
+		offset += head->elem_size;
+	}
+
+	if (!head || head->type != elem_type) {
+		fprintf(stdout,
+			"Extended manifest element %d not found\n", elem_type);
+		return -EINVAL;
+	}
+
+	/* read section with list content */
+	ret = elf_read_section(module, section_name, &section,
+			       (void **)&sec_buffer);
+	if (ret < 0) {
+		fprintf(stderr,
+			"error: failed to read %s section content, code %d\n",
+			section_name, ret);
+		return ret;
+	}
+
+	temp_buff = malloc(*meta_section_size + section->size);
+	if (!temp_buff) {
+		free(sec_buffer);
+		return -ENOMEM;
+	}
+
+	/* update element size and insert list after element header */
+	offset += head->elem_size;
+	extra_size = ALIGN_UP(head->elem_size + section->size, EXT_MAN_ALIGN) -
+		     head->elem_size;
+	head->elem_size += extra_size;
+	memcpy(&temp_buff[0], msd_buff, offset);
+	memcpy(&temp_buff[offset], sec_buffer, section->size);
+	memcpy(&temp_buff[offset + section->size], &msd_buff[offset],
+	       *meta_section_size - offset);
+
+	free(*meta_section_data);
+	*meta_section_data = temp_buff;
+
+	return 0;
+}
+
 static int ext_man_build(const struct module *module,
 			 struct ext_man_header **dst_buff)
 {
 	struct ext_man_header ext_man;
 	const Elf32_Shdr *section;
 	uint8_t *buffer = NULL;
 	uint8_t *sec_buffer = NULL;
-	size_t offset;
+	uint32_t sec_buffer_size;
 	int ret;
 
-	ret = elf_read_section(module, EXT_MAN_DATA_SECTION, &section,
-			       (void **)&sec_buffer);
-	if (ret < 0) {
+	sec_buffer_size = elf_read_section(module, EXT_MAN_DATA_SECTION,
+					   &section, (void **)&sec_buffer);
+	if (sec_buffer_size < 0) {
 		fprintf(stderr,
 			"error: failed to read %s section content, code %d\n",
 			EXT_MAN_DATA_SECTION, ret);
-		goto out;
+		return sec_buffer_size;
+	}
+
+	ret = ext_man_update_element_with_list(module, &sec_buffer_size,
+					       &sec_buffer,
+					       EXT_MAN_ELEM_UUID_DICT,
+					       EXT_MAN_UUID_DICT_SECTION);
+	if (ret < 0) {
+		fprintf(stderr,
+			"error: failed to update extended manifest element with %s section content, code %d\n",
+			EXT_MAN_UUID_DICT_SECTION, ret);
+		goto err;
 	}
-	ret = 0;
 
 	/* fill ext_man struct, size aligned to 4 to avoid unaligned accesses */
 	memcpy(&ext_man, &ext_man_template, sizeof(struct ext_man_header));
 	ext_man.full_size = ext_man.header_size;
-	ext_man.full_size += section->size;
+	ext_man.full_size += sec_buffer_size;
 	if (ext_man.full_size % 4) {
 		fprintf(stderr,
 			"error: extended manifest size must be aligned to 4\n");
 		ret = -EINVAL;
-		goto out;
+		goto err;
 	}
 
 	/* alloc buffer for ext_man */
 	buffer = calloc(1, ext_man.full_size);
 	if (!buffer) {
 		ret = -ENOMEM;
-		goto out;
+		goto err;
 	}
 
 	/* fill buffer with ext_man and section content */
 	memcpy(buffer, &ext_man, ext_man.header_size);
-	offset = ext_man.header_size;
-
-	memcpy(&buffer[offset],sec_buffer, section->size);
+	memcpy(&buffer[ext_man.header_size], sec_buffer, sec_buffer_size);
 
 	*dst_buff = (struct ext_man_header *)buffer;
 
-out:
+err:
+	if (!sec_buffer)
+		free(sec_buffer);
 	return ret;
 }
 

src/include/sof/kernel/ext_manifest.h

@@ -83,6 +83,7 @@ enum ext_man_elem_type {
 	EXT_MAN_ELEM_FW_VERSION		= 0,
 	EXT_MAN_ELEM_CC_VERSION		= 1,
 	EXT_MAN_ELEM_PROBE_INFO		= 2,
+	EXT_MAN_ELEM_UUID_DICT		= 3,
 };
 
 #endif /* __KERNEL_EXT_MANIFEST_H__ */

src/include/sof/kernel/ext_manifest_gen.h

@@ -30,6 +30,7 @@
 #include "rimage.h"
 
 #define EXT_MAN_DATA_SECTION ".fw_metadata"
+#define EXT_MAN_UUID_DICT_SECTION ".fw_metadata_uuid_dict"
 
 int ext_man_write(struct image *image);