Add processing of code coverage for optee core

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;
+}

lib/libgcov/include/gcov.h

@@ -0,0 +1,52 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright 2020 NXP
+ */
+
+#ifndef GCOV_H
+#define GCOV_H
+
+#include <tee_api_types.h>
+
+/*
+ * Print debug information about the gcov support
+ *
+ * @version  The version of the implementation
+ */
+TEE_Result gcov_get_version(uint32_t *version);
+
+/*
+ * Reset all the coverage data
+ */
+TEE_Result gcov_reset_coverage_data(void);
+
+/*
+ * Write the coverage data to filesystem in the file filepath
+ *
+ * @filepath      Path of the file to write
+ * @cov_data      Coverage data to write
+ * @cov_data_size Coverage data size
+ */
+typedef TEE_Result (*gcov_dump_writer)(const char *filepath, char *cov_data,
+				       uint32_t cov_data_size);
+
+TEE_Result register_gcov_dump_writer(gcov_dump_writer writer_fn);
+
+/*
+ * Dump coverage data to REE FS
+ *
+ * @filepath       Path of the coverage file
+ * @cov_data       The coverage data to dump
+ * @cov_data_size  Size of the coverage data
+ */
+TEE_Result gcov_dump_coverage_data(const char *filepath, char *cov_data,
+				   uint32_t cov_data_size);
+
+/*
+ * Dump the current state of the coverage data to filesystem
+ *
+ * @desc  Description for storage, null terminated string
+ */
+TEE_Result gcov_dump_all_coverage_data(const char *desc);
+
+#endif /* GCOV_H */

lib/libgcov/int_gcov.h

@@ -0,0 +1,118 @@
+/* SPDX-License-Identifier: BSD-2-Clause */
+/*
+ * Copyright 2020 NXP
+ */
+
+#ifndef INT_GCOV_H
+#define INT_GCOV_H
+
+#include <tee_api_types.h>
+
+/*
+ * Maximum size of a coverage path
+ */
+#define COVERAGE_PATH_MAX 255
+
+/*
+ * Initialize the data from a coverage unit
+ *
+ * @cov_unit_info  The coverage data to initialize
+ */
+void __gcov_init(void *cov_unit_info);
+
+/*
+ * Perform the merge_data operation for @p hProfData
+ *
+ * @ctrs     List of counters to merge
+ * @nb_ctrs  Number of counters to merge
+ */
+void __gcov_merge_add(void *ctrs, uint32_t nb_ctrs);
+
+/*
+ * Coverage processing can be stopped
+ */
+void __gcov_exit(void);
+
+/*
+ * Dump coverage data to REE FS
+ *
+ * The description is prepended to the filepath
+ *
+ * @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
+ */
+typedef TEE_Result (*gcov_dump_file_fn)(const char *desc, const char *filepath,
+					void *cov_data, uint32_t cov_data_size);
+
+/*
+ * static Implementation of dump function to use
+ */
+extern gcov_dump_file_fn g_gcov_dump_fn;
+
+/*
+ * Define the functions an implementation shall provide to process the coverage
+ * data
+ */
+struct gcov_impl_t {
+	/*
+	 * Get the version of the implementation
+	 */
+	uint32_t (*get_version)(void);
+	/*
+	 * Initialize the data of the coverage unit
+	 *
+	 * @cov_unit_info  The coverage unit info to initialize
+	 */
+	void (*init)(void *cov_unit_info);
+
+	/*
+	 * Perform the merge_data operation for @p hProfData
+	 *
+	 * @ctrs     List of counters to merge
+	 * @nb_ctrs  Number of counters to merge
+	 */
+	void (*merge_add)(void *ctrs, uint32_t nb_ctrs);
+
+	/*
+	 * Coverage processing can be stopped
+	 */
+	void (*exit)(void);
+
+	/*
+	 * Reset all the coverage data
+	 */
+	TEE_Result (*reset_all_coverage_data)(void);
+
+	/*
+	 * Start dump of all the coverage data
+	 */
+	TEE_Result (*start_dump_all_coverage_data)(void);
+
+	/*
+	 * Dump all the coverage data to filesystem
+	 *
+	 * @dump_fn  The function to call to dump data
+	 * @desc     Description for storage, null terminated string
+	 */
+	TEE_Result (*dump_all_coverage_data)(gcov_dump_file_fn dump_fn,
+					     const char *desc);
+
+	/*
+	 * End dump of all the coverage data
+	 */
+	void (*end_dump_all_coverage_data)(void);
+};
+
+/*
+ * static Implementation of gcov to use
+ */
+extern const struct gcov_impl_t *g_gcov_impl;
+
+/*
+ * Macro to register the implementation of gcov
+ */
+#define REGISTR_GCOV_IMPL(p_impl) const struct gcov_impl_t *g_gcov_impl = p_impl
+
+#endif /* INT_GCOV_H */

lib/libgcov/sub.mk

@@ -0,0 +1,10 @@
+global-incdirs-y += include
+srcs-y += gcov.c
+
+# Select the dumper of coverage to use in the library depending on the
+# component being built
+ifeq ($(sm-core),y)
+srcs-y += core_dump_coverage.c
+else
+srcs-y += ta_dump_coverage.c
+endif