Add processing of code coverage for optee core

core/arch/arm/plat-imx/conf.mk

@@ -425,5 +425,17 @@ CFG_IMX_CAAM ?= y
 endif
 endif
 
+ifeq ($(CFG_CORE_GCOV_SUPPORT), y)
+ifneq ($(CFG_WITH_LPAE), y)
+# Default:
+# TEE_RAM_VA_SIZE = CORE_MMU_PGDIR_SIZE
+#                 = BIT(CORE_MMU_PGDIR_SHIFT)
+# with LPAE disabled: #define CORE_MMU_PGDIR_SHIFT	20
+#                 = BIT(20)
+#                 = 0x80000 (512 Ko)
+CFG_TEE_RAM_VA_SIZE := 0x200000 # 2MB
+endif
+endif
+
 # Cryptographic configuration
 include core/arch/arm/plat-imx/crypto_conf.mk

core/core.mk

@@ -119,6 +119,12 @@ include mk/lib.mk
 base-prefix := $(sm)-
 endif
 
+ifeq ($(CFG_GCOV_SUPPORT),y)
+libname = gcov
+libdir = lib/libgcov
+include mk/lib.mk
+endif
+
 ifeq ($(firstword $(subst /, ,$(CFG_CRYPTOLIB_DIR))),core)
 # If a library can be compiled for both core and user space a base-prefix
 # is needed in order to avoid conflicts in the output. However, if the

lib/libgcov/core_dump_coverage.c

@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright 2020 NXP
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <trace.h>
+
+#include <gcov.h>
+#include <optee_rpc_cmd.h>
+#include <tee/tee_fs_rpc.h>
+#include <tee_api_types.h>
+
+#include "int_gcov.h"
+
+/*
+ * Dump coverage data to REE FS
+ *
+ * The description is prepended to the filepath
+ * Sends the coverage data to the writer
+ *
+ * @desc           Description for storage, null terminated string
+ * @filepath       Name of the coverage file
+ * @cov_data       The coverage data to dump
+ * @cov_data_size  Size of the coverage data
+ */
+static TEE_Result core_direct_dump_data(const char *desc, const char *filepath,
+					void *cov_data, uint32_t cov_data_size)
+{
+	const char *core = "core/";
+	char new_filepath[COVERAGE_PATH_MAX];
+	uint32_t filepath_size = 0;
+
+	if (!desc || !filepath || !cov_data) {
+		EMSG("Wrong parameters");
+		return TEE_ERROR_BAD_PARAMETERS;
+	}
+
+	filepath_size = strlen(core) + strlen(desc) + strlen(filepath) + 1;
+	if (filepath_size >= COVERAGE_PATH_MAX) {
+		EMSG("Not enough space to store new filepath");
+		return TEE_ERROR_SHORT_BUFFER;
+	}
+
+	filepath_size = 0;
+	strcpy(new_filepath + filepath_size, core);
+	filepath_size += strlen(core);
+
+	strcpy(new_filepath + filepath_size, desc);
+	filepath_size += strlen(desc);
+
+	strcpy(new_filepath + filepath_size, filepath);
+	filepath_size += strlen(filepath);
+
+	filepath_size++;
+
+	return gcov_dump_coverage_data(new_filepath, cov_data, cov_data_size);
+}
+
+gcov_dump_file_fn g_gcov_dump_fn = core_direct_dump_data;

lib/libgcov/gcov.c

