diff --git a/inc/hf/api.h b/inc/hf/api.h
index 292f036..74860a3 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -30,8 +30,6 @@
 void api_regs_state_saved(struct vcpu *vcpu);
 int64_t api_mailbox_writable_get(const struct vcpu *current);
 int64_t api_mailbox_waiter_get(spci_vm_id_t vm_id, const struct vcpu *current);
-int64_t api_share_memory(spci_vm_id_t vm_id, ipaddr_t addr, size_t size,
-			 enum hf_share share, struct vcpu *current);
 int64_t api_debug_log(char c, struct vcpu *current);
 
 struct vcpu *api_preempt(struct vcpu *current);
diff --git a/inc/vmapi/hf/abi.h b/inc/vmapi/hf/abi.h
index ac6fe4b..ed004b7 100644
--- a/inc/vmapi/hf/abi.h
+++ b/inc/vmapi/hf/abi.h
@@ -30,7 +30,6 @@
 #define HF_INTERRUPT_ENABLE            0xff05
 #define HF_INTERRUPT_GET               0xff06
 #define HF_INTERRUPT_INJECT            0xff07
-#define HF_SHARE_MEMORY                0xff08
 
 /* Custom SPCI-like calls returned from SPCI_RUN. */
 #define HF_SPCI_RUN_WAIT_FOR_INTERRUPT 0xff09
@@ -40,23 +39,3 @@
 #define HF_DEBUG_LOG            0xbd000000
 
 /* clang-format on */
-
-enum hf_share {
-	/**
-	 * Relinquish ownership and access to the memory and pass them to the
-	 * recipient.
-	 */
-	HF_MEMORY_GIVE,
-
-	/**
-	 * Retain ownership of the memory but relinquish access to the
-	 * recipient.
-	 */
-	HF_MEMORY_LEND,
-
-	/**
-	 * Retain ownership and access but additionally allow access to the
-	 * recipient.
-	 */
-	HF_MEMORY_SHARE,
-};
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index 6ec1694..e9af0e7 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -257,21 +257,6 @@
 }
 
 /**
- * Shares a region of memory with another VM.
- *
- * Returns 0 on success or -1 if the sharing was not allowed or failed.
- *
- * TODO: replace this with a better API once we have decided what that should
- *       look like.
- */
-static inline int64_t hf_share_memory(spci_vm_id_t vm_id, hf_ipaddr_t addr,
-				      size_t size, enum hf_share share)
-{
-	return hf_call(HF_SHARE_MEMORY, (((uint64_t)vm_id) << 32) | share, addr,
-		       size);
-}
-
-/**
  * Sends a character to the debug log for the VM.
  *
  * Returns 0 on success, or -1 if it failed for some reason.
diff --git a/src/api.c b/src/api.c
index c748fb5..4db97dd 100644
--- a/src/api.c
+++ b/src/api.c
@@ -1581,167 +1581,6 @@
 	return ret;
 }
 
-/**
- * Shares memory from the calling VM with another. The memory can be shared in
- * different modes.
- *
- * TODO: the interface for sharing memory will need to be enhanced to allow
- *       sharing with different modes e.g. read-only, informing the recipient
- *       of the memory they have been given, opting to not wipe the memory and
- *       possibly allowing multiple blocks to be transferred. What this will
- *       look like is TBD.
- */
-int64_t api_share_memory(spci_vm_id_t vm_id, ipaddr_t addr, size_t size,
-			 enum hf_share share, struct vcpu *current)
-{
-	struct vm *from = current->vm;
-	struct vm *to;
-	uint32_t orig_from_mode;
-	uint32_t from_mode;
-	uint32_t to_mode;
-	ipaddr_t begin;
-	ipaddr_t end;
-	paddr_t pa_begin;
-	paddr_t pa_end;
-	struct mpool local_page_pool;
-	int64_t ret;
-
-	/* Disallow reflexive shares as this suggests an error in the VM. */
-	if (vm_id == from->id) {
-		return -1;
-	}
-
-	/* Ensure the target VM exists. */
-	to = vm_find(vm_id);
-	if (to == NULL) {
-		return -1;
-	}
-
-	begin = addr;
-	end = ipa_add(addr, size);
-
-	/* Fail if addresses are not page-aligned. */
-	if (!is_aligned(ipa_addr(begin), PAGE_SIZE) ||
-	    !is_aligned(ipa_addr(end), PAGE_SIZE)) {
-		return -1;
-	}
-
-	/* Convert the sharing request to memory management modes. */
-	switch (share) {
-	case HF_MEMORY_GIVE:
-		from_mode = MM_MODE_INVALID | MM_MODE_UNOWNED;
-		to_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X;
-		break;
-
-	case HF_MEMORY_LEND:
-		from_mode = MM_MODE_INVALID;
-		to_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X | MM_MODE_UNOWNED;
-		break;
-
-	case HF_MEMORY_SHARE:
-		from_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X | MM_MODE_SHARED;
-		to_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X | MM_MODE_UNOWNED |
-			  MM_MODE_SHARED;
-		break;
-
-	default:
-		/* The input is untrusted so might not be a valid value. */
-		return -1;
-	}
-
-	/*
-	 * Create a local pool so any freed memory can't be used by another
-	 * thread. This is to ensure the original mapping can be restored if any
-	 * stage of the process fails.
-	 */
-	mpool_init_with_fallback(&local_page_pool, &api_page_pool);
-
-	sl_lock_both(&from->lock, &to->lock);
-
-	/*
-	 * Ensure that the memory range is mapped with the same mode so that
-	 * changes can be reverted if the process fails.
-	 */
-	if (!mm_vm_get_mode(&from->ptable, begin, end, &orig_from_mode)) {
-		goto fail;
-	}
-
-	/* Ensure the address range is normal memory and not a device. */
-	if (orig_from_mode & MM_MODE_D) {
-		goto fail;
-	}
-
-	/*
-	 * Ensure the memory range is valid for the sender. If it isn't, the
-	 * sender has either shared it with another VM already or has no claim
-	 * to the memory.
-	 */
-	if (orig_from_mode & MM_MODE_INVALID) {
-		goto fail;
-	}
-
-	/*
-	 * The sender must own the memory and have exclusive access to it in
-	 * order to share it. Alternatively, it is giving memory back to the
-	 * owning VM.
-	 */
-	if (orig_from_mode & MM_MODE_UNOWNED) {
-		uint32_t orig_to_mode;
-
-		if (share != HF_MEMORY_GIVE ||
-		    !mm_vm_get_mode(&to->ptable, begin, end, &orig_to_mode) ||
-		    orig_to_mode & MM_MODE_UNOWNED) {
-			goto fail;
-		}
-	} else if (orig_from_mode & MM_MODE_SHARED) {
-		goto fail;
-	}
-
-	pa_begin = pa_from_ipa(begin);
-	pa_end = pa_from_ipa(end);
-
-	/*
-	 * First update the mapping for the sender so there is not overlap with
-	 * the recipient.
-	 */
-	if (!mm_vm_identity_map(&from->ptable, pa_begin, pa_end, from_mode,
-				NULL, &local_page_pool)) {
-		goto fail;
-	}
-
-	/* Clear the memory so no VM or device can see the previous contents. */
-	if (!api_clear_memory(pa_begin, pa_end, &local_page_pool)) {
-		goto fail_return_to_sender;
-	}
-
-	/* Complete the transfer by mapping the memory into the recipient. */
-	if (!mm_vm_identity_map(&to->ptable, pa_begin, pa_end, to_mode, NULL,
-				&local_page_pool)) {
-		/* TODO: partial defrag of failed range. */
-		/* Recover any memory consumed in failed mapping. */
-		mm_vm_defrag(&from->ptable, &local_page_pool);
-		goto fail_return_to_sender;
-	}
-
-	ret = 0;
-	goto out;
-
-fail_return_to_sender:
-	CHECK(mm_vm_identity_map(&from->ptable, pa_begin, pa_end,
-				 orig_from_mode, NULL, &local_page_pool));
-
-fail:
-	ret = -1;
-
-out:
-	sl_unlock(&from->lock);
-	sl_unlock(&to->lock);
-
-	mpool_fini(&local_page_pool);
-
-	return ret;
-}
-
 /** Returns the version of the implemented SPCI specification. */
 struct spci_value api_spci_version(void)
 {
diff --git a/src/arch/aarch64/hypervisor/handler.c b/src/arch/aarch64/hypervisor/handler.c
index 4852f69..0e75b97 100644
--- a/src/arch/aarch64/hypervisor/handler.c
+++ b/src/arch/aarch64/hypervisor/handler.c
@@ -485,12 +485,6 @@
 						       args.arg3, vcpu, &next);
 		break;
 
