From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from phobos.denx.de (phobos.denx.de [85.214.62.61]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 4F733C433FE for ; Tue, 8 Nov 2022 10:54:10 +0000 (UTC) Received: from h2850616.stratoserver.net (localhost [IPv6:::1]) by phobos.denx.de (Postfix) with ESMTP id 9DC3284DE8; Tue, 8 Nov 2022 11:54:07 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=fail (p=none dis=none) header.from=arm.com Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=u-boot-bounces@lists.denx.de Received: by phobos.denx.de (Postfix, from userid 109) id 6C15484DEB; Tue, 8 Nov 2022 11:54:05 +0100 (CET) Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by phobos.denx.de (Postfix) with ESMTP id 1582D81C06 for ; Tue, 8 Nov 2022 11:54:01 +0100 (CET) Authentication-Results: phobos.denx.de; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: phobos.denx.de; spf=pass smtp.mailfrom=abdellatif.elkhlifi@arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 770E423A; Tue, 8 Nov 2022 02:54:06 -0800 (PST) Received: from e121910.cambridge.arm.com (unknown [10.57.36.86]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 14A693F534; Tue, 8 Nov 2022 02:53:58 -0800 (PST) Date: Tue, 8 Nov 2022 10:53:56 +0000 From: Abdellatif El Khlifi To: Ilias Apalodimas Cc: sjg@chromium.org, u-boot@lists.denx.de, nd@arm.com Subject: Re: [PATCH v6 07/10] arm_ffa: introduce Sandbox test cases for UCLASS_FFA Message-ID: <20221108105356.GA529@e121910.cambridge.arm.com> References: <20220926140827.15125-1-abdellatif.elkhlifi@arm.com> <20221013103857.614-1-abdellatif.elkhlifi@arm.com> <20221013103857.614-8-abdellatif.elkhlifi@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.9.4 (2018-02-28) X-BeenThere: u-boot@lists.denx.de X-Mailman-Version: 2.1.39 Precedence: list List-Id: U-Boot discussion List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: u-boot-bounces@lists.denx.de Sender: "U-Boot" X-Virus-Scanned: clamav-milter 0.103.6 at phobos.denx.de X-Virus-Status: Clean On Mon, Oct 24, 2022 at 03:10:09PM +0300, Ilias Apalodimas wrote: > Hi Abdellatif > On Thu, Oct 13, 2022 at 11:38:54AM +0100, Abdellatif El Khlifi wrote: > > Add functional test cases for the FF-A core driver > > > > These tests rely on the FF-A Sandbox driver which helps in > > inspecting the FF-A core driver. > > This looks ok from me, but I'd prefer Simon having a quick look, since I am > not an expert when it comes to sandbox and testing Thanks for the feedback Ilias. Simon, could you please provide a feedback about the Sandbox part ? > > Thanks > /Ilias > > > > Signed-off-by: Abdellatif El Khlifi > > Cc: Tom Rini > > Cc: Simon Glass > > Cc: Ilias Apalodimas > > Cc: Jens Wiklander > > > > --- > > > > Changelog: > > =============== > > > > v4: align sandbox tests with the new FF-A driver interfaces > > and new way of error handling > > > > v1: introduce sandbox tests > > > > MAINTAINERS | 1 + > > test/dm/Makefile | 2 + > > test/dm/ffa.c | 394 +++++++++++++++++++++++++++++++++++++++++++++++ > > 3 files changed, 397 insertions(+) > > create mode 100644 test/dm/ffa.c > > > > diff --git a/MAINTAINERS b/MAINTAINERS > > index 598ae76e16..bf198f4ce1 100644 > > --- a/MAINTAINERS > > +++ b/MAINTAINERS > > @@ -256,6 +256,7 @@ F: doc/arch/arm64.ffa.rst > > F: drivers/firmware/arm-ffa/ > > F: include/arm_ffa.h > > F: include/sandbox_arm_ffa.h > > +F: test/dm/ffa.c > > > > ARM FREESCALE IMX > > M: Stefano Babic > > diff --git a/test/dm/Makefile b/test/dm/Makefile > > index 5178daa7cf..e5bc4b4bd6 100644 > > --- a/test/dm/Makefile > > +++ b/test/dm/Makefile > > @@ -1,6 +1,7 @@ > > # SPDX-License-Identifier: GPL-2.0+ > > # > > # Copyright (c) 2013 Google, Inc > > +# (C) Copyright 2022 ARM Limited > > > > obj-$(CONFIG_UT_DM) += test-dm.o > > > > @@ -81,6 +82,7 @@ obj-$(CONFIG_POWER_DOMAIN) += power-domain.o > > obj-$(CONFIG_ACPI_PMC) += pmc.o > > obj-$(CONFIG_DM_PMIC) += pmic.o > > obj-$(CONFIG_DM_PWM) += pwm.o > > +obj-$(CONFIG_SANDBOX_FFA) += ffa.o > > obj-$(CONFIG_QFW) += qfw.o > > obj-$(CONFIG_RAM) += ram.o > > obj-y += regmap.o > > diff --git a/test/dm/ffa.c b/test/dm/ffa.c > > new file mode 100644 > > index 0000000000..052d5fc3f4 > > --- /dev/null > > +++ b/test/dm/ffa.c > > @@ -0,0 +1,394 @@ > > +// SPDX-License-Identifier: GPL-2.0+ > > +/* > > + * Functional tests for UCLASS_FFA class > > + * > > + * (C) Copyright 2022 ARM Limited > > + * Abdellatif El Khlifi > > + */ > > + > > +#include > > +#include > > +#include > > +#include > > +#include "../../drivers/firmware/arm-ffa/sandbox_arm_ffa_prv.h" > > +#include > > +#include > > +#include > > + > > +/* Macros */ > > + > > +#define LOG_MSG_SZ (100) > > +#define LOG_CMD_SZ (LOG_MSG_SZ * 2) > > + > > +/* Functional tests for the UCLASS_FFA */ > > + > > +static int dm_test_ffa_log(struct unit_test_state *uts, char *msg) > > +{ > > + char cmd[LOG_CMD_SZ] = {0}; > > + > > + console_record_reset(); > > + > > + snprintf(cmd, LOG_CMD_SZ, "echo \"%s\"", msg); > > + run_command(cmd, 0); > > + > > + ut_assert_console_end(); > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_fwk_version(struct ffa_prvdata *prvdata, struct sandbox_ffa_prvdata *sdx_prvdata, > > + struct unit_test_state *uts) > > +{ > > + if (prvdata->fwk_version != sdx_prvdata->fwk_version) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, > > + "[%s]: Error: framework version: core = 0x%x , sandbox = 0x%x", __func__, > > + prvdata->fwk_version, > > + sdx_prvdata->fwk_version); > > + > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_endpoint_id(struct ffa_prvdata *prvdata, struct unit_test_state *uts) > > +{ > > + if (prvdata->id) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, > > + "[%s]: Error: endpoint id: core = 0x%x", __func__, prvdata->id); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_core_dev(struct ffa_prvdata *prvdata, struct unit_test_state *uts) > > +{ > > + if (!prvdata->dev) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: core device NULL", __func__); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_sandbox_dev(struct sandbox_ffa_prvdata *sdx_prvdata, struct unit_test_state *uts) > > +{ > > + if (!sdx_prvdata->dev) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: sandbox device NULL", __func__); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_rxtxbuf(struct ffa_prvdata *prvdata, struct unit_test_state *uts) > > +{ > > + if (!prvdata->pair.rxbuf && prvdata->pair.txbuf) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: rxbuf = 0x%llx txbuf = 0x%llx", __func__, > > + prvdata->pair.rxbuf, > > + prvdata->pair.txbuf); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_features(struct ffa_prvdata *prvdata, struct unit_test_state *uts) > > +{ > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + if (prvdata->pair.rxtx_min_pages != RXTX_4K && > > + prvdata->pair.rxtx_min_pages != RXTX_16K && > > + prvdata->pair.rxtx_min_pages != RXTX_64K) { > > + snprintf(msg, > > + LOG_MSG_SZ, > > + "[%s]: Error: FFA_RXTX_MAP features = 0x%lx", > > + __func__, > > + prvdata->pair.rxtx_min_pages); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int check_rxbuf_mapped_flag(u32 queried_func_id, > > + u8 rxbuf_mapped, > > + struct unit_test_state *uts) > > +{ > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + switch (queried_func_id) { > > + case FFA_RXTX_MAP: > > + { > > + if (rxbuf_mapped) > > + return CMD_RET_SUCCESS; > > + break; > > + } > > + case FFA_RXTX_UNMAP: > > + { > > + if (!rxbuf_mapped) > > + return CMD_RET_SUCCESS; > > + break; > > + } > > + default: > > + return CMD_RET_FAILURE; > > + } > > + > > + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: %s mapping issue", __func__, > > + (queried_func_id == FFA_RXTX_MAP ? "FFA_RXTX_MAP" : "FFA_RXTX_UNMAP")); > > + dm_test_ffa_log(uts, msg); > > + > > + return CMD_RET_FAILURE; > > +} > > + > > +static int check_rxbuf_release_flag(u8 rxbuf_owned, struct unit_test_state *uts) > > +{ > > + if (rxbuf_owned) { > > + char msg[LOG_MSG_SZ] = {0}; > > + > > + snprintf(msg, LOG_MSG_SZ, "[%s]: Error: RX buffer not released", __func__); > > + dm_test_ffa_log(uts, msg); > > + return CMD_RET_FAILURE; > > + } > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int test_ffa_msg_send_direct_req(u16 part_id, struct unit_test_state *uts) > > +{ > > + struct ffa_send_direct_data msg = {0}; > > + u8 cnt; > > + > > + ut_assertok(ffa_bus_ops_get()->sync_send_receive(part_id, &msg)); > > + > > + for (cnt = 0; cnt < sizeof(struct ffa_send_direct_data) / sizeof(u64); cnt++) > > + ut_assertok(((u64 *)&msg)[cnt] != 0xffffffffffffffff); > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int test_partitions_and_comms(const char *service_uuid, > > + struct sandbox_ffa_prvdata *sdx_prvdata, > > + struct unit_test_state *uts) > > +{ > > + u32 count = 0, size = 0; > > + struct ffa_partition_info *parts_info; > > + u32 info_idx, exp_info_idx; > > + int ret; > > + > > + /* > > + * get from the driver the count of the SPs matching the UUID > > + */ > > + ret = ffa_bus_ops_get()->partition_info_get(service_uuid, &count, NULL); > > + /* make sure partitions are detected */ > > + ut_assertok(ret != 0); > > + ut_assertok(count != SANDBOX_SP_COUNT_PER_VALID_SERVICE); > > + > > + /* > > + * pre-allocate a buffer to be filled by the driver > > + * with ffa_partition_info structs > > + */ > > + > > + parts_info = calloc(count, sizeof(struct ffa_partition_info)); > > + ut_assertok(!parts_info); > > + > > + size = count * sizeof(struct ffa_partition_info); > > + > > + /* > > + * ask the driver to fill the buffer with the SPs info > > + */ > > + ret = ffa_bus_ops_get()->partition_info_get(service_uuid, &size, parts_info); > > + if (ret != 0) { > > + free(parts_info); > > + ut_assertok(ret != 0); > > + } > > + > > + /* > > + * SPs found , verify the partitions information > > + */ > > + > > + ret = CMD_RET_FAILURE; > > + > > + for (info_idx = 0; info_idx < count ; info_idx++) { > > + for (exp_info_idx = 0; > > + exp_info_idx < sdx_prvdata->partitions.count; > > + exp_info_idx++) { > > + if (parts_info[info_idx].id == > > + sdx_prvdata->partitions.descs[exp_info_idx].info.id) { > > + ret = memcmp(&parts_info[info_idx], > > + &sdx_prvdata->partitions.descs[exp_info_idx] > > + .info, > > + sizeof(struct ffa_partition_info)); > > + if (ret) > > + free(parts_info); > > + ut_assertok(ret != 0); > > + /* send and receive data from the current partition */ > > + test_ffa_msg_send_direct_req(parts_info[info_idx].id, uts); > > + } > > + ret = CMD_RET_SUCCESS; > > + } > > + } > > + > > + free(parts_info); > > + > > + /* Verify expected partitions found in the emulated secure world*/ > > + ut_assertok(ret != CMD_RET_SUCCESS); > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +static int dm_test_ffa_ack(struct unit_test_state *uts) > > +{ > > + struct ffa_prvdata *prvdata = NULL; > > + struct sandbox_ffa_prvdata *sdx_prvdata = NULL; > > + struct ffa_sandbox_data func_data = {0}; > > + u8 rxbuf_flag = 0; > > + const char *svc1_uuid = SANDBOX_SERVICE1_UUID; > > + const char *svc2_uuid = SANDBOX_SERVICE2_UUID; > > + int ret; > > + > > + /* test probing FF-A devices */ > > + ut_assertok(ffa_bus_discover()); > > + > > + /* get a pointer to the FF-A core and sandbox drivers private data */ > > + func_data.data0 = &prvdata; > > + func_data.data0_size = sizeof(prvdata); > > + func_data.data1 = &sdx_prvdata; > > + func_data.data1_size = sizeof(sdx_prvdata); > > + > > + ut_assertok(sandbox_ffa_query_core_state(FFA_VERSION, &func_data)); > > + > > + /* make sure private data pointers are retrieved */ > > + ut_assertok(prvdata == 0); > > + ut_assertok(sdx_prvdata == 0); > > + > > + /* make sure dev devices created */ > > + ut_assertok(check_core_dev(prvdata, uts)); > > + ut_assertok(check_sandbox_dev(sdx_prvdata, uts)); > > + > > + /* test FFA_VERSION */ > > + ut_assertok(check_fwk_version(prvdata, sdx_prvdata, uts)); > > + > > + /* test FFA_ID_GET */ > > + ut_assertok(check_endpoint_id(prvdata, uts)); > > + > > + /* test FFA_FEATURES */ > > + ut_assertok(check_features(prvdata, uts)); > > + > > + /* test core RX/TX buffers */ > > + ut_assertok(check_rxtxbuf(prvdata, uts)); > > + > > + /* test FFA_RXTX_MAP */ > > + func_data.data0 = &rxbuf_flag; > > + func_data.data0_size = sizeof(rxbuf_flag); > > + > > + rxbuf_flag = 0; > > + ut_assertok(sandbox_ffa_query_core_state(FFA_RXTX_MAP, &func_data)); > > + ut_assertok(check_rxbuf_mapped_flag(FFA_RXTX_MAP, rxbuf_flag, uts)); > > + > > + /* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */ > > + ret = test_partitions_and_comms(svc1_uuid, sdx_prvdata, uts); > > + ut_assertok(ret != CMD_RET_SUCCESS); > > + > > + /* test FFA_RX_RELEASE */ > > + rxbuf_flag = 1; > > + ut_assertok(sandbox_ffa_query_core_state(FFA_RX_RELEASE, &func_data)); > > + ut_assertok(check_rxbuf_release_flag(rxbuf_flag, uts)); > > + > > + /* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */ > > + ret = test_partitions_and_comms(svc2_uuid, sdx_prvdata, uts); > > + ut_assertok(ret != CMD_RET_SUCCESS); > > + > > + /* test FFA_RX_RELEASE */ > > + rxbuf_flag = 1; > > + ut_assertok(sandbox_ffa_query_core_state(FFA_RX_RELEASE, &func_data)); > > + ut_assertok(check_rxbuf_release_flag(rxbuf_flag, uts)); > > + > > + /* test FFA_RXTX_UNMAP */ > > + ut_assertok(ffa_bus_ops_get()->rxtx_unmap()); > > + > > + rxbuf_flag = 1; > > + ut_assertok(sandbox_ffa_query_core_state(FFA_RXTX_UNMAP, &func_data)); > > + ut_assertok(check_rxbuf_mapped_flag(FFA_RXTX_UNMAP, rxbuf_flag, uts)); > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +DM_TEST(dm_test_ffa_ack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC); > > + > > +static int dm_test_ffa_nack(struct unit_test_state *uts) > > +{ > > + struct ffa_prvdata *prvdata = NULL; > > + struct sandbox_ffa_prvdata *sdx_prvdata = NULL; > > + struct ffa_sandbox_data func_data = {0}; > > + const char *valid_svc_uuid = SANDBOX_SERVICE1_UUID; > > + const char *unvalid_svc_uuid = SANDBOX_SERVICE3_UUID; > > + const char *unvalid_svc_uuid_str = SANDBOX_SERVICE4_UUID; > > + struct ffa_send_direct_data msg = {0}; > > + int ret; > > + u32 count = 0; > > + u16 part_id = 0; > > + > > + /* test probing FF-A devices */ > > + ut_assertok(ffa_bus_discover()); > > + > > + /* get a pointer to the FF-A core and sandbox drivers private data */ > > + func_data.data0 = &prvdata; > > + func_data.data0_size = sizeof(prvdata); > > + func_data.data1 = &sdx_prvdata; > > + func_data.data1_size = sizeof(sdx_prvdata); > > + > > + ut_assertok(sandbox_ffa_query_core_state(FFA_VERSION, &func_data)); > > + > > + /* make sure private data pointers are retrieved */ > > + ut_assertok(prvdata == 0); > > + ut_assertok(sdx_prvdata == 0); > > + > > + /* make sure dev devices created */ > > + ut_assertok(check_core_dev(prvdata, uts)); > > + ut_assertok(check_sandbox_dev(sdx_prvdata, uts)); > > + > > + /* query partitions count using invalid arguments */ > > + ret = ffa_bus_ops_get()->partition_info_get(unvalid_svc_uuid, NULL, NULL); > > + ut_assertok(ret != -EINVAL); > > + > > + /* query partitions count using an invalid UUID string */ > > + ret = ffa_bus_ops_get()->partition_info_get(unvalid_svc_uuid_str, &count, NULL); > > + ut_assertok(ret != -EINVAL); > > + > > + /* query partitions count using an invalid UUID (no matching SP) */ > > + count = 0; > > + ret = ffa_bus_ops_get()->partition_info_get(unvalid_svc_uuid, &count, NULL); > > + ut_assertok(count != 0); > > + > > + /* query partitions count using a valid UUID */ > > + count = 0; > > + ret = ffa_bus_ops_get()->partition_info_get(valid_svc_uuid, &count, NULL); > > + /* make sure partitions are detected */ > > + ut_assertok(ret != 0); > > + ut_assertok(count != SANDBOX_SP_COUNT_PER_VALID_SERVICE); > > + > > + /* send data to an invalid partition */ > > + ret = ffa_bus_ops_get()->sync_send_receive(part_id, &msg); > > + ut_assertok(ret != -EINVAL); > > + > > + /* send data to a valid partition */ > > + part_id = prvdata->partitions.descs[0].info.id; > > + ret = ffa_bus_ops_get()->sync_send_receive(part_id, &msg); > > + ut_assertok(ret != 0); > > + > > + return CMD_RET_SUCCESS; > > +} > > + > > +DM_TEST(dm_test_ffa_nack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC); > > -- > > 2.17.1 > >