@@ -0,0 +1,141 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright 2020 NXP
+ */
+
+#include <string.h>
+#include <trace.h>
+
+#include <gcov.h>
+
+#include "int_gcov.h"
+
+static gcov_dump_writer s_writer_fn;
+
+static bool isnullterm(const char *string, size_t maxlen, size_t *len)
+{
+	size_t s_len = strnlen(string, maxlen);
+
+	if (s_len == maxlen)
+		return false;
+
+	if (len)
+		*len = s_len;
+
+	return true;
+}
+
+void __gcov_init(void *cov_unit_info)
+{
+	if (!g_gcov_impl || !g_gcov_impl->init)
+		EMSG("No implementation");
+	else
+		g_gcov_impl->init(cov_unit_info);
+}
+
+void __gcov_merge_add(void *ctrs, uint32_t nb_ctrs)
+{
+	if (!g_gcov_impl || !g_gcov_impl->merge_add)
+		EMSG("No implementation");
+	else
+		g_gcov_impl->merge_add(ctrs, nb_ctrs);
+}
+
+void __gcov_exit(void)
+{
+	if (!g_gcov_impl || !g_gcov_impl->exit)
+		EMSG("No implementation");
+	else
+		g_gcov_impl->exit();
+}
+
+TEE_Result gcov_get_version(uint32_t *version)
+{
+	/* We test if the implementation has implementeed the function */
+	if (!g_gcov_impl || !g_gcov_impl->get_version) {
+		EMSG("No implementation");
+		return TEE_ERROR_NOT_IMPLEMENTED;
+	}
+
+	if (version)
+		*version = g_gcov_impl->get_version();
+
+	return TEE_SUCCESS;
+}
+
+TEE_Result gcov_reset_coverage_data(void)
+{
+	TEE_Result res = TEE_SUCCESS;
+
+	/* We test if the implementation has implementeed the function */
+	if (!g_gcov_impl || !g_gcov_impl->reset_all_coverage_data) {
+		EMSG("No implementation");
+		res = TEE_ERROR_NOT_IMPLEMENTED;
+	} else {
+		res = g_gcov_impl->reset_all_coverage_data();
+	}
+
+	return res;
+}
+
+TEE_Result register_gcov_dump_writer(gcov_dump_writer writer_fn)
+{
+	s_writer_fn = writer_fn;
+
+	return TEE_SUCCESS;
+}
+
+TEE_Result gcov_dump_coverage_data(const char *filepath, char *cov_data,
+				   uint32_t cov_data_size)
+{
+	if (!filepath || !cov_data || !cov_data_size)
+		return TEE_ERROR_BAD_PARAMETERS;
+
+	if (!s_writer_fn) {
+		EMSG("Writer function not registered");
+		return TEE_ERROR_NOT_IMPLEMENTED;
+	}
+
+	if (!isnullterm(filepath, COVERAGE_PATH_MAX, NULL)) {
+		EMSG("filepath is not null terminated");
+		return TEE_ERROR_BAD_PARAMETERS;
+	}
+
+	return s_writer_fn(filepath, cov_data, cov_data_size);
+}
+
+TEE_Result gcov_dump_all_coverage_data(const char *desc)
+{
+	TEE_Result res = TEE_SUCCESS;
+	const char *slash = "/";
+
+	if (!desc) {
+		desc = slash;
+	} else if (!isnullterm(desc, COVERAGE_PATH_MAX, NULL)) {
+		EMSG("description is not null terminated");
+		return TEE_ERROR_BAD_PARAMETERS;
+	}
+
+	/* We test if the implementation has implementeed the function */
+	if (!g_gcov_impl || !g_gcov_impl->dump_all_coverage_data ||
+	    !g_gcov_dump_fn) {
+		EMSG("No implementation");
+		return TEE_ERROR_NOT_IMPLEMENTED;
+	}
+
+	if (g_gcov_impl->start_dump_all_coverage_data) {
+		res = g_gcov_impl->start_dump_all_coverage_data();
+		if (res) {
+			EMSG("Failed to start dump of coverage data");
+			return res;
+		}
+	}
+
+	res = g_gcov_impl->dump_all_coverage_data(g_gcov_dump_fn, desc);
+
+	if (g_gcov_impl->start_dump_all_coverage_data &&
+	    g_gcov_impl->end_dump_all_coverage_data)
+		g_gcov_impl->end_dump_all_coverage_data();
+
+	return res;
+}