-	case HF_SHARE_MEMORY:
-		vcpu->regs.r[0] = api_share_memory(
-			args.arg1 >> 32, ipa_init(args.arg2), args.arg3,
-			args.arg1 & 0xffffffff, vcpu);
-		break;
-
 	case HF_DEBUG_LOG:
 		vcpu->regs.r[0] = api_debug_log(args.arg1, vcpu);
 		break;
diff --git a/test/vmapi/primary_with_secondaries/abort.c b/test/vmapi/primary_with_secondaries/abort.c
index e8559f8..3b6b995 100644
--- a/test/vmapi/primary_with_secondaries/abort.c
+++ b/test/vmapi/primary_with_secondaries/abort.c
@@ -44,6 +44,12 @@
 
 	SERVICE_SELECT(SERVICE_VM1, "straddling_data_abort", mb.send);
 
+	/*
+	 * First we get a message about the memory being donated to us, then we
+	 * get the abort.
+	 */
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
@@ -72,6 +78,12 @@
 
 	SERVICE_SELECT(SERVICE_VM1, "straddling_instruction_abort", mb.send);
 
+	/*
+	 * First we get a message about the memory being donated to us, then we
+	 * get the abort.
+	 */
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
diff --git a/test/vmapi/primary_with_secondaries/memory_sharing.c b/test/vmapi/primary_with_secondaries/memory_sharing.c
index 108bbb9..bbd1c92 100644
--- a/test/vmapi/primary_with_secondaries/memory_sharing.c
+++ b/test/vmapi/primary_with_secondaries/memory_sharing.c
@@ -28,30 +28,9 @@
 alignas(PAGE_SIZE) static uint8_t page[PAGE_SIZE];
 
 /**
- * Tries sharing memory in different modes with different VMs and asserts that
- * it will fail.
- */
-void check_cannot_share_memory(void *ptr, size_t size)
-{
-	uint32_t vms[] = {SERVICE_VM1, SERVICE_VM2};
-	enum hf_share modes[] = {HF_MEMORY_GIVE, HF_MEMORY_LEND,
-				 HF_MEMORY_SHARE};
-	size_t i;
-	size_t j;
-
-	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
-		for (j = 0; j < ARRAY_SIZE(modes); ++j) {
-			ASSERT_EQ(hf_share_memory(vms[i], (hf_ipaddr_t)ptr,
-						  size, modes[j]),
-				  -1);
-		}
-	}
-}
-
-/**
  * Helper function to test sending memory in the different configurations.
  */
