diff --git a/include/runtime_services/host_realm_managment/host_realm_helper.h b/include/runtime_services/host_realm_managment/host_realm_helper.h
index 6886a09..1bfc70f 100644
--- a/include/runtime_services/host_realm_managment/host_realm_helper.h
+++ b/include/runtime_services/host_realm_managment/host_realm_helper.h
@@ -10,21 +10,22 @@
 #include <host_realm_rmi.h>
 #include <tftf_lib.h>
 
-bool host_create_realm_payload(u_register_t realm_payload_adr,
+bool host_create_realm_payload(struct realm *realm_ptr,
+		u_register_t realm_payload_adr,
 		u_register_t plat_mem_pool_adr,
 		u_register_t plat_mem_pool_size,
 		u_register_t realm_pages_size,
 		u_register_t feature_flag,
 		const u_register_t *rec_flag,
 		unsigned int rec_count);
-bool host_create_shared_mem(
+bool host_create_shared_mem(struct realm *realm_ptr,
 		u_register_t ns_shared_mem_adr,
 		u_register_t ns_shared_mem_size);
-bool host_destroy_realm(void);
-void host_rec_send_sgi(unsigned int sgi, unsigned int rec_num);
-bool host_enter_realm_execute(uint8_t cmd, struct realm **realm_ptr,
-			      unsigned int test_exit_reason,
-			      unsigned int rec_num);
+bool host_destroy_realm(struct realm *realm_ptr);
+void host_rec_send_sgi(struct realm *realm_ptr,
+		unsigned int sgi, unsigned int rec_num);
+bool host_enter_realm_execute(struct realm *realm_ptr, uint8_t cmd,
+		int test_exit_reason, unsigned int rec_num);
 test_result_t host_cmp_result(void);
 void realm_print_handler(unsigned int rec_num);
 
diff --git a/include/runtime_services/host_realm_managment/host_realm_rmi.h b/include/runtime_services/host_realm_managment/host_realm_rmi.h
index d60e15e..ac6a6f1 100644
--- a/include/runtime_services/host_realm_managment/host_realm_rmi.h
+++ b/include/runtime_services/host_realm_managment/host_realm_rmi.h
@@ -503,25 +503,28 @@
 };
 
 struct realm {
-	unsigned int rec_count;
-	u_register_t par_base;
-	u_register_t par_size;
-	u_register_t rd;
-	u_register_t rtt_addr;
-	u_register_t rec[MAX_REC_COUNT];
-	u_register_t run[MAX_REC_COUNT];
-	u_register_t rec_flag[MAX_REC_COUNT];
-	u_register_t mpidr[MAX_REC_COUNT];
-	u_register_t host_mpidr[MAX_REC_COUNT];
-	u_register_t num_aux;
-	u_register_t rmm_feat_reg0;
-	u_register_t ipa_ns_buffer;
-	u_register_t ns_buffer_size;
-	u_register_t aux_pages_all_rec[MAX_REC_COUNT][REC_PARAMS_AUX_GRANULES];
-	uint8_t      sve_vl;
-	uint8_t      num_bps;
-	uint8_t      num_wps;
-	uint8_t      pmu_num_ctrs;
+	unsigned int     rec_count;
+	u_register_t     par_base;
+	u_register_t     par_size;
+	u_register_t     rd;
+	u_register_t     rtt_addr;
+	u_register_t     rec[MAX_REC_COUNT];
+	u_register_t     run[MAX_REC_COUNT];
+	u_register_t     rec_flag[MAX_REC_COUNT];
+	u_register_t     mpidr[MAX_REC_COUNT];
+	u_register_t     host_mpidr[MAX_REC_COUNT];
+	u_register_t     num_aux;
+	u_register_t     rmm_feat_reg0;
+	u_register_t     ipa_ns_buffer;
+	u_register_t     ns_buffer_size;
+	u_register_t     aux_pages_all_rec[MAX_REC_COUNT][REC_PARAMS_AUX_GRANULES];
+	uint8_t          sve_vl;
+	uint8_t          num_bps;
+	uint8_t          num_wps;
+	uint8_t          pmu_num_ctrs;
+	bool             payload_created;
+	bool             shared_mem_created;
+	unsigned short   vmid;
 	enum realm_state state;
 };
 
diff --git a/realm/realm_rsi.c b/realm/realm_rsi.c
index d82aa6f..ba60ba8 100644
--- a/realm/realm_rsi.c
+++ b/realm/realm_rsi.c
@@ -11,8 +11,6 @@
 #include <realm_rsi.h>
 #include <smccc.h>
 
-static struct rsi_host_call host_cal __aligned(sizeof(struct rsi_host_call));
-
 /* This function return RSI_ABI_VERSION */
 u_register_t rsi_get_version(u_register_t req_ver)
 {
@@ -32,6 +30,7 @@
 u_register_t rsi_get_ns_buffer(void)
 {
 	smc_ret_values res = {};
+	struct rsi_host_call host_cal __aligned(sizeof(struct rsi_host_call));
 
 	host_cal.imm = HOST_CALL_GET_SHARED_BUFF_CMD;
 	res = tftf_smc(&(smc_args) {RSI_HOST_CALL, (u_register_t)&host_cal,
@@ -45,6 +44,8 @@
 /* This function call Host and request to exit Realm with proper exit code */
 void rsi_exit_to_host(enum host_call_cmd exit_code)
 {
+	struct rsi_host_call host_cal __aligned(sizeof(struct rsi_host_call));
+
 	host_cal.imm = exit_code;
 	host_cal.gprs[0] = read_mpidr_el1() & MPID_MASK;
 	tftf_smc(&(smc_args) {RSI_HOST_CALL, (u_register_t)&host_cal,
diff --git a/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c b/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
index 1ba67ed..9a4f5d9 100644
--- a/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
+++ b/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
@@ -23,11 +23,6 @@
 #include <test_helpers.h>
 #include <xlat_tables_v2.h>
 
-static struct realm realm;
-static bool realm_payload_created;
-static bool shared_mem_created;
-static volatile bool timer_enabled;
-
 #define RMI_EXIT(id)	\
 	[RMI_EXIT_##id] = #id
 
@@ -71,32 +66,34 @@
  * and try to find another CPU other than the lead one to
  * handle the Realm message logging.
  */
-static void host_init_realm_print_buffer(void)
+static void host_init_realm_print_buffer(struct realm *realm_ptr)
 {
 	host_shared_data_t *host_shared_data;
 
-	for (unsigned int i = 0U; i < realm.rec_count; i++) {
+	for (unsigned int i = 0U; i < realm_ptr->rec_count; i++) {
 		host_shared_data = host_get_shared_structure(i);
 		(void)memset((char *)host_shared_data, 0, sizeof(host_shared_data_t));
 	}
 }
 
-static bool host_enter_realm(u_register_t *exit_reason,
-		unsigned int *host_call_result, unsigned int rec_num)
+static bool host_enter_realm(struct realm *realm_ptr,
+			     u_register_t *exit_reason,
+			     unsigned int *host_call_result,
+			     unsigned int rec_num)
 {
 	u_register_t ret;
 
-	if (!realm_payload_created) {
-		ERROR("%s() failed\n", "realm_payload_created");
+	if (!realm_ptr->payload_created) {
+		ERROR("%s() failed\n", "payload_created");
 		return false;
 	}
-	if (!shared_mem_created) {
+	if (!realm_ptr->shared_mem_created) {
 		ERROR("%s() failed\n", "shared_mem_created");
 		return false;
 	}
 
 	/* Enter Realm */
-	ret = host_realm_rec_enter(&realm, exit_reason, host_call_result, rec_num);
+	ret = host_realm_rec_enter(realm_ptr, exit_reason, host_call_result, rec_num);
 	if (ret != REALM_SUCCESS) {
 		ERROR("%s() failed, ret=%lx\n", "host_realm_rec_enter", ret);
 		return false;
@@ -105,13 +102,14 @@
 	return true;
 }
 
-bool host_create_realm_payload(u_register_t realm_payload_adr,
-				u_register_t plat_mem_pool_adr,
-				u_register_t plat_mem_pool_size,
-				u_register_t realm_pages_size,
-				u_register_t feature_flag,
-				const u_register_t *rec_flag,
-				unsigned int rec_count)
+bool host_create_realm_payload(struct realm *realm_ptr,
+			       u_register_t realm_payload_adr,
+			       u_register_t plat_mem_pool_adr,
+			       u_register_t plat_mem_pool_size,
+			       u_register_t realm_pages_size,
+			       u_register_t feature_flag,
+			       const u_register_t *rec_flag,
+			       unsigned int rec_count)
 {
 	int8_t value;
 
@@ -135,73 +133,74 @@
 		ERROR("%s() failed\n", "page_pool_init");
 		return false;
 	}
+	memset((char *)realm_ptr, 0U, sizeof(struct realm));
 
 	/* Read Realm Feature Reg 0 */
-	if (host_rmi_features(0UL, &realm.rmm_feat_reg0) != REALM_SUCCESS) {
+	if (host_rmi_features(0UL, &realm_ptr->rmm_feat_reg0) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_rmi_features");
 		return false;
 	}
 
 	/* Disable PMU if not required */
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_PMU_EN) == 0UL) {
-		realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_PMU_EN;
-		realm.pmu_num_ctrs = 0U;
+		realm_ptr->rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_PMU_EN;
+		realm_ptr->pmu_num_ctrs = 0U;
 	} else {
 		value = EXTRACT(FEATURE_PMU_NUM_CTRS, feature_flag);
 		if (value != -1) {
-			realm.pmu_num_ctrs = (unsigned int)value;
+			realm_ptr->pmu_num_ctrs = (unsigned int)value;
 		} else {
-			realm.pmu_num_ctrs =
+			realm_ptr->pmu_num_ctrs =
 				EXTRACT(RMI_FEATURE_REGISTER_0_PMU_NUM_CTRS,
-					realm.rmm_feat_reg0);
+					realm_ptr->rmm_feat_reg0);
 		}
 	}
 
 	/* Disable SVE if not required */
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) == 0UL) {
-		realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_SVE_EN;
-		realm.sve_vl = 0U;
+		realm_ptr->rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_SVE_EN;
+		realm_ptr->sve_vl = 0U;
 	} else {
-		realm.sve_vl = EXTRACT(FEATURE_SVE_VL, feature_flag);
+		realm_ptr->sve_vl = EXTRACT(FEATURE_SVE_VL, feature_flag);
 	}
 
 	/* Requested number of breakpoints */
 	value = EXTRACT(FEATURE_NUM_BPS, feature_flag);
 	if (value != -1) {
-		realm.num_bps = (unsigned int)value;
+		realm_ptr->num_bps = (unsigned int)value;
 	} else {
-		realm.num_bps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_BPS,
-					realm.rmm_feat_reg0);
+		realm_ptr->num_bps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_BPS,
+					realm_ptr->rmm_feat_reg0);
 	}
 
 	/* Requested number of watchpoints */
 	value = EXTRACT(FEATURE_NUM_WPS, feature_flag);
 	if (value != -1) {
-		realm.num_wps = (unsigned int)value;
+		realm_ptr->num_wps = (unsigned int)value;
 	} else {
-		realm.num_wps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_WPS,
-					realm.rmm_feat_reg0);
+		realm_ptr->num_wps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_WPS,
+					realm_ptr->rmm_feat_reg0);
 	}
 
 	/* Set SVE bits from feature_flag */
-	realm.rmm_feat_reg0 &= ~(RMI_FEATURE_REGISTER_0_SVE_EN |
+	realm_ptr->rmm_feat_reg0 &= ~(RMI_FEATURE_REGISTER_0_SVE_EN |
 				 MASK(RMI_FEATURE_REGISTER_0_SVE_VL));
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) != 0UL) {
-		realm.rmm_feat_reg0 |= RMI_FEATURE_REGISTER_0_SVE_EN |
+		realm_ptr->rmm_feat_reg0 |= RMI_FEATURE_REGISTER_0_SVE_EN |
 				       INPLACE(RMI_FEATURE_REGISTER_0_SVE_VL,
 				       EXTRACT(RMI_FEATURE_REGISTER_0_SVE_VL,
 						feature_flag));
 	}
 
-	if (realm.rec_count > MAX_REC_COUNT) {
+	if (realm_ptr->rec_count > MAX_REC_COUNT) {
 		ERROR("Invalid Rec Count\n");
 		return false;
 	}
-	realm.rec_count = rec_count;
+	realm_ptr->rec_count = rec_count;
 	for (unsigned int i = 0U; i < rec_count; i++) {
 		if (rec_flag[i] == RMI_RUNNABLE ||
 				rec_flag[i] == RMI_NOT_RUNNABLE) {
-			realm.rec_flag[i] = rec_flag[i];
+			realm_ptr->rec_flag[i] = rec_flag[i];
 		} else {
 			ERROR("Invalid Rec Flag\n");
 			return false;
@@ -209,84 +208,85 @@
 	}
 
 	/* Create Realm */
-	if (host_realm_create(&realm) != REALM_SUCCESS) {
+	if (host_realm_create(realm_ptr) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_create");
 		return false;
 	}
 
-	if (host_realm_init_ipa_state(&realm, 0U, 0U, 1ULL << 32)
+	if (host_realm_init_ipa_state(realm_ptr, 0U, 0U, 1ULL << 32)
 		!= RMI_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_init_ipa_state");
 		goto destroy_realm;
 	}
 
 	/* RTT map Realm image */
-	if (host_realm_map_payload_image(&realm, realm_payload_adr) !=
+	if (host_realm_map_payload_image(realm_ptr, realm_payload_adr) !=
 			REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_map_payload_image");
 		goto destroy_realm;
 	}
 
 	/* Create REC */
-	if (host_realm_rec_create(&realm) != REALM_SUCCESS) {
+	if (host_realm_rec_create(realm_ptr) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_rec_create");
 		goto destroy_realm;
 	}
 
 	/* Activate Realm */
-	if (host_realm_activate(&realm) != REALM_SUCCESS) {
+	if (host_realm_activate(realm_ptr) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_activate");
 		goto destroy_realm;
 	}
 
-	realm_payload_created = true;
+	realm_ptr->payload_created = true;
 
-	return realm_payload_created;
+	return true;
 
 	/* Free test resources */
 destroy_realm:
-	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
+	if (host_realm_destroy(realm_ptr) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_destroy");
 	}
-	realm_payload_created = false;
+	realm_ptr->payload_created = false;
 
-	return realm_payload_created;
+	return false;
 }
 
-bool host_create_shared_mem(u_register_t ns_shared_mem_adr,
-	u_register_t ns_shared_mem_size)
+bool host_create_shared_mem(struct realm *realm_ptr,
+			    u_register_t ns_shared_mem_adr,
+			    u_register_t ns_shared_mem_size)
 {
 	/* RTT map NS shared region */
-	if (host_realm_map_ns_shared(&realm, ns_shared_mem_adr,
+	if (host_realm_map_ns_shared(realm_ptr, ns_shared_mem_adr,
 				ns_shared_mem_size) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_map_ns_shared");
-		shared_mem_created = false;
+		realm_ptr->shared_mem_created = false;
 		return false;
 	}
 
 	memset((void *)ns_shared_mem_adr, 0, (size_t)ns_shared_mem_size);
-	host_init_realm_print_buffer();
-	shared_mem_created = true;
+	host_init_realm_print_buffer(realm_ptr);
+	realm_ptr->shared_mem_created = true;
 
-	return shared_mem_created;
+	return true;
 }
 
-bool host_destroy_realm(void)
+bool host_destroy_realm(struct realm *realm_ptr)
 {
 	/* Free test resources */
-	timer_enabled = false;
 	page_pool_reset();
 
-	if (!realm_payload_created) {
-		ERROR("%s() failed\n", "realm_payload_created");
+	if (!realm_ptr->payload_created) {
+		ERROR("%s() failed\n", "payload_created");
 		return false;
 	}
 
-	realm_payload_created = false;
-	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
+	realm_ptr->payload_created = false;
+	if (host_realm_destroy(realm_ptr) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_destroy");
 		return false;
 	}
+	memset((char *)realm_ptr, 0U, sizeof(struct realm));
 
 	return true;
 }
@@ -301,30 +301,32 @@
  *	       TEST_RESULT_SUCCESS.
  *	false: On error.
  */
-bool host_enter_realm_execute(uint8_t cmd, struct realm **realm_ptr,
-			      unsigned int test_exit_reason,
+bool host_enter_realm_execute(struct realm *realm_ptr,
+			      uint8_t cmd,
+			      int test_exit_reason,
 			      unsigned int rec_num)
 {
 	u_register_t realm_exit_reason = RMI_EXIT_INVALID;
 	unsigned int host_call_result = TEST_RESULT_FAIL;
 
+	if (realm_ptr == NULL || realm_ptr->payload_created == false) {
+		return false;
+	}
+
 	if (test_exit_reason >= RMI_EXIT_INVALID) {
 		ERROR("Invalid RmiRecExitReason\n");
 		return false;
 	}
 
-	if (rec_num >= realm.rec_count) {
+	if (rec_num >= realm_ptr->rec_count) {
 		ERROR("Invalid Rec Count\n");
 		return false;
 	}
 	host_shared_data_set_realm_cmd(cmd, rec_num);
-	if (!host_enter_realm(&realm_exit_reason, &host_call_result, rec_num)) {
+	if (!host_enter_realm(realm_ptr, &realm_exit_reason, &host_call_result, rec_num)) {
 		return false;
 	}
 
-	if (realm_ptr != NULL) {
-		*realm_ptr = &realm;
-	}
 
 	if (test_exit_reason == realm_exit_reason) {
 		if (realm_exit_reason != RMI_EXIT_HOST_CALL) {
@@ -365,10 +367,11 @@
  * Returns Host core position for specified Rec
  * Host mpidr is saved on every rec enter
  */
-static unsigned int host_realm_find_core_pos_by_rec(unsigned int rec_num)
+static unsigned int host_realm_find_core_pos_by_rec(struct realm *realm_ptr,
+		unsigned int rec_num)
 {
-	if (rec_num < MAX_REC_COUNT && realm.run[rec_num] != 0U) {
-		return platform_get_core_pos(realm.host_mpidr[rec_num]);
+	if (rec_num < MAX_REC_COUNT && realm_ptr->run[rec_num] != 0U) {
+		return platform_get_core_pos(realm_ptr->host_mpidr[rec_num]);
 	}
 	return (unsigned int)-1;
 }
@@ -377,9 +380,11 @@
  * Send SGI on core running specified Rec
  * API can be used to forcefully exit from Realm
  */
-void host_rec_send_sgi(unsigned int sgi, unsigned int rec_num)
+void host_rec_send_sgi(struct realm *realm_ptr,
+		       unsigned int sgi,
+		       unsigned int rec_num)
 {
-	unsigned int core_pos = host_realm_find_core_pos_by_rec(rec_num);
+	unsigned int core_pos = host_realm_find_core_pos_by_rec(realm_ptr, rec_num);
 	if (core_pos < PLATFORM_CORE_COUNT) {
 		tftf_send_sgi(sgi, core_pos);
 	}
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
index 916e848..4df9005 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
@@ -20,6 +20,8 @@
 #include <host_shared_data.h>
 
 static uint64_t is_secondary_cpu_on;
+static struct realm realm;
+
 /*
  * Test tries to create max Rec
  * Enters all Rec from single CPU
@@ -32,7 +34,7 @@
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -40,21 +42,21 @@
 			0UL, rec_flag, MAX_REC_COUNT)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
 	for (unsigned int i = 0; i < MAX_REC_COUNT; i++) {
 		host_shared_data_set_host_val(i, HOST_ARG1_INDEX, 10U);
-		ret1 = host_enter_realm_execute(REALM_SLEEP_CMD, NULL,
+		ret1 = host_enter_realm_execute(&realm, REALM_SLEEP_CMD,
 				RMI_EXIT_HOST_CALL, i);
 		if (!ret1) {
 			break;
 		}
 	}
 
-	ret2 = host_destroy_realm();
+	ret2 = host_destroy_realm(&realm);
 
 	if (!ret1 || !ret2) {
 		ERROR("%s(): enter=%d destroy=%d\n",
@@ -79,7 +81,6 @@
  */
 test_result_t host_realm_multi_rec_psci_denied(void)
 {
-	struct realm *realm_ptr;
 	bool ret1, ret2;
 	u_register_t ret;
 	unsigned int host_call_result;
@@ -91,7 +92,7 @@
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -99,28 +100,28 @@
 			0UL, rec_flag, 3U)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
-	ret1 = host_enter_realm_execute(REALM_MULTIPLE_REC_PSCI_DENIED_CMD, &realm_ptr,
+	ret1 = host_enter_realm_execute(&realm, REALM_MULTIPLE_REC_PSCI_DENIED_CMD,
 			RMI_EXIT_PSCI, 0U);
-	run = (struct rmi_rec_run *)realm_ptr->run[0];
+	run = (struct rmi_rec_run *)realm.run[0];
 
 	if (run->exit.gprs[0] != SMC_PSCI_CPU_ON_AARCH64) {
 		ERROR("Host did not receive CPU ON request\n");
 		ret1 = false;
 		goto destroy_realm;
 	}
-	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], realm_ptr);
+	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], &realm);
 	if (rec_num != 1U) {
 		ERROR("Invalid mpidr requested\n");
 		ret1 = false;
 		goto destroy_realm;
 	}
 	INFO("Requesting PSCI Complete Status Denied REC %d\n", rec_num);
-	ret = host_rmi_psci_complete(realm_ptr->rec[0], realm_ptr->rec[rec_num],
+	ret = host_rmi_psci_complete(realm.rec[0], realm.rec[rec_num],
 			(unsigned long)PSCI_E_DENIED);
 	if (ret != RMI_SUCCESS) {
 		ERROR("host_rmi_psci_complete failed\n");
@@ -129,27 +130,27 @@
 	}
 
 	/* Enter rec1, should fail */
-	ret = host_realm_rec_enter(realm_ptr, &exit_reason, &host_call_result, 1U);
+	ret = host_realm_rec_enter(&realm, &exit_reason, &host_call_result, 1U);
 	if (ret == RMI_SUCCESS) {
 		ERROR("Rec1 enter should have failed\n");
 		ret1 = false;
 		goto destroy_realm;
 	}
-	ret = host_realm_rec_enter(realm_ptr, &exit_reason, &host_call_result, 0U);
+	ret = host_realm_rec_enter(&realm, &exit_reason, &host_call_result, 0U);
 
 	if (run->exit.gprs[0] != SMC_PSCI_AFFINITY_INFO_AARCH64) {
 		ERROR("Host did not receive PSCI_AFFINITY_INFO request\n");
 		ret1 = false;
 		goto destroy_realm;
 	}
-	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], realm_ptr);
+	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], &realm);
 	if (rec_num != 1U) {
 		ERROR("Invalid mpidr requested\n");
 		goto destroy_realm;
 	}
 
 	INFO("Requesting PSCI Complete Affinity Info REC %d\n", rec_num);
-	ret = host_rmi_psci_complete(realm_ptr->rec[0], realm_ptr->rec[rec_num],
+	ret = host_rmi_psci_complete(realm.rec[0], realm.rec[rec_num],
 			(unsigned long)PSCI_E_SUCCESS);
 	if (ret != RMI_SUCCESS) {
 		ERROR("host_rmi_psci_complete failed\n");
@@ -158,7 +159,7 @@
 	}
 
 	/* Re-enter REC0 complete PSCI_AFFINITY_INFO */
-	ret = host_realm_rec_enter(realm_ptr, &exit_reason, &host_call_result, 0U);
+	ret = host_realm_rec_enter(&realm, &exit_reason, &host_call_result, 0U);
 
 
 	if (run->exit.gprs[0] != SMC_PSCI_CPU_ON_AARCH64) {
@@ -166,7 +167,7 @@
 		ret1 = false;
 		goto destroy_realm;
 	}
-	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], realm_ptr);
+	rec_num = host_realm_find_rec_by_mpidr(run->exit.gprs[1], &realm);
 	if (rec_num != 2U) {
 		ERROR("Invalid mpidr requested\n");
 		ret1 = false;
@@ -175,7 +176,7 @@
 
 	INFO("Requesting PSCI Complete Status Denied REC %d\n", rec_num);
 	/* PSCI_DENIED should fail as rec2 is RMI_RUNNABLE */
-	ret = host_rmi_psci_complete(realm_ptr->rec[0], realm_ptr->rec[rec_num],
+	ret = host_rmi_psci_complete(realm.rec[0], realm.rec[rec_num],
 			(unsigned long)PSCI_E_DENIED);
 	if (ret == RMI_SUCCESS) {
 		ret1 = false;
@@ -183,7 +184,7 @@
 		goto destroy_realm;
 	}
 
-	ret = host_realm_rec_enter(realm_ptr, &exit_reason, &host_call_result, 0U);
+	ret = host_realm_rec_enter(&realm, &exit_reason, &host_call_result, 0U);
 	if (ret != RMI_SUCCESS) {
 		ERROR("Rec0 re-enter failed\n");
 		ret1 = false;
@@ -191,7 +192,7 @@
 	}
 
 destroy_realm:
-	ret2 = host_destroy_realm();
+	ret2 = host_destroy_realm(&realm);
 
 	if (!ret1 || !ret2) {
 		ERROR("%s(): enter=%d destroy=%d\n",
@@ -213,7 +214,8 @@
 	is_secondary_cpu_on++;
 	spin_unlock(&secondary_cpu_lock);
 
-	ret = host_enter_realm_execute(REALM_LOOP_CMD, NULL, RMI_EXIT_IRQ, is_secondary_cpu_on);
+	ret = host_enter_realm_execute(&realm, REALM_LOOP_CMD,
+			RMI_EXIT_IRQ, is_secondary_cpu_on);
 	if (!ret) {
 		return TEST_RESULT_FAIL;
 	}
@@ -233,7 +235,7 @@
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 	SKIP_TEST_IF_LESS_THAN_N_CPUS(rec_count);
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -241,14 +243,14 @@
 			0UL, rec_flag, rec_count)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
 	is_secondary_cpu_on = 0U;
 	my_mpidr = read_mpidr_el1() & MPID_MASK;
-	ret1 = host_enter_realm_execute(REALM_GET_RSI_VERSION, NULL, RMI_EXIT_HOST_CALL, 0U);
+	ret1 = host_enter_realm_execute(&realm, REALM_GET_RSI_VERSION, RMI_EXIT_HOST_CALL, 0U);
 	for_each_cpu(cpu_node) {
 		other_mpidr = tftf_get_mpidr_from_node(cpu_node);
 		if (other_mpidr == my_mpidr) {
@@ -270,10 +272,10 @@
 	tftf_irq_enable(IRQ_NS_SGI_7, GIC_HIGHEST_NS_PRIORITY);
 	for (unsigned int i = 1U; i < rec_count; i++) {
 		INFO("Raising NS IRQ for rec %d\n", i);
-		host_rec_send_sgi(IRQ_NS_SGI_7, i);
+		host_rec_send_sgi(&realm, IRQ_NS_SGI_7, i);
 	}
 	tftf_irq_disable(IRQ_NS_SGI_7);
-	ret2 = host_destroy_realm();
+	ret2 = host_destroy_realm(&realm);
 	if (!ret1 || !ret2) {
 		ERROR("%s(): enter=%d destroy=%d\n",
 		__func__, ret1, ret2);
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
index 3528319..b6ea5d4 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
@@ -66,6 +66,8 @@
 static fpu_cs_regs_t ns_fpu_cs_regs_write;
 static fpu_cs_regs_t ns_fpu_cs_regs_read;
 
+static struct realm realm;
+
 /* Skip test if SVE is not supported in H/W or in RMI features */
 #define CHECK_SVE_SUPPORT_IN_HW_AND_IN_RMI(_reg0)				\
 	do {									\
@@ -97,7 +99,8 @@
 	}
 
 	/* Initialise Realm payload */
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm,
+				       (u_register_t)REALM_IMAGE_BASE,
 				       (u_register_t)PAGE_POOL_BASE,
 				       (u_register_t)(PAGE_POOL_MAX_SIZE +
 						      NS_REALM_SHARED_MEM_SIZE),
@@ -107,7 +110,7 @@
 	}
 
 	/* Create shared memory between Host and Realm */
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 				    NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
@@ -170,7 +173,7 @@
 		return TEST_RESULT_FAIL;
 	}
 
-	realm_rc = host_enter_realm_execute(REALM_SVE_RDVL, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SVE_RDVL,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (realm_rc != true) {
 		rc = TEST_RESULT_FAIL;
@@ -191,7 +194,7 @@
 	}
 
 rm_realm:
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -218,7 +221,7 @@
 	rc = host_create_sve_realm_payload(true, (sve_vq + 1));
 	if (rc == TEST_RESULT_SUCCESS) {
 		ERROR("Error: Realm created with invalid SVE VL %u\n", (sve_vq + 1));
-		host_destroy_realm();
+		host_destroy_realm(&realm);
 		return TEST_RESULT_FAIL;
 	}
 
@@ -246,7 +249,7 @@
 		return rc;
 	}
 
-	realm_rc = host_enter_realm_execute(REALM_SVE_ID_REGISTERS, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SVE_ID_REGISTERS,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		rc = TEST_RESULT_FAIL;
@@ -280,7 +283,7 @@
 	}
 
 rm_realm:
-	host_destroy_realm();
+	host_destroy_realm(&realm);
 	return rc;
 }
 
@@ -333,7 +336,7 @@
 	 */
 	vl_bitmap_expected = sve_probe_vl(sve_vq);
 
-	realm_rc = host_enter_realm_execute(REALM_SVE_PROBE_VL, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SVE_PROBE_VL,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		rc = TEST_RESULT_FAIL;
@@ -356,7 +359,7 @@
 	}
 
 rm_realm:
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -394,7 +397,7 @@
 		ns_zcr_el2 = read_zcr_el2();
 
 		/* Call Realm to run SVE command */
-		realm_rc = host_enter_realm_execute(REALM_SVE_RDVL, NULL,
+		realm_rc = host_enter_realm_execute(&realm, REALM_SVE_RDVL,
 						    RMI_EXIT_HOST_CALL, 0U);
 		if (!realm_rc) {
 			ERROR("Realm command REALM_SVE_RDVL failed\n");
@@ -410,7 +413,7 @@
 		}
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -427,7 +430,7 @@
 static bool callback_realm_do_sve(void)
 {
 
-	return !host_enter_realm_execute(REALM_SVE_OPS, NULL,
+	return !host_enter_realm_execute(&realm, REALM_SVE_OPS,
 					 RMI_EXIT_HOST_CALL, 0U);
 }
 
@@ -440,7 +443,7 @@
  */
 static bool callback_realm_do_fpu(void)
 {
-	return !host_enter_realm_execute(REALM_REQ_FPU_FILL_CMD, NULL,
+	return !host_enter_realm_execute(&realm, REALM_REQ_FPU_FILL_CMD,
 					 RMI_EXIT_HOST_CALL, 0U);
 }
 
@@ -507,7 +510,7 @@
 	}
 
 rm_realm:
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -622,7 +625,7 @@
 	}
 
 	/* 4. Call Realm to fill in Z registers */
-	realm_rc = host_enter_realm_execute(REALM_SVE_FILL_REGS, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SVE_FILL_REGS,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		rc = TEST_RESULT_FAIL;
@@ -648,7 +651,7 @@
 	}
 
 rm_realm:
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -672,7 +675,7 @@
 		return rc;
 	}
 
-	realm_rc = host_enter_realm_execute(REALM_SVE_UNDEF_ABORT, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SVE_UNDEF_ABORT,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		ERROR("Realm didn't receive undefined abort\n");
@@ -681,7 +684,7 @@
 		rc = TEST_RESULT_SUCCESS;
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -1007,7 +1010,7 @@
 		rl_fill_cmd = REALM_REQ_FPU_FILL_CMD;
 	}
 
-	rc = host_enter_realm_execute(rl_fill_cmd, NULL, RMI_EXIT_HOST_CALL, 0U);
+	rc = host_enter_realm_execute(&realm, rl_fill_cmd, RMI_EXIT_HOST_CALL, 0U);
 	assert(rc);
 
 	return type;
@@ -1025,7 +1028,7 @@
 		rl_cmp_cmd = REALM_REQ_FPU_CMP_CMD;
 	}
 
-	return host_enter_realm_execute(rl_cmp_cmd, NULL, RMI_EXIT_HOST_CALL,
+	return host_enter_realm_execute(&realm, rl_cmp_cmd, RMI_EXIT_HOST_CALL,
 					0U);
 }
 
@@ -1171,7 +1174,7 @@
 		tftf_smc_set_sve_hint(false);
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
@@ -1197,7 +1200,7 @@
 		return rc;
 	}
 
-	realm_rc = host_enter_realm_execute(REALM_SME_ID_REGISTERS, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SME_ID_REGISTERS,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		rc = TEST_RESULT_FAIL;
@@ -1220,7 +1223,7 @@
 	}
 
 rm_realm:
-	host_destroy_realm();
+	host_destroy_realm(&realm);
 	return rc;
 }
 
@@ -1240,7 +1243,7 @@
 		return rc;
 	}
 
-	realm_rc = host_enter_realm_execute(REALM_SME_UNDEF_ABORT, NULL,
+	realm_rc = host_enter_realm_execute(&realm, REALM_SME_UNDEF_ABORT,
 					    RMI_EXIT_HOST_CALL, 0U);
 	if (!realm_rc) {
 		ERROR("Realm didn't receive undefined abort\n");
@@ -1249,7 +1252,7 @@
 		rc = TEST_RESULT_SUCCESS;
 	}
 
-	host_destroy_realm();
+	host_destroy_realm(&realm);
 	return rc;
 }
 
@@ -1318,13 +1321,12 @@
 		 * SVE support, so run SVE command else run FPU command
 		 */
 		if (sve_en) {
-			realm_rc = host_enter_realm_execute(REALM_SVE_RDVL, NULL,
+			realm_rc = host_enter_realm_execute(&realm, REALM_SVE_RDVL,
 							    RMI_EXIT_HOST_CALL,
 							    0U);
 		} else {
-			realm_rc = host_enter_realm_execute(
+			realm_rc = host_enter_realm_execute(&realm,
 							REALM_REQ_FPU_FILL_CMD,
-							NULL,
 							RMI_EXIT_HOST_CALL, 0U);
 		}
 
@@ -1357,7 +1359,7 @@
 		sme_smstop(SMSTOP_SM);
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		return TEST_RESULT_FAIL;
 	}
 
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
index f2d1861..0c3349d 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
@@ -25,36 +25,39 @@
 extern const char *rmi_exit[];
 
 /*
- * @Test_Aim@ Test realm payload creation and execution
+ * @Test_Aim@ Test realm payload creation, execution and destruction  iteratively
  */
 test_result_t host_test_realm_create_enter(void)
 {
 	bool ret1, ret2;
 	u_register_t rec_flag[1] = {RMI_RUNNABLE};
+	struct realm realm;
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
-			(u_register_t)PAGE_POOL_BASE,
-			(u_register_t)(PAGE_POOL_MAX_SIZE +
-			NS_REALM_SHARED_MEM_SIZE),
-			(u_register_t)PAGE_POOL_MAX_SIZE,
-			0UL, rec_flag, 1U)) {
-		return TEST_RESULT_FAIL;
-	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
-			NS_REALM_SHARED_MEM_SIZE)) {
-		return TEST_RESULT_FAIL;
-	}
+	for (unsigned int i = 0U; i < 5U; i++) {
+		if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
+				(u_register_t)PAGE_POOL_BASE,
+				(u_register_t)(PAGE_POOL_MAX_SIZE +
+				NS_REALM_SHARED_MEM_SIZE),
+				(u_register_t)PAGE_POOL_MAX_SIZE,
+				0UL, rec_flag, 1U)) {
+			return TEST_RESULT_FAIL;
+		}
+		if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
+				NS_REALM_SHARED_MEM_SIZE)) {
+			return TEST_RESULT_FAIL;
+		}
 
-	host_shared_data_set_host_val(0U, HOST_ARG1_INDEX, SLEEP_TIME_MS);
-	ret1 = host_enter_realm_execute(REALM_SLEEP_CMD, NULL, RMI_EXIT_HOST_CALL, 0U);
-	ret2 = host_destroy_realm();
+		host_shared_data_set_host_val(0U, HOST_ARG1_INDEX, SLEEP_TIME_MS);
+		ret1 = host_enter_realm_execute(&realm, REALM_SLEEP_CMD, RMI_EXIT_HOST_CALL, 0U);
+		ret2 = host_destroy_realm(&realm);
 
-	if (!ret1 || !ret2) {
-		ERROR("%s(): enter=%d destroy=%d\n",
-		__func__, ret1, ret2);
-		return TEST_RESULT_FAIL;
+		if (!ret1 || !ret2) {
+			ERROR("%s(): enter=%d destroy=%d\n",
+			__func__, ret1, ret2);
+			return TEST_RESULT_FAIL;
+		}
 	}
 
 	return host_cmp_result();
@@ -67,10 +70,11 @@
 {
 	bool ret1, ret2;
 	u_register_t rec_flag[] = {RMI_RUNNABLE};
+	struct realm realm;
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -78,13 +82,13 @@
 			0UL, rec_flag, 1U)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
-	ret1 = host_enter_realm_execute(REALM_GET_RSI_VERSION, NULL, RMI_EXIT_HOST_CALL, 0U);
-	ret2 = host_destroy_realm();
+	ret1 = host_enter_realm_execute(&realm, REALM_GET_RSI_VERSION, RMI_EXIT_HOST_CALL, 0U);
+	ret2 = host_destroy_realm(&realm);
 
 	if (!ret1 || !ret2) {
 		ERROR("%s(): enter=%d destroy=%d\n",
@@ -105,11 +109,12 @@
 #else
 	bool ret1, ret2;
 	u_register_t rec_flag[1] = {RMI_RUNNABLE};
+	struct realm realm;
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
 
 	pauth_test_lib_fill_regs_and_template();
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 				(u_register_t)PAGE_POOL_BASE,
 				(u_register_t)(PAGE_POOL_MAX_SIZE +
 					NS_REALM_SHARED_MEM_SIZE),
@@ -118,20 +123,20 @@
 		return TEST_RESULT_FAIL;
 	}
 
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 				NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
-	ret1 = host_enter_realm_execute(REALM_PAUTH_SET_CMD, NULL, RMI_EXIT_HOST_CALL, 0U);
+	ret1 = host_enter_realm_execute(&realm, REALM_PAUTH_SET_CMD, RMI_EXIT_HOST_CALL, 0U);
 
 	if (ret1) {
 		/* Re-enter Realm to compare PAuth registers. */
-		ret1 = host_enter_realm_execute(REALM_PAUTH_CHECK_CMD, NULL,
+		ret1 = host_enter_realm_execute(&realm, REALM_PAUTH_CHECK_CMD,
 				RMI_EXIT_HOST_CALL, 0U);
 	}
 
-	ret2 = host_destroy_realm();
+	ret2 = host_destroy_realm(&realm);
 
 	if (!ret1) {
 		ERROR("%s(): enter=%d destroy=%d\n",
@@ -160,9 +165,10 @@
 #else
 	bool ret1, ret2;
 	u_register_t rec_flag[1] = {RMI_RUNNABLE};
+	struct realm realm;
 
 	SKIP_TEST_IF_RME_NOT_SUPPORTED_OR_RMM_IS_TRP();
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 				(u_register_t)PAGE_POOL_BASE,
 				(u_register_t)(PAGE_POOL_MAX_SIZE +
 					NS_REALM_SHARED_MEM_SIZE),
@@ -170,13 +176,13 @@
 				0UL, rec_flag, 1U)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 				NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
-	ret1 = host_enter_realm_execute(REALM_PAUTH_FAULT, NULL, RMI_EXIT_HOST_CALL, 0U);
-	ret2 = host_destroy_realm();
+	ret1 = host_enter_realm_execute(&realm, REALM_PAUTH_FAULT, RMI_EXIT_HOST_CALL, 0U);
+	ret2 = host_destroy_realm(&realm);
 
 	if (!ret1) {
 		ERROR("%s(): enter=%d destroy=%d\n",
@@ -248,7 +254,7 @@
  */
 static test_result_t host_test_realm_pmuv3(uint8_t cmd)
 {
-	struct realm *realm_ptr;
+	struct realm realm;
 	u_register_t feature_flag;
 	u_register_t rec_flag[1] = {RMI_RUNNABLE};
 	bool ret1, ret2;
@@ -260,7 +266,7 @@
 	feature_flag = RMI_FEATURE_REGISTER_0_PMU_EN |
 			INPLACE(FEATURE_PMU_NUM_CTRS, (unsigned long long)(-1));
 
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -268,22 +274,22 @@
 			feature_flag, rec_flag, 1U)) {
 		return TEST_RESULT_FAIL;
 	}
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
 
-	ret1 = host_enter_realm_execute(cmd, &realm_ptr,
+	ret1 = host_enter_realm_execute(&realm, cmd,
 					(cmd == REALM_PMU_INTERRUPT) ?
 					RMI_EXIT_IRQ : RMI_EXIT_HOST_CALL, 0U);
 	if (!ret1 || (cmd != REALM_PMU_INTERRUPT)) {
 		goto test_exit;
 	}
 
-	ret1 = host_realm_handle_irq_exit(realm_ptr, 0U);
+	ret1 = host_realm_handle_irq_exit(&realm, 0U);
 
 test_exit:
-	ret2 = host_destroy_realm();
+	ret2 = host_destroy_realm(&realm);
 	if (!ret1 || !ret2) {
 		ERROR("%s() enter=%u destroy=%u\n", __func__, ret1, ret2);
 		return TEST_RESULT_FAIL;
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_spm.c b/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
index a187584..6001113 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
@@ -25,6 +25,7 @@
 
 static fpu_state_t ns_fpu_state_write;
 static fpu_state_t ns_fpu_state_read;
+static struct realm realm;
 
 typedef enum security_state {
 	NONSECURE_WORLD = 0U,
@@ -55,7 +56,7 @@
 	/*
 	 * Initialise Realm payload
 	 */
-	if (!host_create_realm_payload((u_register_t)REALM_IMAGE_BASE,
+	if (!host_create_realm_payload(&realm, (u_register_t)REALM_IMAGE_BASE,
 			(u_register_t)PAGE_POOL_BASE,
 			(u_register_t)(PAGE_POOL_MAX_SIZE +
 			NS_REALM_SHARED_MEM_SIZE),
@@ -66,7 +67,7 @@
 	/*
 	 * Create shared memory between Host and Realm
 	 */
-	if (!host_create_shared_mem(NS_REALM_SHARED_MEM_BASE,
+	if (!host_create_shared_mem(&realm, NS_REALM_SHARED_MEM_BASE,
 			NS_REALM_SHARED_MEM_SIZE)) {
 		return TEST_RESULT_FAIL;
 	}
@@ -120,7 +121,7 @@
 /* Send request to Realm to fill FPU/SIMD regs with realm template values */
 static bool fpu_fill_rl(void)
 {
-	if (!host_enter_realm_execute(REALM_REQ_FPU_FILL_CMD, NULL, RMI_EXIT_HOST_CALL, 0U)) {
+	if (!host_enter_realm_execute(&realm, REALM_REQ_FPU_FILL_CMD, RMI_EXIT_HOST_CALL, 0U)) {
 		ERROR("%s failed %d\n", __func__, __LINE__);
 		return false;
 	}
@@ -130,7 +131,7 @@
 /* Send request to Realm to compare FPU/SIMD regs with previous realm template values */
 static bool fpu_cmp_rl(void)
 {
-	if (!host_enter_realm_execute(REALM_REQ_FPU_CMP_CMD, NULL, RMI_EXIT_HOST_CALL, 0U)) {
+	if (!host_enter_realm_execute(&realm, REALM_REQ_FPU_CMP_CMD, RMI_EXIT_HOST_CALL, 0U)) {
 		ERROR("%s failed %d\n", __func__, __LINE__);
 		return false;
 	}
@@ -180,7 +181,6 @@
  */
 test_result_t host_realm_sec_interrupt_can_preempt_rl(void)
 {
-	struct realm *realm_ptr;
 	struct ffa_value ret_values;
 	test_result_t res;
 
@@ -220,12 +220,12 @@
 	 * timer triggers during this time.
 	 */
 	host_shared_data_set_host_val(0U, HOST_ARG1_INDEX, REALM_TIME_SLEEP);
-	host_enter_realm_execute(REALM_SLEEP_CMD, &realm_ptr, RMI_EXIT_FIQ, 0U);
+	host_enter_realm_execute(&realm, REALM_SLEEP_CMD, RMI_EXIT_FIQ, 0U);
 
 	/*
 	 * Check if Realm exit reason is FIQ.
 	 */
-	if (!host_realm_handle_fiq_exit(realm_ptr, 0U)) {
+	if (!host_realm_handle_fiq_exit(&realm, 0U)) {
 		ERROR("Trusted watchdog timer interrupt not fired\n");
 		goto destroy_realm;
 	}
@@ -250,7 +250,7 @@
 		goto destroy_realm;
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		ERROR("host_destroy_realm error\n");
 		return TEST_RESULT_FAIL;
 	}
@@ -258,7 +258,7 @@
 	return TEST_RESULT_SUCCESS;
 
 destroy_realm:
-	host_destroy_realm();
+	host_destroy_realm(&realm);
 	return TEST_RESULT_FAIL;
 }
 
@@ -404,12 +404,12 @@
 		}
 	}
 
-	if (!host_destroy_realm()) {
+	if (!host_destroy_realm(&realm)) {
 		ERROR("host_destroy_realm error\n");
 		return TEST_RESULT_FAIL;
 	}
 	return TEST_RESULT_SUCCESS;
 destroy_realm:
-	host_destroy_realm();
+	host_destroy_realm(&realm);
 	return TEST_RESULT_FAIL;
 }