-static void spci_check_cannot_send_memory(
+static void check_cannot_send_memory(
 	struct mailbox_buffers mb, enum spci_memory_share mode,
 	struct spci_memory_region_constituent constituents[],
 	int num_constituents, int32_t avoid_vm)
@@ -120,27 +99,27 @@
 /**
  * Helper function to test lending memory in the different configurations.
  */
-static void spci_check_cannot_lend_memory(
+static void check_cannot_lend_memory(
 	struct mailbox_buffers mb,
 	struct spci_memory_region_constituent constituents[],
 	int num_constituents, int32_t avoid_vm)
 
 {
-	spci_check_cannot_send_memory(mb, SPCI_MEMORY_LEND, constituents,
-				      num_constituents, avoid_vm);
+	check_cannot_send_memory(mb, SPCI_MEMORY_LEND, constituents,
+				 num_constituents, avoid_vm);
 }
 
 /**
  * Helper function to test sharing memory in the different configurations.
  */
-static void spci_check_cannot_share_memory(
+static void check_cannot_share_memory(
 	struct mailbox_buffers mb,
 	struct spci_memory_region_constituent constituents[],
 	int num_constituents, int32_t avoid_vm)
 
 {
-	spci_check_cannot_send_memory(mb, SPCI_MEMORY_SHARE, constituents,
-				      num_constituents, avoid_vm);
+	check_cannot_send_memory(mb, SPCI_MEMORY_SHARE, constituents,
+				 num_constituents, avoid_vm);
 }
 
 /**
@@ -148,7 +127,7 @@
  * it will fail to all except the supplied VM ID as this would succeed if it
  * is the only borrower.
  */
-static void spci_check_cannot_donate_memory(
+static void check_cannot_donate_memory(
 	struct mailbox_buffers mb,
 	struct spci_memory_region_constituent constituents[],
 	int num_constituents, int32_t avoid_vm)
@@ -178,7 +157,7 @@
  * Tries relinquishing memory with different VMs and asserts that
  * it will fail.
  */
-static void spci_check_cannot_relinquish_memory(
+static void check_cannot_relinquish_memory(
 	struct mailbox_buffers mb,
 	struct spci_memory_region_constituent constituents[],
 	int num_constituents)
@@ -201,47 +180,6 @@
 }
 
 /**
- * Device address space cannot be shared, only normal memory.
- */
-TEST(memory_sharing, cannot_share_device_memory)
-{
-	check_cannot_share_memory((void *)PAGE_SIZE, PAGE_SIZE);
-}
-
-/**
- * After memory has been shared concurrently, it can't be shared again.
- */
-TEST(memory_sharing, cannot_share_concurrent_memory_twice)
-{
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_SHARE),
-		  0);
-	check_cannot_share_memory(page, PAGE_SIZE);
-}
-
-/**
- * After memory has been given away, it can't be shared again.
- */
-TEST(memory_sharing, cannot_share_given_memory_twice)
-{
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_GIVE),
-		  0);
-	check_cannot_share_memory(page, PAGE_SIZE);
-}
-
-/**
- * After memory has been lent, it can't be shared again.
- */
-TEST(memory_sharing, cannot_share_lent_memory_twice)
-{
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
-	check_cannot_share_memory(page, PAGE_SIZE);
-}
-
-/**
  * Sharing memory concurrently gives both VMs access to the memory so it can be
  * used for communication.
  */
@@ -250,21 +188,23 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)page, .page_count = 1},
+	};
 
 	SERVICE_SELECT(SERVICE_VM1, "memory_increment", mb.send);
 
 	memset_s(ptr, sizeof(page), 'a', PAGE_SIZE);
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_SHARE),
-		  0);
 
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
+	msg_size = spci_memory_init(
+		mb.send, SPCI_MEMORY_SHARE, SERVICE_VM1, constituents,
+		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_REGION_FLAG_CLEAR,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
 
@@ -293,94 +233,28 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
-
-	SERVICE_SELECT(SERVICE_VM1, "memory_return", mb.send);
-
-	/* Dirty the memory before sharing it. */
-	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_SHARE),
-		  0);
-
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
-			  .func,
-		  SPCI_SUCCESS_32);
-
-	/* Let the memory be returned. */
-	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
-	for (int i = 0; i < PAGE_SIZE; ++i) {
-		ASSERT_EQ(ptr[i], 0);
-	}
-
-	/* Observe the service faulting when accessing the memory. */
-	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
-}
-
-/**
- * Device address space cannot be shared, only normal memory.
- */
-TEST(memory_sharing, spci_cannot_share_device_memory)
-{
-	struct mailbox_buffers mb = set_up_mailbox();
-	struct spci_memory_region_constituent constituents[] = {
-		{.address = PAGE_SIZE, .page_count = 1},
-	};
-
-	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
-	SERVICE_SELECT(SERVICE_VM2, "spci_memory_return", mb.send);
-
-	spci_check_cannot_lend_memory(mb, constituents,
-				      ARRAY_SIZE(constituents), -1);
-	spci_check_cannot_share_memory(mb, constituents,
-				       ARRAY_SIZE(constituents), -1);
-	spci_check_cannot_donate_memory(mb, constituents,
-					ARRAY_SIZE(constituents), -1);
-}
-
-/**
- * SPCI Memory given away can be given back.
- * Employing SPCI donate architected messages.
- */
-TEST(memory_sharing, spci_give_and_get_back)
-{
-	struct spci_value run_res;
-	struct mailbox_buffers mb = set_up_mailbox();
-	uint8_t *ptr = page;
 	uint32_t msg_size;
-
-	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
-
-	/* Initialise the memory before giving it. */
-	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
-
-	/* Can only donate single constituent memory region. */
 	struct spci_memory_region_constituent constituents[] = {
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	msg_size = spci_memory_donate_init(
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
+
+	/* Dirty the memory before sharing it. */
+	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
+
+	msg_size = spci_memory_share_init(
 		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
 		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
 		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
-
 	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
 				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
-	run_res = spci_run(SERVICE_VM1, 0);
 
 	/* Let the memory be returned. */
+	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
-
-	/* Ensure that the secondary VM accessed the region. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 'c');
 	}
@@ -391,9 +265,30 @@
 }
 
 /**
- * SPCI: Check that memory can be lent and is accessible by both parties.
+ * Device address space cannot be shared, only normal memory.
  */
-TEST(memory_sharing, spci_lend_relinquish)
+TEST(memory_sharing, cannot_share_device_memory)
+{
+	struct mailbox_buffers mb = set_up_mailbox();
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = PAGE_SIZE, .page_count = 1},
+	};
+
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
+	SERVICE_SELECT(SERVICE_VM2, "spci_memory_return", mb.send);
+
+	check_cannot_lend_memory(mb, constituents, ARRAY_SIZE(constituents),
+				 -1);
+	check_cannot_share_memory(mb, constituents, ARRAY_SIZE(constituents),
+				  -1);
+	check_cannot_donate_memory(mb, constituents, ARRAY_SIZE(constituents),
+				   -1);
+}
+
+/**
+ * Check that memory can be lent and is accessible by both parties.
+ */
+TEST(memory_sharing, lend_relinquish)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -441,22 +336,22 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)page, .page_count = 1},
+	};
 
-	SERVICE_SELECT(SERVICE_VM1, "memory_return", mb.send);
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
 
 	/* Dirty the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_GIVE),
-		  0);
 
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
+	msg_size = spci_memory_donate_init(
+		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
 
@@ -464,7 +359,7 @@
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	for (int i = 0; i < PAGE_SIZE; ++i) {
-		ASSERT_EQ(ptr[i], 0);
+		ASSERT_EQ(ptr[i], 'c');
 	}
 
 	/* Observe the service faulting when accessing the memory. */
@@ -480,22 +375,22 @@
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)page, .page_count = 1},
+	};
 
-	SERVICE_SELECT(SERVICE_VM1, "memory_return", mb.send);
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
 
 	/* Dirty the memory before lending it. */
 	memset_s(ptr, sizeof(page), 'c', PAGE_SIZE);
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
 
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
+	msg_size = spci_memory_lend_init(
+		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
 
@@ -503,7 +398,7 @@
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	for (int i = 0; i < PAGE_SIZE; ++i) {
-		ASSERT_EQ(ptr[i], 0);
+		ASSERT_EQ(ptr[i], 'd');
 	}
 
 	/* Observe the service faulting when accessing the memory. */
@@ -518,38 +413,41 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
-	uint8_t *ptr = page;
+	uint32_t msg_size;
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)page, .page_count = 1},
+	};
 
-	SERVICE_SELECT(SERVICE_VM1, "memory_return", mb.send);
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
 
 	/* Share the memory initially. */
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
-
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
+	msg_size = spci_memory_lend_init(
+		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	spci_rx_release();
 
 	/* Share the memory again after it has been returned. */
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
+	msg_size = spci_memory_lend_init(
+		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Observe the service doesn't fault when accessing the memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
-	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 }
 
 /**
@@ -559,22 +457,21 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
-	uint8_t *ptr = page;
+	uint32_t msg_size;
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)page, .page_count = 1},
+	};
 
-	SERVICE_SELECT(SERVICE_VM1, "memory_return", mb.send);
+	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish", mb.send);
+	SERVICE_SELECT(SERVICE_VM2, "spci_memory_lend_relinquish", mb.send);
 
 	/* Share the memory initially. */
-	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
-
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, sizeof(ptr), 0)
+	msg_size = spci_memory_lend_init(
+		mb.send, SERVICE_VM1, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
 
@@ -582,10 +479,15 @@
 	run_res = spci_run(SERVICE_VM1, 0);
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
-	/* Share the memory with a differnt VM after it has been returned. */
-	ASSERT_EQ(hf_share_memory(SERVICE_VM2, (hf_ipaddr_t)&page, PAGE_SIZE,
-				  HF_MEMORY_LEND),
-		  0);
+	/* Share the memory with a different VM after it has been returned. */
+	msg_size = spci_memory_lend_init(
+		mb.send, SERVICE_VM2, constituents, ARRAY_SIZE(constituents), 0,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM2, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Observe the service faulting when accessing the memory. */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -599,6 +501,8 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
+	struct spci_memory_region *memory_region;
+	struct spci_memory_region_constituent *constituents;
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM1, "give_memory_and_fault", mb.send);
@@ -608,7 +512,9 @@
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Check the memory was cleared. */
-	ptr = *(uint8_t **)mb.recv;
+	memory_region = spci_get_memory_region(mb.recv);
+	constituents = spci_memory_region_get_constituents(memory_region);
+	ptr = (uint8_t *)constituents[0].address;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -625,6 +531,8 @@
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
+	struct spci_memory_region *memory_region;
+	struct spci_memory_region_constituent *constituents;
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM1, "lend_memory_and_fault", mb.send);
@@ -634,7 +542,9 @@
 	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Check the memory was cleared. */
-	ptr = *(uint8_t **)mb.recv;
+	memory_region = spci_get_memory_region(mb.recv);
+	constituents = spci_memory_region_get_constituents(memory_region);
+	ptr = (uint8_t *)constituents[0].address;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -645,9 +555,9 @@
 }
 
 /**
- * SPCI: Verify past the upper bound of the donated region cannot be accessed.
+ * Verify past the upper bound of the donated region cannot be accessed.
  */
-TEST(memory_sharing, spci_donate_check_upper_bounds)
+TEST(memory_sharing, donate_check_upper_bounds)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -678,9 +588,9 @@
 }
 
 /**
- * SPCI: Verify past the lower bound of the donated region cannot be accessed.
+ * Verify past the lower bound of the donated region cannot be accessed.
  */
-TEST(memory_sharing, spci_donate_check_lower_bounds)
+TEST(memory_sharing, donate_check_lower_bounds)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -711,10 +621,10 @@
 }
 
 /**
- * SPCI: After memory has been returned, it is free to be shared with another
+ * After memory has been returned, it is free to be shared with another
  * VM.
  */
-TEST(memory_sharing, spci_donate_elsewhere_after_return)
+TEST(memory_sharing, donate_elsewhere_after_return)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -761,10 +671,10 @@
 }
 
 /**
- * SPCI: Check if memory can be donated between secondary VMs.
+ * Check if memory can be donated between secondary VMs.
  * Ensure that the memory can no longer be accessed by the first VM.
  */
-TEST(memory_sharing, spci_donate_vms)
+TEST(memory_sharing, donate_vms)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -813,9 +723,9 @@
 }
 
 /**
- * SPCI: Check that memory is unable to be donated to multiple parties.
+ * Check that memory is unable to be donated to multiple parties.
  */
-TEST(memory_sharing, spci_donate_twice)
+TEST(memory_sharing, donate_twice)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -847,15 +757,15 @@
 	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Fail to share memory again with any VM. */
-	spci_check_cannot_share_memory(mb, constituents,
-				       ARRAY_SIZE(constituents), -1);
-	spci_check_cannot_lend_memory(mb, constituents,
-				      ARRAY_SIZE(constituents), -1);
-	spci_check_cannot_donate_memory(mb, constituents,
-					ARRAY_SIZE(constituents), -1);
+	check_cannot_share_memory(mb, constituents, ARRAY_SIZE(constituents),
+				  -1);
+	check_cannot_lend_memory(mb, constituents, ARRAY_SIZE(constituents),
+				 -1);
+	check_cannot_donate_memory(mb, constituents, ARRAY_SIZE(constituents),
+				   -1);
 	/* Fail to relinquish memory from any VM. */
-	spci_check_cannot_relinquish_memory(mb, constituents,
-					    ARRAY_SIZE(constituents));
+	check_cannot_relinquish_memory(mb, constituents,
+				       ARRAY_SIZE(constituents));
 
 	/* Let the memory be sent from VM1 to PRIMARY (returned). */
 	run_res = spci_run(SERVICE_VM1, 0);
@@ -870,9 +780,9 @@
 }
 
 /**
- * SPCI: Check cannot donate to self.
+ * Check cannot donate to self.
  */
-TEST(memory_sharing, spci_donate_to_self)
+TEST(memory_sharing, donate_to_self)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
@@ -896,9 +806,9 @@
 }
 
 /**
- * SPCI: Check cannot lend to self.
+ * Check cannot lend to self.
  */
-TEST(memory_sharing, spci_lend_to_self)
+TEST(memory_sharing, lend_to_self)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
@@ -921,9 +831,9 @@
 }
 
 /**
- * SPCI: Check cannot share to self.
+ * Check cannot share to self.
  */
-TEST(memory_sharing, spci_share_to_self)
+TEST(memory_sharing, share_to_self)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
@@ -946,9 +856,9 @@
 }
 
 /**
- * SPCI: Check cannot donate from alternative VM.
+ * Check cannot donate from alternative VM.
  */
-TEST(memory_sharing, spci_donate_invalid_source)
+TEST(memory_sharing, donate_invalid_source)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1010,9 +920,9 @@
 }
 
 /**
- * SPCI: Check that unaligned addresses can not be shared.
+ * Check that unaligned addresses can not be shared.
  */
-TEST(memory_sharing, spci_give_and_get_back_unaligned)
+TEST(memory_sharing, give_and_get_back_unaligned)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 
@@ -1044,9 +954,9 @@
 }
 
 /**
- * SPCI: Check cannot lend from alternative VM.
+ * Check cannot lend from alternative VM.
  */
-TEST(memory_sharing, spci_lend_invalid_source)
+TEST(memory_sharing, lend_invalid_source)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1090,10 +1000,10 @@
 }
 
 /**
- * SPCI: Memory can be lent with executable permissions.
+ * Memory can be lent with executable permissions.
  * Check RO and RW permissions.
  */
-TEST(memory_sharing, spci_lend_relinquish_X_RW)
+TEST(memory_sharing, lend_relinquish_X_RW)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1150,10 +1060,10 @@
 }
 
 /**
- * SPCI: Memory can be shared with executable permissions.
+ * Memory can be shared with executable permissions.
  * Check RO and RW permissions.
  */
-TEST(memory_sharing, spci_share_relinquish_X_RW)
+TEST(memory_sharing, share_relinquish_X_RW)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1222,10 +1132,10 @@
 }
 
 /**
- * SPCI: Memory can be shared without executable permissions.
+ * Memory can be shared without executable permissions.
  * Check RO and RW permissions.
  */
-TEST(memory_sharing, spci_share_relinquish_NX_RW)
+TEST(memory_sharing, share_relinquish_NX_RW)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1293,9 +1203,9 @@
 }
 
 /**
- * SPCI: Exercise execution permissions for lending memory.
+ * Exercise execution permissions for lending memory.
  */
-TEST(memory_sharing, spci_lend_relinquish_RW_X)
+TEST(memory_sharing, lend_relinquish_RW_X)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1343,9 +1253,9 @@
 }
 
 /**
- * SPCI: Exercise execution permissions for lending memory without write access.
+ * Exercise execution permissions for lending memory without write access.
  */
-TEST(memory_sharing, spci_lend_relinquish_RO_X)
+TEST(memory_sharing, lend_relinquish_RO_X)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1393,9 +1303,9 @@
 }
 
 /**
- * SPCI: Memory can be lent, but then no part can be donated.
+ * Memory can be lent, but then no part can be donated.
  */
-TEST(memory_sharing, spci_lend_donate)
+TEST(memory_sharing, lend_donate)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1453,9 +1363,9 @@
 }
 
 /**
- * SPCI: Memory can be shared, but then no part can be donated.
+ * Memory can be shared, but then no part can be donated.
  */
-TEST(memory_sharing, spci_share_donate)
+TEST(memory_sharing, share_donate)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1487,8 +1397,8 @@
 	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Attempt to share the same area of memory. */
-	spci_check_cannot_share_memory(mb, constituents,
-				       ARRAY_SIZE(constituents), SERVICE_VM1);
+	check_cannot_share_memory(mb, constituents, ARRAY_SIZE(constituents),
+				  SERVICE_VM1);
 
 	/* Ensure we can't donate any sub section of memory to another VM. */
 	constituents[0].page_count = 1;
@@ -1517,9 +1427,9 @@
 }
 
 /**
- * SPCI: Memory can be lent, but then no part can be lent again.
+ * Memory can be lent, but then no part can be lent again.
  */
-TEST(memory_sharing, spci_lend_twice)
+TEST(memory_sharing, lend_twice)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1551,17 +1461,17 @@
 	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Attempt to lend the same area of memory. */
-	spci_check_cannot_lend_memory(mb, constituents,
-				      ARRAY_SIZE(constituents), -1);
+	check_cannot_lend_memory(mb, constituents, ARRAY_SIZE(constituents),
+				 -1);
 	/* Attempt to share the same area of memory. */
-	spci_check_cannot_share_memory(mb, constituents,
-				       ARRAY_SIZE(constituents), -1);
+	check_cannot_share_memory(mb, constituents, ARRAY_SIZE(constituents),
+				  -1);
 	/* Fail to donate to VM apart from VM1. */
-	spci_check_cannot_donate_memory(mb, constituents,
-					ARRAY_SIZE(constituents), SERVICE_VM1);
+	check_cannot_donate_memory(mb, constituents, ARRAY_SIZE(constituents),
+				   SERVICE_VM1);
 	/* Fail to relinquish from any VM. */
-	spci_check_cannot_relinquish_memory(mb, constituents,
-					    ARRAY_SIZE(constituents));
+	check_cannot_relinquish_memory(mb, constituents,
+				       ARRAY_SIZE(constituents));
 
 	/* Attempt to lend again with different permissions. */
 	constituents[0].page_count = 1;
@@ -1580,9 +1490,9 @@
 }
 
 /**
- * SPCI: Memory can be shared, but then no part can be shared again.
+ * Memory can be shared, but then no part can be shared again.
  */
-TEST(memory_sharing, spci_share_twice)
+TEST(memory_sharing, share_twice)
 {
 	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
@@ -1617,16 +1527,16 @@
 	 * Attempting to share or lend the same area of memory with any VM
 	 * should fail.
 	 */
-	spci_check_cannot_share_memory(mb, constituents,
-				       ARRAY_SIZE(constituents), -1);
-	spci_check_cannot_lend_memory(mb, constituents,
-				      ARRAY_SIZE(constituents), -1);
+	check_cannot_share_memory(mb, constituents, ARRAY_SIZE(constituents),
+				  -1);
+	check_cannot_lend_memory(mb, constituents, ARRAY_SIZE(constituents),
+				 -1);
 	/* Fail to donate to VM apart from VM1. */
-	spci_check_cannot_donate_memory(mb, constituents,
-					ARRAY_SIZE(constituents), SERVICE_VM1);
+	check_cannot_donate_memory(mb, constituents, ARRAY_SIZE(constituents),
+				   SERVICE_VM1);
 	/* Fail to relinquish from any VM. */
-	spci_check_cannot_relinquish_memory(mb, constituents,
-					    ARRAY_SIZE(constituents));
+	check_cannot_relinquish_memory(mb, constituents,
+				       ARRAY_SIZE(constituents));
 
 	/* Attempt to share again with different permissions. */
 	constituents[0].page_count = 1;
@@ -1645,9 +1555,9 @@
 }
 
 /**
- * SPCI: Memory can be cleared while being shared.
+ * Memory can be cleared while being shared.
  */
-TEST(memory_sharing, spci_share_clear)
+TEST(memory_sharing, share_clear)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
diff --git a/test/vmapi/primary_with_secondaries/services/abort.c b/test/vmapi/primary_with_secondaries/services/abort.c
index 3d11bd2..a4c445e 100644
--- a/test/vmapi/primary_with_secondaries/services/abort.c
+++ b/test/vmapi/primary_with_secondaries/services/abort.c
@@ -32,11 +32,21 @@
 
 TEST_SERVICE(straddling_data_abort)
 {
+	void *send_buf = SERVICE_SEND_BUFFER();
 	/* Give some memory to the primary VM so that it's unmapped. */
-	ASSERT_EQ(hf_share_memory(HF_PRIMARY_VM_ID,
-				  (hf_ipaddr_t)(&pages[PAGE_SIZE]), PAGE_SIZE,
-				  HF_MEMORY_GIVE),
-		  0);
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)(&pages[PAGE_SIZE]), .page_count = 1},
+	};
+	uint32_t msg_size = spci_memory_donate_init(
+		send_buf, HF_PRIMARY_VM_ID, constituents,
+		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X,
+		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+		SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
+
 	*(volatile uint64_t *)(&pages[PAGE_SIZE - 6]);
 }
 
@@ -49,6 +59,8 @@
 
 TEST_SERVICE(straddling_instruction_abort)
 {
+	void *send_buf = SERVICE_SEND_BUFFER();
+
 	/*
 	 * Get a function pointer which, when branched to, will attempt to
 	 * execute a 4-byte instruction straddling two pages.
@@ -56,10 +68,18 @@
 	int (*f)(void) = (int (*)(void))(&pages[PAGE_SIZE - 2]);
 
 	/* Give second page to the primary VM so that it's unmapped. */
-	ASSERT_EQ(hf_share_memory(HF_PRIMARY_VM_ID,
-				  (hf_ipaddr_t)(&pages[PAGE_SIZE]), PAGE_SIZE,
-				  HF_MEMORY_GIVE),
-		  0);
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)(&pages[PAGE_SIZE]), .page_count = 1},
+	};
+	uint32_t msg_size = spci_memory_donate_init(
+		send_buf, HF_PRIMARY_VM_ID, constituents,
+		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_RW_X,
+		SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
+		SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Branch to instruction whose 2 bytes are now in an unmapped page. */
 	f();
diff --git a/test/vmapi/primary_with_secondaries/services/memory.c b/test/vmapi/primary_with_secondaries/services/memory.c
index dc076c2..b573a58 100644
--- a/test/vmapi/primary_with_secondaries/services/memory.c
+++ b/test/vmapi/primary_with_secondaries/services/memory.c
@@ -32,13 +32,19 @@
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 		size_t i;
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		struct spci_memory_region *memory_region =
+			spci_get_memory_region(recv_buf);
+		struct spci_memory_region_constituent *constituents =
+			spci_memory_region_get_constituents(memory_region);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
+
+		ptr = (uint8_t *)constituents[0].address;
 
 		/* Check the memory was cleared. */
-		void *recv_buf = SERVICE_RECV_BUFFER();
-		ptr = *(uint8_t **)recv_buf;
-
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ASSERT_EQ(ptr[i], 0);
 		}
@@ -78,19 +84,18 @@
 			spci_memory_region_get_constituents(memory_region);
 
 		ptr = (uint8_t *)constituents[0].address;
-		/* Relevant information read, mailbox can be cleared. */
-		spci_rx_release();
 
 		/* Check that one has access to the shared region. */
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ptr[i]++;
 		}
 
-		spci_rx_release();
 		/* Give the memory back and notify the sender. */
 		msg_size = spci_memory_relinquish_init(
 			send_buf, HF_PRIMARY_VM_ID, constituents,
 			memory_region->constituent_count, 0);
+		/* Relevant information read, RX mailbox can be cleared. */
+		spci_rx_release();
 		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
 			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
 
@@ -102,60 +107,23 @@
 	}
 }
 
-TEST_SERVICE(memory_return)
-{
-	/* Loop, giving memory back to the sender. */
-	for (;;) {
-		struct spci_value ret = spci_msg_wait();
-		uint8_t *ptr;
-
-		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
-
-		/* Check the memory was cleared. */
-		void *recv_buf = SERVICE_RECV_BUFFER();
-		ptr = *(uint8_t **)recv_buf;
-
-		for (int i = 0; i < PAGE_SIZE; ++i) {
-			ASSERT_EQ(ptr[i], 0);
-		}
-
-		/* Give the memory back and notify the sender. */
-		ASSERT_EQ(hf_share_memory(spci_msg_send_sender(ret),
-					  (hf_ipaddr_t)ptr, PAGE_SIZE,
-					  HF_MEMORY_GIVE),
-			  0);
-		spci_rx_release();
-		spci_msg_send(hf_vm_get_id(), spci_msg_send_sender(ret),
-			      sizeof(ptr), 0);
-
-		/*
-		 * Try and access the memory which will cause a fault unless the
-		 * memory has been shared back again.
-		 */
-		ptr[0] = 123;
-	}
-}
-
 TEST_SERVICE(give_memory_and_fault)
 {
-	uint8_t *ptr = page;
+	void *send_buf = SERVICE_SEND_BUFFER();
 
 	/* Give memory to the primary. */
-	ASSERT_EQ(hf_share_memory(HF_PRIMARY_VM_ID, (hf_ipaddr_t)&page,
-				  PAGE_SIZE, HF_MEMORY_GIVE),
-		  0);
-
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, &ptr,
-		 sizeof(ptr));
-	EXPECT_EQ(
-		spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ptr), 0)
-			.func,
-		SPCI_SUCCESS_32);
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)&page, .page_count = 1},
+	};
+	uint32_t msg_size = spci_memory_init(
+		send_buf, SPCI_MEMORY_DONATE, HF_PRIMARY_VM_ID, constituents,
+		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_REGION_FLAG_CLEAR,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Try using the memory that isn't valid unless it's been returned. */
 	page[16] = 123;
@@ -163,24 +131,21 @@
 
 TEST_SERVICE(lend_memory_and_fault)
 {
-	uint8_t *ptr = page;
+	void *send_buf = SERVICE_SEND_BUFFER();
 
 	/* Lend memory to the primary. */
-	ASSERT_EQ(hf_share_memory(HF_PRIMARY_VM_ID, (hf_ipaddr_t)&page,
-				  PAGE_SIZE, HF_MEMORY_LEND),
-		  0);
-
-	/*
-	 * TODO: the address of the memory will be part of the proper API. That
-	 *       API is still to be agreed on so the address is passed
-	 *       explicitly to test the mechanism.
-	 */
-	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, &ptr,
-		 sizeof(ptr));
-	EXPECT_EQ(
-		spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ptr), 0)
-			.func,
-		SPCI_SUCCESS_32);
+	struct spci_memory_region_constituent constituents[] = {
+		{.address = (uint64_t)&page, .page_count = 1},
+	};
+	uint32_t msg_size = spci_memory_init(
+		send_buf, SPCI_MEMORY_LEND, HF_PRIMARY_VM_ID, constituents,
+		ARRAY_SIZE(constituents), 0, SPCI_MEMORY_REGION_FLAG_CLEAR,
+		SPCI_MEMORY_RW_X, SPCI_MEMORY_NORMAL_MEM,
+		SPCI_MEMORY_CACHE_WRITE_BACK, SPCI_MEMORY_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Try using the memory that isn't valid unless it's been returned. */
 	page[633] = 180;
@@ -195,16 +160,16 @@
 		uint32_t msg_size;
 		void *recv_buf = SERVICE_RECV_BUFFER();
 		void *send_buf = SERVICE_SEND_BUFFER();
-		struct spci_memory_region *memory_region =
-			spci_get_memory_region(recv_buf);
-		struct spci_memory_region_constituent *constituents =
-			spci_memory_region_get_constituents(memory_region);
+		struct spci_memory_region *memory_region;
+		struct spci_memory_region_constituent *constituents;
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		EXPECT_EQ(spci_msg_send_attributes(ret),
 			  SPCI_MSG_SEND_LEGACY_MEMORY);
-		spci_rx_release();
 
+		memory_region = spci_get_memory_region(recv_buf);
+		constituents =
+			spci_memory_region_get_constituents(memory_region);
 		ptr = (uint8_t *)constituents[0].address;
 
 		/* Check that one has access to the shared region. */
@@ -218,8 +183,12 @@
 			memory_region->constituent_count, 0, SPCI_MEMORY_RW_X,
 			SPCI_MEMORY_NORMAL_MEM, SPCI_MEMORY_CACHE_WRITE_BACK,
 			SPCI_MEMORY_OUTER_SHAREABLE);
-		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
-			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
+		spci_rx_release();
+		EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret),
+					spci_msg_send_sender(ret), msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY)
+				  .func,
+			  SPCI_SUCCESS_32);
 
 		/*
 		 * Try and access the memory which will cause a fault unless the
@@ -234,17 +203,17 @@
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 	void *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_memory_region *memory_region =
-		spci_get_memory_region(recv_buf);
-	struct spci_memory_region_constituent *constituents =
-		spci_memory_region_get_constituents(memory_region);
+	struct spci_memory_region *memory_region;
+	struct spci_memory_region_constituent *constituents;
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
-	spci_rx_release();
-
+	memory_region = spci_get_memory_region(recv_buf);
+	constituents = spci_memory_region_get_constituents(memory_region);
 	ptr = (uint8_t *)constituents[0].address;
 
+	spci_rx_release();
+
 	/* Check that one cannot access out of bounds after donated region. */
 	ptr[PAGE_SIZE]++;
 }
@@ -254,23 +223,23 @@
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 	void *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_memory_region *memory_region =
-		spci_get_memory_region(recv_buf);
-	struct spci_memory_region_constituent *constituents =
-		spci_memory_region_get_constituents(memory_region);
+	struct spci_memory_region *memory_region;
+	struct spci_memory_region_constituent *constituents;
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
-	spci_rx_release();
-
+	memory_region = spci_get_memory_region(recv_buf);
+	constituents = spci_memory_region_get_constituents(memory_region);
 	ptr = (uint8_t *)constituents[0].address;
 
+	spci_rx_release();
+
 	/* Check that one cannot access out of bounds before donated region. */
 	ptr[-1]++;
 }
 
 /**
- * SPCI: Attempt to donate memory and then modify.
+ * Attempt to donate memory and then modify.
  */
 TEST_SERVICE(spci_donate_secondary_and_fault)
 {
@@ -308,7 +277,7 @@
 }
 
 /**
- * SPCI: Attempt to donate memory twice from VM.
+ * Attempt to donate memory twice from VM.
  */
 TEST_SERVICE(spci_donate_twice)
 {
@@ -354,8 +323,8 @@
 }
 
 /**
- * SPCI: Continually receive memory, check if we have access
- * and ensure it is not changed by a third party.
+ * Continually receive memory, check if we have access and ensure it is not
+ * changed by a third party.
  */
 TEST_SERVICE(spci_memory_receive)
 {
@@ -384,7 +353,7 @@
 }
 
 /**
- * SPCI: Receive memory and attempt to donate from primary VM.
+ * Receive memory and attempt to donate from primary VM.
  */
 TEST_SERVICE(spci_donate_invalid_source)
 {
@@ -443,21 +412,23 @@
 		EXPECT_EQ(spci_msg_send_attributes(ret),
 			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		ptr = (uint8_t *)constituents[0].address;
-		/* Relevant information read, mailbox can be cleared. */
-		spci_rx_release();
 
 		/* Check that one has access to the shared region. */
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ptr[i]++;
 		}
 
-		spci_rx_release();
 		/* Give the memory back and notify the sender. */
 		msg_size = spci_memory_relinquish_init(
 			send_buf, HF_PRIMARY_VM_ID, constituents,
 			memory_region->constituent_count, 0);
-		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
-			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
+		/* Relevant information read, mailbox can be cleared. */
+		spci_rx_release();
+		EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret),
+					spci_msg_send_sender(ret), msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY)
+				  .func,
+			  SPCI_SUCCESS_32);
 
 		/*
 		 * Try and access the memory which will cause a fault unless the
@@ -468,7 +439,7 @@
 }
 
 /**
- * SPCI: Ensure that we can't relinquish donated memory.
+ * Ensure that we can't relinquish donated memory.
  */
 TEST_SERVICE(spci_memory_donate_relinquish)
 {
@@ -512,7 +483,7 @@
 }
 
 /**
- * SPCI: Receive memory and attempt to donate from primary VM.
+ * Receive memory and attempt to donate from primary VM.
  */
 TEST_SERVICE(spci_lend_invalid_source)
 {
@@ -572,7 +543,7 @@
 }
 
 /**
- * SPCI: Attempt to execute an instruction from the lent memory.
+ * Attempt to execute an instruction from the lent memory.
  */
 TEST_SERVICE(spci_memory_lend_relinquish_X)
 {
@@ -615,7 +586,7 @@
 }
 
 /**
- * SPCI: Attempt to read and write to a shared page.
+ * Attempt to read and write to a shared page.
  */
 TEST_SERVICE(spci_memory_lend_relinquish_RW)
 {
@@ -663,7 +634,7 @@
 }
 
 /**
- * SPCI: Attempt to modify below the lower bound for the lent memory.
+ * Attempt to modify below the lower bound for the lent memory.
  */
 TEST_SERVICE(spci_lend_check_lower_bound)
 {
@@ -687,7 +658,7 @@
 }
 
 /**
- * SPCI: Attempt to modify above the upper bound for the lent memory.
+ * Attempt to modify above the upper bound for the lent memory.
  */
 TEST_SERVICE(spci_lend_check_upper_bound)
 {