diff --git a/.vscode/settings.json b/.vscode/settings.json
index b85c5f5..88f2c18 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -15,7 +15,8 @@
         "spinlock.h": "c",
         "offsets.h": "c",
         "barriers.h": "c",
-        "spci.h": "c"
+        "spci.h": "c",
+        "spci_internal.h": "c"
     },
     "C_Cpp.errorSquiggles": "Disabled"
 }
diff --git a/driver/linux b/driver/linux
index b331fa9..cafe017 160000
--- a/driver/linux
+++ b/driver/linux
@@ -1 +1 @@
-Subproject commit b331fa985153f8184530a4758ef289dd16923448
+Subproject commit cafe017d8863e5326c3f1c660ce71d5a82da7b19
diff --git a/inc/hf/api.h b/inc/hf/api.h
index ebc6b20..8c6328c 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -54,14 +54,15 @@
 			     spci_vcpu_index_t target_vcpu_idx, uint32_t intid,
 			     struct vcpu *current, struct vcpu **next);
 
-spci_return_t api_spci_msg_send(uint32_t attributes, struct vcpu *current,
-				struct vcpu **next);
+struct spci_value api_spci_msg_send(spci_vm_id_t sender_vm_id,
+				    spci_vm_id_t receiver_vm_id, uint32_t size,
+				    uint32_t attributes, struct vcpu *current,
+				    struct vcpu **next);
 struct spci_value api_spci_msg_recv(bool block, struct vcpu *current,
 				    struct vcpu **next);
 void api_yield(struct vcpu *current, struct vcpu **next);
 struct spci_value api_spci_version(void);
-spci_return_t api_spci_share_memory(struct vm_locked to_locked,
-				    struct vm_locked from_locked,
-				    struct spci_memory_region *memory_region,
-				    uint32_t memory_to_attributes,
-				    enum spci_memory_share share);
+struct spci_value api_spci_share_memory(
+	struct vm_locked to_locked, struct vm_locked from_locked,
+	struct spci_memory_region *memory_region, uint32_t memory_to_attributes,
+	enum spci_memory_share share);
diff --git a/inc/hf/spci_internal.h b/inc/hf/spci_internal.h
index 8f2a500..e046233 100644
--- a/inc/hf/spci_internal.h
+++ b/inc/hf/spci_internal.h
@@ -68,11 +68,11 @@
 	return (struct spci_value){.func = SPCI_ERROR_32, .arg1 = error_code};
 }
 
-spci_return_t spci_msg_handle_architected_message(
+struct spci_value spci_msg_handle_architected_message(
 	struct vm_locked to_locked, struct vm_locked from_locked,
 	const struct spci_architected_message_header
 		*architected_message_replica,
-	struct spci_message *from_msg_replica, struct spci_message *to_msg);
+	uint32_t size);
 
 bool spci_msg_check_transition(struct vm *to, struct vm *from,
 			       enum spci_memory_share share,
diff --git a/inc/hf/vm.h b/inc/hf/vm.h
index 7ea1e12..4762a2e 100644
--- a/inc/hf/vm.h
+++ b/inc/hf/vm.h
@@ -60,8 +60,17 @@
 
 struct mailbox {
 	enum mailbox_state state;
-	struct spci_message *recv;
-	const struct spci_message *send;
+	void *recv;
+	const void *send;
+
+	/** The ID of the VM which sent the message currently in `recv`. */
+	spci_vm_id_t recv_sender;
+
+	/** The size of the message currently in `recv`. */
+	uint32_t recv_size;
+
+	/** The attributes of the message currently in `recv`. */
+	uint32_t recv_attributes;
 
 	/**
 	 * List of wait_entry structs representing VMs that want to be notified
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index a920a58..b3db3fc 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -115,14 +115,26 @@
  * If the recipient's receive buffer is busy, it can optionally register the
  * caller to be notified when the recipient's receive buffer becomes available.
  *
- * Returns SPCI_SUCCESS if the message is sent, an error code otherwise:
- *  - INVALID_PARAMETER: one or more of the parameters do not conform.
+ * Attributes may include:
+ *  - SPCI_MSG_SEND_NOTIFY, to notify the caller when it should try again.
+ *  - SPCI_MSG_SEND_LEGACY_MEMORY, to send a legacy architected memory sharing
+ *    message.
+ *
+ * Returns SPCI_SUCCESS if the message is sent, or an error code otherwise:
+ *  - INVALID_PARAMETERS: one or more of the parameters do not conform.
  *  - BUSY: the message could not be delivered either because the mailbox
- *            was full or the target VM does not yet exist.
+ *    was full or the target VM is not yet set up.
  */
-static inline int64_t spci_msg_send(uint32_t attributes)
+static inline struct spci_value spci_msg_send(spci_vm_id_t sender_vm_id,
+					      spci_vm_id_t target_vm_id,
+					      uint32_t size,
+					      uint32_t attributes)
 {
-	return hf_call(SPCI_MSG_SEND_32, attributes, 0, 0);
+	return spci_call((struct spci_value){
+		.func = SPCI_MSG_SEND_32,
+		.arg1 = ((uint64_t)sender_vm_id << 16) | target_vm_id,
+		.arg3 = size,
+		.arg4 = attributes});
 }
 
 /**
diff --git a/inc/vmapi/hf/spci.h b/inc/vmapi/hf/spci.h
index 125380b..e878ffe 100644
--- a/inc/vmapi/hf/spci.h
+++ b/inc/vmapi/hf/spci.h
@@ -61,23 +61,16 @@
 };
 
 /* SPCI function specific constants. */
+#define SPCI_MSG_RECV_BLOCK  0x1
 #define SPCI_MSG_RECV_BLOCK_MASK  0x1
-#define SPCI_MSG_SEND_NOTIFY_MASK 0x1
-
-#define SPCI_MESSAGE_ARCHITECTED 0x0
-#define SPCI_MESSAGE_IMPDEF      0x1
-#define SPCI_MESSAGE_IMPDEF_MASK 0x1
 
 #define SPCI_MSG_SEND_NOTIFY 0x1
-#define SPCI_MSG_RECV_BLOCK  0x1
+#define SPCI_MSG_SEND_NOTIFY_MASK 0x1
+#define SPCI_MSG_SEND_LEGACY_MEMORY      0x2
+#define SPCI_MSG_SEND_LEGACY_MEMORY_MASK 0x2
 
 /* The maximum length possible for a single message. */
-#define SPCI_MSG_PAYLOAD_MAX (HF_MAILBOX_SIZE - sizeof(struct spci_message))
-
-#define spci_get_lend_descriptor(message)\
-	((struct spci_memory_lend *)(((uint8_t *) message)\
-	+ sizeof(struct spci_message)\
-	+ sizeof(struct spci_architected_message_header)))
+#define SPCI_MSG_PAYLOAD_MAX HF_MAILBOX_SIZE
 
 enum spci_lend_access {
 	SPCI_LEND_RO_NX,
@@ -208,42 +201,10 @@
 	return args.arg3;
 }
 
-/** SPCI common message header. */
-struct spci_message {
-	/*
-	 * TODO: version is part of SPCI alpha2 but will be
-	 * removed in the next spec revision hence we are not
-	 * including it in the header.
-	 */
-
-	/**
-	 * flags[0]:
-	 *     0: Architected message payload;
-	 *     1: Implementation defined message payload.
-	 * flags[15:1] reserved (MBZ).
-	 */
-	uint16_t flags;
-
-	/*
-	 * TODO: Padding is present to ensure controlled offset
-	 * of the length field. SPCI spec must be updated
-	 * to reflect this (TBD).
-	 */
-	uint16_t reserved_1;
-
-	uint32_t length;
-	spci_vm_id_t target_vm_id;
-	spci_vm_id_t source_vm_id;
-
-	/*
-	 * TODO: Padding is present to ensure that the field
-	 * payload alignment is 64B. SPCI spec must be updated
-	 * to reflect this.
-	 */
-	uint32_t reserved_2;
-
-	uint8_t payload[];
-};
+static inline uint32_t spci_msg_send_attributes(struct spci_value args)
+{
+	return args.arg4;
+}
 
 struct spci_architected_message_header {
 	uint16_t type;
@@ -281,73 +242,23 @@
 };
 
 /* TODO: Move all the functions below this line to a support library. */
-/**
- * Fill all the fields, except for the flags, in the SPCI message common header.
- */
-static inline void spci_common_header_init(struct spci_message *message,
-					   uint32_t message_length,
-					   spci_vm_id_t target_vm_id,
-					   spci_vm_id_t source_vm_id)
+
+static inline struct spci_memory_lend *spci_get_lend_descriptor(void *message)
 {
-	message->length = message_length;
-	message->target_vm_id = target_vm_id;
-	message->source_vm_id = source_vm_id;
-
-	/*
-	 * TODO: Reserved fields in the common message header will be
-	 * defined as MBZ in next SPCI spec updates.
-	 */
-	message->reserved_1 = 0;
-	message->reserved_2 = 0;
-}
-
-/**
- * Set the SPCI implementation defined message header fields.
- */
-static inline void spci_message_init(struct spci_message *message,
-				     uint32_t message_length,
-				     spci_vm_id_t target_vm_id,
-				     spci_vm_id_t source_vm_id)
-{
-	spci_common_header_init(message, message_length, target_vm_id,
-				source_vm_id);
-
-	message->flags = SPCI_MESSAGE_IMPDEF;
-}
-
-/**
- * Obtain a pointer to the architected header in the spci_message.
- *
- * Note: the argument "message" has const qualifier. This qualifier
- * is meant to forbid changes in information enclosed in the
- * struct spci_message. The spci_architected_message_header, for which
- * a pointer is returned in this function, is not part of spci_message.
- * Its information is meant to be changed and hence the returned pointer
- * does not have const type qualifier.
- */
-static inline struct spci_architected_message_header *
-spci_get_architected_message_header(const struct spci_message *message)
-{
-	return (struct spci_architected_message_header *)message->payload;
+	return (struct spci_memory_lend
+			*)((struct spci_architected_message_header *)message)
+		->payload;
 }
 
 /**
  * Helper method to fill in the information about the architected message.
  */
-static inline void spci_architected_message_init(struct spci_message *message,
-						 uint32_t message_length,
-						 spci_vm_id_t target_vm_id,
-						 spci_vm_id_t source_vm_id,
+static inline void spci_architected_message_init(void *message,
 						 enum spci_memory_share type)
 {
-	struct spci_architected_message_header *architected_header;
-
-	spci_common_header_init(message, message_length, target_vm_id,
-				source_vm_id);
-	message->flags = SPCI_MESSAGE_ARCHITECTED;
-
 	/* Fill the architected header. */
-	architected_header = spci_get_architected_message_header(message);
+	struct spci_architected_message_header *architected_header =
+		(struct spci_architected_message_header *)message;
 	architected_header->type = type;
 	architected_header->reserved[0] = 0;
 	architected_header->reserved[1] = 0;
@@ -356,10 +267,10 @@
 
 /** Obtain a pointer to the start of the memory region in the donate message. */
 static inline struct spci_memory_region *spci_get_donated_memory_region(
-	struct spci_message *message)
+	void *message)
 {
 	struct spci_architected_message_header *architected_header =
-		spci_get_architected_message_header(message);
+		(struct spci_architected_message_header *)message;
 	return (struct spci_memory_region *)architected_header->payload;
 }
 
@@ -396,64 +307,61 @@
 }
 
 /** Construct the SPCI donate memory region message. */
-static inline void spci_memory_donate(
-	struct spci_message *message, spci_vm_id_t target_vm_id,
-	spci_vm_id_t source_vm_id,
+static inline uint32_t spci_memory_donate_init(
+	void *message,
 	struct spci_memory_region_constituent *region_constituents,
 	uint32_t num_elements, uint32_t handle)
 {
-	int32_t message_length;
+	uint32_t message_length;
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(message);
 
 	message_length = sizeof(struct spci_architected_message_header);
 
 	/* Fill in the details on the common message header. */
-	spci_architected_message_init(message, message_length, target_vm_id,
-				      source_vm_id, SPCI_MEMORY_DONATE);
+	spci_architected_message_init(message, SPCI_MEMORY_DONATE);
 
 	/* Create single memory region. */
-	message->length += spci_memory_region_add(
+	message_length += spci_memory_region_add(
 		memory_region, handle, region_constituents, num_elements);
+	return message_length;
 }
 
 /**
  * Construct the SPCI memory region relinquish message.
  * A set of memory regions can be given back to the owner.
  */
-static inline void spci_memory_relinquish(
-	struct spci_message *message, spci_vm_id_t target_vm_id,
-	spci_vm_id_t source_vm_id,
+static inline uint32_t spci_memory_relinquish_init(
+	void *message,
 	struct spci_memory_region_constituent *region_constituents,
 	uint64_t num_elements, uint32_t handle)
 {
-	int32_t message_length;
+	uint32_t message_length;
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(message);
 
 	message_length = sizeof(struct spci_architected_message_header);
 
 	/* Fill in the details on the common message header. */
-	spci_architected_message_init(message, message_length, target_vm_id,
-				      source_vm_id, SPCI_MEMORY_RELINQUISH);
+	spci_architected_message_init(message, SPCI_MEMORY_RELINQUISH);
 
 	/* Create single memory region. */
-	message->length += spci_memory_region_add(
+	message_length += spci_memory_region_add(
 		memory_region, handle, region_constituents, num_elements);
+	return message_length;
 }
 
 /**
  * Construct the SPCI memory region lend message.
  */
-static inline void spci_memory_lend(
-	struct spci_message *message, spci_vm_id_t target_vm_id,
-	spci_vm_id_t source_vm_id,
+static inline uint32_t spci_memory_lend_init(
+	void *message,
 	struct spci_memory_region_constituent *region_constituents,
 	uint64_t num_elements, uint32_t handle, enum spci_lend_access access,
 	enum spci_lend_type type, enum spci_lend_cacheability cacheability,
 	enum spci_lend_shareability shareability)
 {
-	int32_t message_length;
+	uint32_t message_length;
 	struct spci_memory_region *memory_region;
 
 	const struct spci_memory_lend lend_init = {0};
@@ -469,8 +377,7 @@
 			 sizeof(struct spci_memory_lend);
 
 	/* Fill in the details on the common message header. */
-	spci_architected_message_init(message, message_length, target_vm_id,
-				      source_vm_id, SPCI_MEMORY_LEND);
+	spci_architected_message_init(message, SPCI_MEMORY_LEND);
 
 	lend_descriptor->flags = SPCI_LEND_KEEP_MAPPED;
 
@@ -484,6 +391,7 @@
 					shareability);
 
 	/* Create single memory region. */
-	message->length += spci_memory_region_add(
+	message_length += spci_memory_region_add(
 		memory_region, handle, region_constituents, num_elements);
+	return message_length;
 }
diff --git a/inc/vmapi/hf/types.h b/inc/vmapi/hf/types.h
index 1612099..687dafa 100644
--- a/inc/vmapi/hf/types.h
+++ b/inc/vmapi/hf/types.h
@@ -21,6 +21,8 @@
 
 #include <linux/types.h>
 
+#define INT32_C(c) c
+
 typedef phys_addr_t hf_ipaddr_t;
 
 #else
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 1b81c4a..16e8197 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -158,7 +158,6 @@
     "manifest_test.cc",
     "mm_test.cc",
     "mpool_test.cc",
-    "spci_test.cc",
     "string_test.cc",
   ]
   sources += [ "layout_fake.c" ]
diff --git a/src/api.c b/src/api.c
index 2034ae9..d11b305 100644
--- a/src/api.c
+++ b/src/api.c
@@ -352,9 +352,9 @@
 {
 	return (struct spci_value){
 		.func = SPCI_MSG_SEND_32,
-		.arg1 = receiver->mailbox.recv->source_vm_id << 16 |
-			receiver->id,
-		.arg3 = receiver->mailbox.recv->length};
+		.arg1 = (receiver->mailbox.recv_sender << 16) | receiver->id,
+		.arg3 = receiver->mailbox.recv_size,
+		.arg4 = receiver->mailbox.recv_attributes};
 }
 
 /**
@@ -846,8 +846,10 @@
  * If the recipient's receive buffer is busy, it can optionally register the
  * caller to be notified when the recipient's receive buffer becomes available.
  */
-spci_return_t api_spci_msg_send(uint32_t attributes, struct vcpu *current,
-				struct vcpu **next)
+struct spci_value api_spci_msg_send(spci_vm_id_t sender_vm_id,
+				    spci_vm_id_t receiver_vm_id, uint32_t size,
+				    uint32_t attributes, struct vcpu *current,
+				    struct vcpu **next)
 {
 	struct vm *from = current->vm;
 	struct vm *to;
@@ -857,59 +859,49 @@
 	struct hf_vcpu_run_return primary_ret = {
 		.code = HF_VCPU_RUN_MESSAGE,
 	};
-	struct spci_message from_msg_replica;
-	struct spci_message *to_msg;
-	const struct spci_message *from_msg;
+	const void *from_msg;
 
-	uint32_t size;
-
-	int64_t ret;
+	struct spci_value ret;
 	bool notify = (attributes & SPCI_MSG_SEND_NOTIFY_MASK) ==
 		      SPCI_MSG_SEND_NOTIFY;
 
+	/* Ensure sender VM ID corresponds to the current VM. */
+	if (sender_vm_id != from->id) {
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* Disallow reflexive requests as this suggests an error in the VM. */
+	if (receiver_vm_id == from->id) {
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
+	/* Limit the size of transfer. */
+	if (size > SPCI_MSG_PAYLOAD_MAX) {
+		return spci_error(SPCI_INVALID_PARAMETERS);
+	}
+
 	/*
-	 * Check that the sender has configured its send buffer. Copy the
-	 * message header. If the tx mailbox at from_msg is configured (i.e.
-	 * from_msg != NULL) then it can be safely accessed after releasing the
-	 * lock since the tx mailbox address can only be configured once.
+	 * Check that the sender has configured its send buffer. If the tx
+	 * mailbox at from_msg is configured (i.e. from_msg != NULL) then it can
+	 * be safely accessed after releasing the lock since the tx mailbox
+	 * address can only be configured once.
 	 */
 	sl_lock(&from->lock);
 	from_msg = from->mailbox.send;
 	sl_unlock(&from->lock);
 
 	if (from_msg == NULL) {
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
-	/*
-	 * Note that the payload is not copied when the message header is.
-	 */
-	from_msg_replica = *from_msg;
-
-	/* Ensure source VM id corresponds to the current VM. */
-	if (from_msg_replica.source_vm_id != from->id) {
-		return SPCI_INVALID_PARAMETERS;
-	}
-
-	size = from_msg_replica.length;
-	/* Limit the size of transfer. */
-	if (size > SPCI_MSG_PAYLOAD_MAX) {
-		return SPCI_INVALID_PARAMETERS;
-	}
-
-	/* Disallow reflexive requests as this suggests an error in the VM. */
-	if (from_msg_replica.target_vm_id == from->id) {
-		return SPCI_INVALID_PARAMETERS;
-	}
-
-	/* Ensure the target VM exists. */
-	to = vm_find(from_msg_replica.target_vm_id);
+	/* Ensure the receiver VM exists. */
+	to = vm_find(receiver_vm_id);
 	if (to == NULL) {
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	/*
-	 * Hf needs to hold the lock on <to> before the mailbox state is
+	 * Hafnium needs to hold the lock on <to> before the mailbox state is
 	 * checked. The lock on <to> must be held until the information is
 	 * copied to <to> Rx buffer. Since in
 	 * spci_msg_handle_architected_message we may call api_spci_share_memory
@@ -921,13 +913,12 @@
 	if (to->mailbox.state != MAILBOX_STATE_EMPTY ||
 	    to->mailbox.recv == NULL) {
 		/*
-		 * Fail if the target isn't currently ready to receive data,
+		 * Fail if the receiver isn't currently ready to receive data,
 		 * setting up for notification if requested.
 		 */
 		if (notify) {
 			struct wait_entry *entry =
-				&current->vm->wait_entries
-					 [from_msg_replica.target_vm_id];
+				&from->wait_entries[receiver_vm_id];
 
 			/* Append waiter only if it's not there yet. */
 			if (list_empty(&entry->wait_links)) {
@@ -936,72 +927,68 @@
 			}
 		}
 
-		ret = SPCI_BUSY;
+		ret = spci_error(SPCI_BUSY);
 		goto out;
 	}
 
-	to_msg = to->mailbox.recv;
-
-	/* Handle architected messages. */
-	if ((from_msg_replica.flags & SPCI_MESSAGE_IMPDEF_MASK) !=
-	    SPCI_MESSAGE_IMPDEF) {
+	/* Handle legacy memory sharing messages. */
+	if ((attributes & SPCI_MSG_SEND_LEGACY_MEMORY_MASK) ==
+	    SPCI_MSG_SEND_LEGACY_MEMORY) {
 		/*
 		 * Buffer holding the internal copy of the shared memory
 		 * regions.
 		 */
-		uint8_t *message_buffer = cpu_get_buffer(current->cpu->id);
+		struct spci_architected_message_header
+			*architected_message_replica =
+				(struct spci_architected_message_header *)
+					cpu_get_buffer(current->cpu->id);
 		uint32_t message_buffer_size =
 			cpu_get_buffer_size(current->cpu->id);
 
 		struct spci_architected_message_header *architected_header =
-			spci_get_architected_message_header(from->mailbox.send);
+			(struct spci_architected_message_header *)from_msg;
 
-		const struct spci_architected_message_header
-			*architected_message_replica;
-
-		if (from_msg_replica.length > message_buffer_size) {
-			ret = SPCI_INVALID_PARAMETERS;
+		if (size > message_buffer_size) {
+			ret = spci_error(SPCI_INVALID_PARAMETERS);
 			goto out;
 		}
 
-		if (from_msg_replica.length <
-		    sizeof(struct spci_architected_message_header)) {
-			ret = SPCI_INVALID_PARAMETERS;
+		if (size < sizeof(struct spci_architected_message_header)) {
+			ret = spci_error(SPCI_INVALID_PARAMETERS);
 			goto out;
 		}
 
-		/* Copy the architected message into an internal buffer. */
-		memcpy_s(message_buffer, message_buffer_size,
-			 architected_header, from_msg_replica.length);
-
-		architected_message_replica =
-			(struct spci_architected_message_header *)
-				message_buffer;
+		/* Copy the architected message into the internal buffer. */
+		memcpy_s(architected_message_replica, message_buffer_size,
+			 architected_header, size);
 
 		/*
-		 * Note that message_buffer is passed as the third parameter to
-		 * spci_msg_handle_architected_message. The execution flow
-		 * commencing at spci_msg_handle_architected_message will make
-		 * several accesses to fields in message_buffer. The memory area
-		 * message_buffer must be exclusively owned by Hf so that TOCTOU
-		 * issues do not arise.
+		 * Note that architected_message_replica is passed as the third
+		 * parameter to spci_msg_handle_architected_message. The
+		 * execution flow commencing at
+		 * spci_msg_handle_architected_message will make several
+		 * accesses to fields in architected_message_replica. The memory
+		 * area architected_message_replica must be exclusively owned by
+		 * Hafnium so that TOCTOU issues do not arise.
 		 */
 		ret = spci_msg_handle_architected_message(
 			vm_from_to_lock.vm1, vm_from_to_lock.vm2,
-			architected_message_replica, &from_msg_replica, to_msg);
+			architected_message_replica, size);
 
-		if (ret != SPCI_SUCCESS) {
+		if (ret.func != SPCI_SUCCESS_32) {
 			goto out;
 		}
 	} else {
 		/* Copy data. */
-		memcpy_s(to_msg->payload, SPCI_MSG_PAYLOAD_MAX,
-			 from->mailbox.send->payload, size);
-		*to_msg = from_msg_replica;
+		memcpy_s(to->mailbox.recv, SPCI_MSG_PAYLOAD_MAX, from_msg,
+			 size);
+		to->mailbox.recv_size = size;
+		to->mailbox.recv_sender = sender_vm_id;
+		to->mailbox.recv_attributes = 0;
+		ret = (struct spci_value){.func = SPCI_SUCCESS_32};
 	}
 
 	primary_ret.message.vm_id = to->id;
-	ret = SPCI_SUCCESS;
 
 	/* Messages for the primary VM are delivered directly. */
 	if (to->id == HF_PRIMARY_VM_ID) {
@@ -1429,11 +1416,10 @@
  *     the request.
  *  Success is indicated by SPCI_SUCCESS.
  */
-spci_return_t api_spci_share_memory(struct vm_locked to_locked,
-				    struct vm_locked from_locked,
-				    struct spci_memory_region *memory_region,
-				    uint32_t memory_to_attributes,
-				    enum spci_memory_share share)
+struct spci_value api_spci_share_memory(
+	struct vm_locked to_locked, struct vm_locked from_locked,
+	struct spci_memory_region *memory_region, uint32_t memory_to_attributes,
+	enum spci_memory_share share)
 {
 	struct vm *to = to_locked.vm;
 	struct vm *from = from_locked.vm;
@@ -1441,7 +1427,7 @@
 	int from_mode;
 	int to_mode;
 	struct mpool local_page_pool;
-	int64_t ret;
+	struct spci_value ret;
 	paddr_t pa_begin;
 	paddr_t pa_end;
 	ipaddr_t begin;
@@ -1451,7 +1437,7 @@
 
 	/* Disallow reflexive shares as this suggests an error in the VM. */
 	if (to == from) {
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	/*
@@ -1475,7 +1461,7 @@
 	if (!spci_msg_check_transition(to, from, share, &orig_from_mode, begin,
 				       end, memory_to_attributes, &from_mode,
 				       &to_mode)) {
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	pa_begin = pa_from_ipa(begin);
@@ -1487,7 +1473,7 @@
 	 */
 	if (!mm_vm_identity_map(&from->ptable, pa_begin, pa_end, from_mode,
 				NULL, &local_page_pool)) {
-		ret = SPCI_NO_MEMORY;
+		ret = spci_error(SPCI_NO_MEMORY);
 		goto out;
 	}
 
@@ -1498,7 +1484,7 @@
 		/* Recover any memory consumed in failed mapping. */
 		mm_vm_defrag(&from->ptable, &local_page_pool);
 
-		ret = SPCI_NO_MEMORY;
+		ret = spci_error(SPCI_NO_MEMORY);
 
 		CHECK(mm_vm_identity_map(&from->ptable, pa_begin, pa_end,
 					 orig_from_mode, NULL,
@@ -1507,10 +1493,9 @@
 		goto out;
 	}
 
-	ret = SPCI_SUCCESS;
+	ret = (struct spci_value){.func = SPCI_SUCCESS_32};
 
 out:
-
 	mpool_fini(&local_page_pool);
 
 	return ret;
diff --git a/src/arch/aarch64/hypervisor/handler.c b/src/arch/aarch64/hypervisor/handler.c
index 00ba80b..c4719ab 100644
--- a/src/arch/aarch64/hypervisor/handler.c
+++ b/src/arch/aarch64/hypervisor/handler.c
@@ -324,7 +324,11 @@
 
 		return true;
 	case SPCI_MSG_SEND_32:
-		args->func = api_spci_msg_send(args->arg1, current(), next);
+		*args = api_spci_msg_send(spci_msg_send_sender(*args),
+					  spci_msg_send_receiver(*args),
+					  spci_msg_send_size(*args),
+					  spci_msg_send_attributes(*args),
+					  current(), next);
 		return true;
 	case SPCI_MSG_WAIT_32:
 		*args = api_spci_msg_recv(true, current(), next);
diff --git a/src/spci_architected_message.c b/src/spci_architected_message.c
index 28d5fc7..ec2041e 100644
--- a/src/spci_architected_message.c
+++ b/src/spci_architected_message.c
@@ -23,7 +23,7 @@
  * Check if the message length and the number of memory region constituents
  * match, if the check is correct call the memory sharing routine.
  */
-static spci_return_t spci_validate_call_share_memory(
+static struct spci_value spci_validate_call_share_memory(
 	struct vm_locked to_locked, struct vm_locked from_locked,
 	struct spci_memory_region *memory_region, uint32_t memory_share_size,
 	uint32_t memory_to_attributes, enum spci_memory_share share)
@@ -38,7 +38,7 @@
 	    sizeof(struct spci_memory_region) +
 		    (sizeof(struct spci_memory_region_constituent) *
 		     max_count)) {
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	return api_spci_share_memory(to_locked, from_locked, memory_region,
@@ -50,13 +50,13 @@
  * corresponding api functions implementing the functionality requested
  * in the architected message.
  */
-spci_return_t spci_msg_handle_architected_message(
+struct spci_value spci_msg_handle_architected_message(
 	struct vm_locked to_locked, struct vm_locked from_locked,
 	const struct spci_architected_message_header
 		*architected_message_replica,
-	struct spci_message *from_msg_replica, struct spci_message *to_msg)
+	uint32_t size)
 {
-	int64_t ret;
+	struct spci_value ret;
 	struct spci_memory_region *memory_region;
 	uint32_t to_mode;
 	uint32_t message_type;
@@ -70,8 +70,7 @@
 					architected_message_replica->payload;
 
 		memory_share_size =
-			from_msg_replica->length -
-			sizeof(struct spci_architected_message_header);
+			size - sizeof(struct spci_architected_message_header);
 
 		/* TODO: Add memory attributes. */
 		to_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X;
@@ -87,8 +86,7 @@
 					architected_message_replica->payload;
 
 		memory_share_size =
-			from_msg_replica->length -
-			sizeof(struct spci_architected_message_header);
+			size - sizeof(struct spci_architected_message_header);
 
 		to_mode = MM_MODE_R | MM_MODE_W | MM_MODE_X;
 
@@ -111,8 +109,7 @@
 		memory_region =
 			(struct spci_memory_region *)lend_descriptor->payload;
 		memory_share_size =
-			from_msg_replica->length -
-			sizeof(struct spci_architected_message_header) -
+			size - sizeof(struct spci_architected_message_header) -
 			sizeof(struct spci_memory_lend);
 
 		to_mode = spci_memory_attrs_to_mode(borrower_attributes);
@@ -126,7 +123,7 @@
 
 	default:
 		dlog("Invalid memory sharing message.\n");
-		return SPCI_INVALID_PARAMETERS;
+		return spci_error(SPCI_INVALID_PARAMETERS);
 	}
 
 	/* Copy data to the destination Rx. */
@@ -138,11 +135,14 @@
 	 * in the destination Rx buffer. This mechanism will be defined at the
 	 * spec level.
 	 */
-	if (ret == SPCI_SUCCESS) {
-		memcpy_s(to_msg->payload, SPCI_MSG_PAYLOAD_MAX,
-			 architected_message_replica, from_msg_replica->length);
+	if (ret.func == SPCI_SUCCESS_32) {
+		memcpy_s(to_locked.vm->mailbox.recv, SPCI_MSG_PAYLOAD_MAX,
+			 architected_message_replica, size);
+		to_locked.vm->mailbox.recv_size = size;
+		to_locked.vm->mailbox.recv_sender = from_locked.vm->id;
+		to_locked.vm->mailbox.recv_attributes =
+			SPCI_MSG_SEND_LEGACY_MEMORY;
 	}
-	*to_msg = *from_msg_replica;
 
 	return ret;
 }
diff --git a/src/spci_test.cc b/src/spci_test.cc
deleted file mode 100644
index a3191cc..0000000
--- a/src/spci_test.cc
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * Copyright 2019 The Hafnium Authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-extern "C" {
-#include "vmapi/hf/spci.h"
-}
-
-#include <gmock/gmock.h>
-
-namespace
-{
-using ::testing::Eq;
-
-/**
- * Ensure that spci_message_init is correctly setting the expected fields in the
- * SPCI common message header.
- */
-TEST(spci, spci_message_init)
-{
-	spci_message header;
-	spci_message compare_header = {
-		.flags = SPCI_MESSAGE_IMPDEF_MASK,
-		.length = 1,
-		.target_vm_id = 2,
-		.source_vm_id = 3,
-	};
-
-	memset(&header, 0xff, sizeof(header));
-	spci_message_init(&header, 1, 2, 3);
-
-	EXPECT_THAT(memcmp(&header, &compare_header, sizeof(header)), 0);
-}
-} /* namespace */
diff --git a/test/hftest/inc/hftest_impl.h b/test/hftest/inc/hftest_impl.h
index f3eb407..9598b12 100644
--- a/test/hftest/inc/hftest_impl.h
+++ b/test/hftest/inc/hftest_impl.h
@@ -140,8 +140,8 @@
 	const struct fdt_header *fdt;
 
 	/* These are used in services. */
-	struct spci_message *send;
-	struct spci_message *recv;
+	void *send;
+	void *recv;
 	size_t memory_size;
 };
 
@@ -291,12 +291,12 @@
 		ASSERT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);             \
                                                                               \
 		/* Send the selected service to run and let it be handled. */ \
-		memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, service, \
+		memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, service,          \
 			 msg_length);                                         \
-		spci_message_init(send_buffer, msg_length, vm_id,             \
-				  hf_vm_get_id());                            \
                                                                               \
-		ASSERT_EQ(spci_msg_send(0), 0);                               \
+		ASSERT_EQ(spci_msg_send(hf_vm_get_id(), vm_id, msg_length, 0) \
+				  .func,                                      \
+			  SPCI_SUCCESS_32);                                   \
 		run_res = hf_vcpu_run(vm_id, 0);                              \
 		ASSERT_EQ(run_res.code, HF_VCPU_RUN_YIELD);                   \
 	} while (0)
diff --git a/test/hftest/service.c b/test/hftest/service.c
index c04c253..ed35e74 100644
--- a/test/hftest/service.c
+++ b/test/hftest/service.c
@@ -95,8 +95,6 @@
 		}
 	}
 
-	struct spci_message *recv_msg = (struct spci_message *)recv;
-
 	/* Prepare the context. */
 
 	/* Set up the mailbox. */
@@ -104,7 +102,8 @@
 
 	/* Receive the name of the service to run. */
 	ret = spci_msg_wait();
-	memiter_init(&args, recv_msg->payload, spci_msg_send_size(ret));
+	ASSERT_EQ(ret.func, SPCI_MSG_SEND_32);
+	memiter_init(&args, recv, spci_msg_send_size(ret));
 	service = find_service(&args);
 	hf_mailbox_clear();
 
@@ -122,8 +121,8 @@
 	ctx = hftest_get_context();
 	memset_s(ctx, sizeof(*ctx), 0, sizeof(*ctx));
 	ctx->abort = abort;
-	ctx->send = (struct spci_message *)send;
-	ctx->recv = (struct spci_message *)recv;
+	ctx->send = send;
+	ctx->recv = recv;
 	ctx->memory_size = memory_size;
 
 	/* Pause so the next time cycles are given the service will be run. */
diff --git a/test/linux/hftest_socket.c b/test/linux/hftest_socket.c
index ae69abb..460d1f1 100644
--- a/test/linux/hftest_socket.c
+++ b/test/linux/hftest_socket.c
@@ -74,14 +74,12 @@
 	ctx = hftest_get_context();
 	memset_s(ctx, sizeof(*ctx), 0, sizeof(*ctx));
 	ctx->abort = abort;
-	ctx->send = (struct spci_message *)send;
-	ctx->recv = (struct spci_message *)recv;
+	ctx->send = send;
+	ctx->recv = recv;
 	ctx->memory_size = memory_size;
 
 	for (;;) {
 		struct spci_value ret;
-		struct spci_message *send_buf = (struct spci_message *)send;
-		struct spci_message *recv_buf = (struct spci_message *)recv;
 
 		/* Receive the packet. */
 		ret = spci_msg_wait();
@@ -89,21 +87,21 @@
 		EXPECT_LE(spci_msg_send_size(ret), SPCI_MSG_PAYLOAD_MAX);
 
 		/* Echo the message back to the sender. */
-		memcpy_s(send_buf->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_buf->payload, spci_msg_send_size(ret));
+		memcpy_s(send, SPCI_MSG_PAYLOAD_MAX, recv,
+			 spci_msg_send_size(ret));
 
 		/* Swap the socket's source and destination ports */
-		struct hf_msg_hdr *hdr = (struct hf_msg_hdr *)send_buf->payload;
+		struct hf_msg_hdr *hdr = (struct hf_msg_hdr *)send;
 		swap(&(hdr->src_port), &(hdr->dst_port));
 
 		/* Swap the destination and source ids. */
 		spci_vm_id_t dst_id = spci_msg_send_sender(ret);
 		spci_vm_id_t src_id = spci_msg_send_receiver(ret);
 
-		spci_message_init(send_buf, spci_msg_send_size(ret), dst_id,
-				  src_id);
-
 		hf_mailbox_clear();
-		EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+		EXPECT_EQ(spci_msg_send(src_id, dst_id, spci_msg_send_size(ret),
+					0)
+				  .func,
+			  SPCI_SUCCESS_32);
 	}
 }
diff --git a/test/vmapi/arch/aarch64/gicv3/busy_secondary.c b/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
index 2f0766a..1ed1031 100644
--- a/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
+++ b/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
@@ -79,10 +79,11 @@
 
 	/* Let secondary start looping. */
 	dlog("Telling secondary to loop.\n");
-	memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(send_buffer, 0, SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_PREEMPTED);
 
@@ -136,10 +137,11 @@
 
 	/* Let secondary start looping. */
 	dlog("Telling secondary to loop.\n");
-	memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(send_buffer, 0, SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_PREEMPTED);
 
diff --git a/test/vmapi/arch/aarch64/gicv3/gicv3.c b/test/vmapi/arch/aarch64/gicv3/gicv3.c
index e6e7435..9c144b0 100644
--- a/test/vmapi/arch/aarch64/gicv3/gicv3.c
+++ b/test/vmapi/arch/aarch64/gicv3/gicv3.c
@@ -34,8 +34,8 @@
 hf_ipaddr_t send_page_addr = (hf_ipaddr_t)send_page;
 hf_ipaddr_t recv_page_addr = (hf_ipaddr_t)recv_page;
 
-struct spci_message *send_buffer = (struct spci_message *)send_page;
-struct spci_message *recv_buffer = (struct spci_message *)recv_page;
+void *send_buffer = send_page;
+void *recv_buffer = recv_page;
 
 volatile uint32_t last_interrupt_id = 0;
 
diff --git a/test/vmapi/arch/aarch64/gicv3/inc/gicv3.h b/test/vmapi/arch/aarch64/gicv3/inc/gicv3.h
index d51398f..7308233 100644
--- a/test/vmapi/arch/aarch64/gicv3/inc/gicv3.h
+++ b/test/vmapi/arch/aarch64/gicv3/inc/gicv3.h
@@ -33,8 +33,8 @@
 extern hf_ipaddr_t send_page_addr;
 extern hf_ipaddr_t recv_page_addr;
 
-extern struct spci_message *send_buffer;
-extern struct spci_message *recv_buffer;
+extern void *send_buffer;
+extern void *recv_buffer;
 
 extern volatile uint32_t last_interrupt_id;
 
diff --git a/test/vmapi/arch/aarch64/gicv3/services/timer.c b/test/vmapi/arch/aarch64/gicv3/services/timer.c
index 5d3dd2d..fc52ab1 100644
--- a/test/vmapi/arch/aarch64/gicv3/services/timer.c
+++ b/test/vmapi/arch/aarch64/gicv3/services/timer.c
@@ -46,11 +46,8 @@
 	}
 	buffer[8] = '0' + interrupt_id / 10;
 	buffer[9] = '0' + interrupt_id % 10;
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, buffer,
-		 size);
-	spci_message_init(SERVICE_SEND_BUFFER(), size, HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-	spci_msg_send(0);
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, buffer, size);
+	spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, size, 0);
 	dlog("secondary IRQ %d ended\n", interrupt_id);
 	event_send_local();
 }
@@ -63,8 +60,7 @@
 
 	for (;;) {
 		const char timer_wfi_message[] = "**** xxxxxxx";
-		struct spci_message *message_header = SERVICE_RECV_BUFFER();
-		uint8_t *message;
+		uint8_t *message = (uint8_t *)SERVICE_RECV_BUFFER();
 		bool wfi, wfe, receive;
 		bool disable_interrupts;
 		uint32_t ticks;
@@ -77,8 +73,6 @@
 			     spci_msg_send_size(ret));
 		}
 
-		message = message_header->payload;
-
 		/*
 		 * Start a timer to send the message back: enable it and
 		 * set it for the requested number of ticks.
diff --git a/test/vmapi/arch/aarch64/gicv3/timer_secondary.c b/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
index b21bd83..e38a2fc 100644
--- a/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
+++ b/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
@@ -49,11 +49,11 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
-	memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(send_buffer, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	/*
 	 * Let the secondary handle the message and set the timer. It will loop
@@ -75,7 +75,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(recv_buffer->payload, expected_response,
+	EXPECT_EQ(memcmp(recv_buffer, expected_response,
 			 sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -108,11 +108,11 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
-	memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 message_length);
-	spci_message_init(send_buffer, message_length, SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, message_length);
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, message_length, 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	/* Let the secondary handle the message and set the timer. */
 	last_interrupt_id = 0;
@@ -173,7 +173,7 @@
 	/* Once we wake it up it should get the timer interrupt and respond. */
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(recv_buffer->payload, expected_response,
+	EXPECT_EQ(memcmp(recv_buffer, expected_response,
 			 sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -261,11 +261,11 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
-	memcpy_s(send_buffer->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 message_length);
-	spci_message_init(send_buffer, message_length, SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, message_length);
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, message_length, 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	/*
 	 * Let the secondary handle the message and set the timer.
diff --git a/test/vmapi/primary_with_secondaries/BUILD.gn b/test/vmapi/primary_with_secondaries/BUILD.gn
index 7302db0..86092cc 100644
--- a/test/vmapi/primary_with_secondaries/BUILD.gn
+++ b/test/vmapi/primary_with_secondaries/BUILD.gn
@@ -38,14 +38,24 @@
     "spci.c",
   ]
 
-  sources += [ "util.c" ]
-
   deps = [
+    ":util",
     "//src/arch/aarch64/hftest:registers",
     "//test/hftest:hftest_primary_vm",
   ]
 }
 
+source_set("util") {
+  testonly = true
+  public_configs = [
+    ":config",
+    "//test/hftest:hftest_config",
+  ]
+  sources = [
+    "util.c",
+  ]
+}
+
 initrd("primary_with_secondaries_test") {
   testonly = true
 
diff --git a/test/vmapi/primary_with_secondaries/inc/util.h b/test/vmapi/primary_with_secondaries/inc/util.h
index eca641f..845a4b4 100644
--- a/test/vmapi/primary_with_secondaries/inc/util.h
+++ b/test/vmapi/primary_with_secondaries/inc/util.h
@@ -18,9 +18,15 @@
 
 #include "vmapi/hf/spci.h"
 
+#define EXPECT_SPCI_ERROR(value, spci_error)          \
+	do {                                          \
+		EXPECT_EQ(value.func, SPCI_ERROR_32); \
+		EXPECT_EQ(value.arg1, spci_error);    \
+	} while (0)
+
 struct mailbox_buffers {
-	struct spci_message *send;
-	struct spci_message *recv;
+	void *send;
+	void *recv;
 };
 
 struct mailbox_buffers set_up_mailbox(void);
diff --git a/test/vmapi/primary_with_secondaries/interrupts.c b/test/vmapi/primary_with_secondaries/interrupts.c
index ae081d4..31db0b0 100644
--- a/test/vmapi/primary_with_secondaries/interrupts.c
+++ b/test/vmapi/primary_with_secondaries/interrupts.c
@@ -42,16 +42,15 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Set the message, echo it and wait for a response. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -78,8 +77,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
@@ -88,8 +86,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -116,8 +113,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
@@ -126,7 +122,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response_2));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response_2,
+	EXPECT_EQ(memcmp(mb.recv, expected_response_2,
 			 sizeof(expected_response_2)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -156,8 +152,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
@@ -166,15 +161,15 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Now send a message to the secondary. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response_2));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response_2,
+	EXPECT_EQ(memcmp(mb.recv, expected_response_2,
 			 sizeof(expected_response_2)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -204,16 +199,15 @@
 	 * Now send a message to the secondary to enable the interrupt ID, and
 	 * expect the response from the interrupt we sent before.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -240,8 +234,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -268,8 +261,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response,
-			 sizeof(expected_response)),
+	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -290,15 +282,15 @@
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	hf_interrupt_inject(SERVICE_VM0, 0, EXTERNAL_INTERRUPT_ID_A);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
diff --git a/test/vmapi/primary_with_secondaries/mailbox.c b/test/vmapi/primary_with_secondaries/mailbox.c
index ca06bff..d83beaf 100644
--- a/test/vmapi/primary_with_secondaries/mailbox.c
+++ b/test/vmapi/primary_with_secondaries/mailbox.c
@@ -88,15 +88,15 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Set the message, echo it and check it didn't change. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.send->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.send, message, sizeof(message)), 0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
 
@@ -120,16 +120,16 @@
 
 		/* Set the message, echo it and check it didn't change. */
 		next_permutation(message, sizeof(message) - 1);
-		memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
+		memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message,
 			 sizeof(message));
-		spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-				  HF_PRIMARY_VM_ID);
-		EXPECT_EQ(spci_msg_send(0), 0);
+		EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0,
+					sizeof(message), 0)
+				  .func,
+			  SPCI_SUCCESS_32);
 		run_res = hf_vcpu_run(SERVICE_VM0, 0);
 		EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 		EXPECT_EQ(run_res.message.size, sizeof(message));
-		EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)),
-			  0);
+		EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 		EXPECT_EQ(hf_mailbox_clear(), 0);
 	}
 }
@@ -159,17 +159,19 @@
 	 * SERVICE_VM0, then to SERVICE_VM1 and finally back to here.
 	 */
 	{
-		spci_vm_id_t *chain = (spci_vm_id_t *)mb.send->payload;
+		spci_vm_id_t *chain = (spci_vm_id_t *)mb.send;
 		*chain++ = htole32(SERVICE_VM1);
 		*chain++ = htole32(HF_PRIMARY_VM_ID);
 		memcpy_s(chain,
 			 SPCI_MSG_PAYLOAD_MAX - (2 * sizeof(spci_vm_id_t)),
 			 message, sizeof(message));
 
-		spci_message_init(mb.send,
-				  sizeof(message) + (2 * sizeof(spci_vm_id_t)),
-				  SERVICE_VM0, HF_PRIMARY_VM_ID);
-		EXPECT_EQ(spci_msg_send(0), 0);
+		EXPECT_EQ(
+			spci_msg_send(
+				HF_PRIMARY_VM_ID, SERVICE_VM0,
+				sizeof(message) + (2 * sizeof(spci_vm_id_t)), 0)
+				.func,
+			SPCI_SUCCESS_32);
 	}
 
 	/* Let SERVICE_VM0 forward the message. */
@@ -185,7 +187,7 @@
 	/* Ensure the message is intact. */
 	EXPECT_EQ(run_res.message.vm_id, HF_PRIMARY_VM_ID);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
 
@@ -196,17 +198,17 @@
 TEST(mailbox, no_primary_to_secondary_notification_on_configure)
 {
 	struct hf_vcpu_run_return run_res;
+	set_up_mailbox();
 
-	struct mailbox_buffers mb = set_up_mailbox();
-	spci_message_init(mb.send, 0, SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_BUSY);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0, 0),
+			  SPCI_BUSY);
 
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	spci_message_init(mb.send, 0, SERVICE_VM0, HF_PRIMARY_VM_ID);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0, 0).func,
+		  SPCI_SUCCESS_32);
 }
 
 /**
@@ -216,11 +218,11 @@
 TEST(mailbox, secondary_to_primary_notification_on_configure)
 {
 	struct hf_vcpu_run_return run_res;
+	set_up_mailbox();
 
-	struct mailbox_buffers mb = set_up_mailbox();
-
-	spci_message_init(mb.send, 0, SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(SPCI_MSG_SEND_NOTIFY), SPCI_BUSY);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0,
+					SPCI_MSG_SEND_NOTIFY),
+			  SPCI_BUSY);
 
 	/*
 	 * Run first VM for it to configure itself. It should result in
@@ -234,7 +236,8 @@
 	EXPECT_EQ(hf_mailbox_waiter_get(SERVICE_VM0), -1);
 
 	/* Send should now succeed. */
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0, 0).func,
+		  SPCI_SUCCESS_32);
 }
 
 /**
@@ -255,15 +258,15 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Send a message to echo service, and get response back. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 
 	/* Let secondary VM continue running so that it will wait again. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -272,13 +275,13 @@
 
 	/* Without clearing our mailbox, send message again. */
 	reverse(message, strnlen_s(message, sizeof(message)));
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
 
 	/* Message should be dropped since the mailbox was not cleared. */
-	EXPECT_EQ(spci_msg_send(0), 0);
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
@@ -300,7 +303,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 }
 
 /**
@@ -321,18 +324,21 @@
 	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
 
 	/* Send a message to echo service twice. The second should fail. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
-	EXPECT_EQ(spci_msg_send(SPCI_MSG_SEND_NOTIFY), SPCI_BUSY);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message),
+				SPCI_MSG_SEND_NOTIFY)
+			  .arg1,
+		  SPCI_BUSY);
 
 	/* Receive a reply for the first message. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(message));
-	EXPECT_EQ(memcmp(mb.recv->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 
 	/* Run VM again so that it clears its mailbox. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -343,5 +349,8 @@
 	EXPECT_EQ(hf_mailbox_waiter_get(SERVICE_VM0), -1);
 
 	/* Send should now succeed. */
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 }
diff --git a/test/vmapi/primary_with_secondaries/memory_sharing.c b/test/vmapi/primary_with_secondaries/memory_sharing.c
index 5de2649..b97dfab 100644
--- a/test/vmapi/primary_with_secondaries/memory_sharing.c
+++ b/test/vmapi/primary_with_secondaries/memory_sharing.c
@@ -84,16 +84,23 @@
 					for (m = 0;
 					     m < ARRAY_SIZE(lend_shareability);
 					     ++m) {
-						spci_memory_lend(
-							mb.send, vms[i],
-							HF_PRIMARY_VM_ID,
-							constituents, 1, 0,
-							lend_access[j],
-							lend_type[k],
-							lend_cacheability[l],
-							lend_shareability[m]);
-						EXPECT_EQ(
-							spci_msg_send(0),
+						uint32_t msg_size =
+							spci_memory_lend_init(
+								mb.send,
+								constituents, 1,
+								0,
+								lend_access[j],
+								lend_type[k],
+								lend_cacheability
+									[l],
+								lend_shareability
+									[m]);
+						EXPECT_SPCI_ERROR(
+							spci_msg_send(
+								HF_PRIMARY_VM_ID,
+								vms[i],
+								msg_size,
+								SPCI_MSG_SEND_LEGACY_MEMORY),
 							SPCI_INVALID_PARAMETERS);
 					}
 				}
@@ -116,13 +123,17 @@
 
 	int i;
 	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
+		uint32_t msg_size;
 		/* Optionally skip one VM as the donate would succeed. */
 		if (vms[i] == avoid_vm) {
 			continue;
 		}
-		spci_memory_donate(mb.send, vms[i], HF_PRIMARY_VM_ID,
-				   constituents, num_elements, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_donate_init(mb.send, constituents,
+						   num_elements, 0);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, vms[i], msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
 	}
 }
 
@@ -140,9 +151,12 @@
 	int j;
 	for (i = 0; i < ARRAY_SIZE(vms); ++i) {
 		for (j = 0; j < ARRAY_SIZE(vms); ++j) {
-			spci_memory_relinquish(mb.send, vms[i], vms[j],
-					       constituents, num_elements, 0);
-			EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+			uint32_t msg_size = spci_memory_relinquish_init(
+				mb.send, constituents, num_elements, 0);
+			EXPECT_SPCI_ERROR(
+				spci_msg_send(vms[j], vms[i], msg_size,
+					      SPCI_MSG_SEND_LEGACY_MEMORY),
+				SPCI_INVALID_PARAMETERS);
 		}
 	}
 }
@@ -210,9 +224,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
@@ -253,9 +268,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -295,6 +311,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_return", mb.send);
 
@@ -306,10 +323,12 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
@@ -333,6 +352,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish", mb.send);
 
@@ -343,11 +363,15 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
@@ -385,9 +409,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -423,9 +448,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -460,9 +486,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -500,9 +527,10 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
-	spci_message_init(mb.send, sizeof(ptr), SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, &ptr, sizeof(ptr));
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(ptr), 0)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -534,7 +562,7 @@
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 
 	/* Check the memory was cleared. */
-	ptr = *(uint8_t **)mb.recv->payload;
+	ptr = *(uint8_t **)mb.recv;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -560,7 +588,7 @@
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 
 	/* Check the memory was cleared. */
-	ptr = *(uint8_t **)mb.recv->payload;
+	ptr = *(uint8_t **)mb.recv;
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
@@ -578,6 +606,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_donate_check_upper_bound", mb.send);
 
@@ -588,9 +617,11 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Observe the service faulting when accessing the memory. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -605,6 +636,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_donate_check_lower_bound", mb.send);
 
@@ -615,9 +647,11 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Observe the service faulting when accessing the memory. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -633,6 +667,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_return", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_return", mb.send);
@@ -644,19 +679,23 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 
 	/* Share the memory with another VM. */
-	spci_memory_donate(mb.send, SERVICE_VM1, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Observe the original service faulting when accessing the memory. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -672,6 +711,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_donate_secondary_and_fault", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_receive", mb.send);
@@ -688,9 +728,11 @@
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
 
 	/* Donate memory. */
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be sent from VM0 to VM1. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -717,6 +759,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_donate_twice", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_receive", mb.send);
@@ -729,9 +772,11 @@
 	};
 
 	/* Donate memory to VM0. */
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be received. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -761,6 +806,7 @@
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
@@ -768,10 +814,11 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_donate(mb.send, HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID,
-			   constituents, 1, 0);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID,
+					msg_size, SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 }
 
 /**
@@ -781,6 +828,7 @@
 {
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	/* Initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
@@ -788,11 +836,13 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID,
-			 constituents, 1, 0, SPCI_LEND_RW_X,
-			 SPCI_LEND_NORMAL_MEM, SPCI_LEND_CACHE_WRITE_BACK,
-			 SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, HF_PRIMARY_VM_ID,
+					msg_size, SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 }
 
 /**
@@ -803,6 +853,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_donate_invalid_source", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_receive", mb.send);
@@ -814,22 +865,27 @@
 	};
 
 	/* Try invalid configurations. */
-	spci_memory_donate(mb.send, HF_PRIMARY_VM_ID, SERVICE_VM0, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_SPCI_ERROR(spci_msg_send(SERVICE_VM0, HF_PRIMARY_VM_ID, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 
-	spci_memory_donate(mb.send, SERVICE_VM0, SERVICE_VM0, constituents, 1,
-			   0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_SPCI_ERROR(spci_msg_send(SERVICE_VM0, SERVICE_VM0, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 
-	spci_memory_donate(mb.send, SERVICE_VM0, SERVICE_VM1, constituents, 1,
-			   0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_SPCI_ERROR(spci_msg_send(SERVICE_VM1, SERVICE_VM0, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 
 	/* Successfully donate to VM0. */
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Receive and return memory from VM0. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -853,14 +909,20 @@
 		struct spci_memory_region_constituent constituents[] = {
 			{.address = (uint64_t)page + i, .page_count = 1},
 		};
-		spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID,
-				   constituents, 1, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
-		spci_memory_lend(
-			mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents, 1,
-			0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		uint32_t msg_size =
+			spci_memory_donate_init(mb.send, constituents, 1, 0);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_lend_init(
+			mb.send, constituents, 1, 0, SPCI_LEND_RW_X,
+			SPCI_LEND_NORMAL_MEM, SPCI_LEND_CACHE_WRITE_BACK,
+			SPCI_LEND_OUTER_SHAREABLE);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
 	}
 }
 
@@ -872,6 +934,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_lend_invalid_source", mb.send);
 
@@ -882,16 +945,23 @@
 	};
 
 	/* Check cannot swap VM IDs. */
-	spci_memory_lend(mb.send, HF_PRIMARY_VM_ID, SERVICE_VM0, constituents,
-			 1, 0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_msg_send(SERVICE_VM0, HF_PRIMARY_VM_ID, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 
 	/* Lend memory to VM0. */
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Receive and return memory from VM0. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -911,6 +981,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish_RW", mb.send);
 
@@ -921,11 +992,15 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -944,11 +1019,15 @@
 	/* Re-initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -974,6 +1053,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish_RW", mb.send);
 
@@ -984,11 +1064,15 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_NX, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_NX, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1006,11 +1090,15 @@
 	/* Re-initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_NX, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_NX, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1035,6 +1123,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish_X", mb.send);
 
@@ -1049,19 +1138,27 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Attempt to execute from memory. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RW_NX, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RW_NX, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Try and fail to execute from the memory region. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1076,6 +1173,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish_X", mb.send);
 
@@ -1090,19 +1188,27 @@
 		{.address = (uint64_t)page, .page_count = 1},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Attempt to execute from memory. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_NX, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_NX, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Try and fail to execute from the memory region. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1117,6 +1223,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_relinquish_RW", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_relinquish_RW", mb.send);
@@ -1128,11 +1235,15 @@
 		{.address = (uint64_t)page, .page_count = 2},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1142,15 +1253,19 @@
 	constituents[0].page_count = 1;
 	for (int i = 1; i < PAGE_SIZE * 2; i++) {
 		constituents[0].address = (uint64_t)page + PAGE_SIZE;
-		spci_memory_donate(mb.send, SERVICE_VM1, HF_PRIMARY_VM_ID,
-				   constituents, 1, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
 	}
 
 	/* Ensure we can donate to the only borrower. */
-	spci_memory_donate(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			   1, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(mb.send, constituents, 1, 0);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 }
 
 /**
@@ -1161,6 +1276,7 @@
 	struct hf_vcpu_run_return run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
+	uint32_t msg_size;
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_memory_lend_twice", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "spci_memory_lend_twice", mb.send);
@@ -1172,11 +1288,15 @@
 		{.address = (uint64_t)page, .page_count = 2},
 	};
 
-	spci_memory_lend(mb.send, SERVICE_VM0, HF_PRIMARY_VM_ID, constituents,
-			 1, 0, SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	msg_size = spci_memory_lend_init(mb.send, constituents, 1, 0,
+					 SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
+					 SPCI_LEND_CACHE_WRITE_BACK,
+					 SPCI_LEND_OUTER_SHAREABLE);
 
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
@@ -1193,10 +1313,13 @@
 	constituents[0].page_count = 1;
 	for (int i = 1; i < PAGE_SIZE * 2; i++) {
 		constituents[0].address = (uint64_t)page + PAGE_SIZE;
-		spci_memory_lend(
-			mb.send, SERVICE_VM1, HF_PRIMARY_VM_ID, constituents, 1,
-			0, SPCI_LEND_RO_X, SPCI_LEND_NORMAL_MEM,
-			SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_lend_init(
+			mb.send, constituents, 1, 0, SPCI_LEND_RO_X,
+			SPCI_LEND_NORMAL_MEM, SPCI_LEND_CACHE_WRITE_BACK,
+			SPCI_LEND_OUTER_SHAREABLE);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
 	}
 }
diff --git a/test/vmapi/primary_with_secondaries/run_race.c b/test/vmapi/primary_with_secondaries/run_race.c
index 7ba4d74..3689825 100644
--- a/test/vmapi/primary_with_secondaries/run_race.c
+++ b/test/vmapi/primary_with_secondaries/run_race.c
@@ -56,7 +56,7 @@
 
 	/* Copies the contents of the received boolean to the return value. */
 	if (run_res.message.size == sizeof(ok)) {
-		ok = *(bool *)mb->recv->payload;
+		ok = *(bool *)mb->recv;
 	}
 
 	hf_mailbox_clear();
diff --git a/test/vmapi/primary_with_secondaries/services/BUILD.gn b/test/vmapi/primary_with_secondaries/services/BUILD.gn
index 6694a93..4dbe074 100644
--- a/test/vmapi/primary_with_secondaries/services/BUILD.gn
+++ b/test/vmapi/primary_with_secondaries/services/BUILD.gn
@@ -93,6 +93,9 @@
     "..:config",
     "//test/hftest:hftest_config",
   ]
+  deps = [
+    "//test/vmapi/primary_with_secondaries:util",
+  ]
 
   sources = [
     "memory.c",
@@ -150,6 +153,7 @@
   ]
   deps = [
     "//src/arch/aarch64:arch",
+    "//test/vmapi/primary_with_secondaries:util",
   ]
 }
 
@@ -194,6 +198,9 @@
     "..:config",
     "//test/hftest:hftest_config",
   ]
+  deps = [
+    "//test/vmapi/primary_with_secondaries:util",
+  ]
 
   sources = [
     "spci_check.c",
diff --git a/test/vmapi/primary_with_secondaries/services/check_state.c b/test/vmapi/primary_with_secondaries/services/check_state.c
index a1805f9..49939dd 100644
--- a/test/vmapi/primary_with_secondaries/services/check_state.c
+++ b/test/vmapi/primary_with_secondaries/services/check_state.c
@@ -22,13 +22,14 @@
 
 #include "hftest.h"
 
-void send_with_retry()
+void send_with_retry(spci_vm_id_t sender_vm_id, spci_vm_id_t target_vm_id,
+		     uint32_t size)
 {
-	int64_t res;
+	struct spci_value res;
 
 	do {
-		res = spci_msg_send(0);
-	} while (res != SPCI_SUCCESS);
+		res = spci_msg_send(sender_vm_id, target_vm_id, size, 0);
+	} while (res.func != SPCI_SUCCESS_32);
 }
 
 /**
@@ -49,9 +50,6 @@
 	static volatile uintptr_t expected;
 	static volatile uintptr_t actual;
 
-	spci_message_init(SERVICE_SEND_BUFFER(), 0, HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-
 	for (i = 0; i < 100000; i++) {
 		/*
 		 * We store the expected/actual values in volatile static
@@ -60,16 +58,13 @@
 		 */
 		expected = i;
 		per_cpu_ptr_set(expected);
-		send_with_retry();
+		send_with_retry(hf_vm_get_id(), HF_PRIMARY_VM_ID, 0);
 		actual = per_cpu_ptr_get();
 		ok &= expected == actual;
 	}
 
 	/* Send two replies, one for each physical CPU. */
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, &ok,
-		 sizeof(ok));
-	spci_message_init(SERVICE_SEND_BUFFER(), sizeof(ok), HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-	send_with_retry();
-	send_with_retry();
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, &ok, sizeof(ok));
+	send_with_retry(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ok));
+	send_with_retry(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ok));
 }
diff --git a/test/vmapi/primary_with_secondaries/services/echo.c b/test/vmapi/primary_with_secondaries/services/echo.c
index 87695a8..0578710 100644
--- a/test/vmapi/primary_with_secondaries/services/echo.c
+++ b/test/vmapi/primary_with_secondaries/services/echo.c
@@ -28,17 +28,15 @@
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t target_vm_id = spci_msg_send_receiver(ret);
 		spci_vm_id_t source_vm_id = spci_msg_send_sender(ret);
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
 
 		ASSERT_EQ(ret.func, SPCI_MSG_SEND_32);
-		memcpy_s(send_buf->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_buf->payload, spci_msg_send_size(ret));
-		spci_message_init(SERVICE_SEND_BUFFER(),
-				  spci_msg_send_size(ret), source_vm_id,
-				  target_vm_id);
+		memcpy_s(send_buf, SPCI_MSG_PAYLOAD_MAX, recv_buf,
+			 spci_msg_send_size(ret));
 
 		hf_mailbox_clear();
-		spci_msg_send(0);
+		spci_msg_send(target_vm_id, source_vm_id,
+			      spci_msg_send_size(ret), 0);
 	}
 }
diff --git a/test/vmapi/primary_with_secondaries/services/echo_with_notification.c b/test/vmapi/primary_with_secondaries/services/echo_with_notification.c
index ffd1e12..a4954d9 100644
--- a/test/vmapi/primary_with_secondaries/services/echo_with_notification.c
+++ b/test/vmapi/primary_with_secondaries/services/echo_with_notification.c
@@ -53,18 +53,19 @@
 
 	/* Loop, echo messages back to the sender. */
 	for (;;) {
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
 		struct spci_value ret = spci_msg_wait();
 		spci_vm_id_t target_vm_id = spci_msg_send_receiver(ret);
 		spci_vm_id_t source_vm_id = spci_msg_send_sender(ret);
 
-		memcpy_s(send_buf->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_buf->payload, spci_msg_send_size(ret));
-		spci_message_init(send_buf, spci_msg_send_size(ret),
-				  source_vm_id, target_vm_id);
+		memcpy_s(send_buf, SPCI_MSG_PAYLOAD_MAX, recv_buf,
+			 spci_msg_send_size(ret));
 
-		while (spci_msg_send(SPCI_MSG_SEND_NOTIFY) != SPCI_SUCCESS) {
+		while (spci_msg_send(target_vm_id, source_vm_id,
+				     spci_msg_send_size(ret),
+				     SPCI_MSG_SEND_NOTIFY)
+			       .func != SPCI_SUCCESS_32) {
 			wait_for_vm(source_vm_id);
 		}
 
diff --git a/test/vmapi/primary_with_secondaries/services/interruptible.c b/test/vmapi/primary_with_secondaries/services/interruptible.c
index 94ac007..04ea783 100644
--- a/test/vmapi/primary_with_secondaries/services/interruptible.c
+++ b/test/vmapi/primary_with_secondaries/services/interruptible.c
@@ -39,11 +39,8 @@
 	dlog("secondary IRQ %d from current\n", interrupt_id);
 	buffer[8] = '0' + interrupt_id / 10;
 	buffer[9] = '0' + interrupt_id % 10;
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, buffer,
-		 size);
-	spci_message_init(SERVICE_SEND_BUFFER(), size, HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-	spci_msg_send(0);
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, buffer, size);
+	spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, size, 0);
 	dlog("secondary IRQ %d ended\n", interrupt_id);
 }
 
@@ -66,7 +63,7 @@
 TEST_SERVICE(interruptible)
 {
 	spci_vm_id_t this_vm_id = hf_vm_get_id();
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 
 	exception_setup(irq);
 	hf_interrupt_enable(SELF_INTERRUPT_ID, true);
@@ -83,13 +80,12 @@
 		ASSERT_EQ(ret.func, SPCI_MSG_SEND_32);
 		if (spci_msg_send_sender(ret) == HF_PRIMARY_VM_ID &&
 		    spci_msg_send_size(ret) == sizeof(ping_message) &&
-		    memcmp(recv_buf->payload, ping_message,
-			   sizeof(ping_message)) == 0) {
+		    memcmp(recv_buf, ping_message, sizeof(ping_message)) == 0) {
 			/* Interrupt ourselves */
 			hf_interrupt_inject(this_vm_id, 0, SELF_INTERRUPT_ID);
 		} else if (spci_msg_send_sender(ret) == HF_PRIMARY_VM_ID &&
 			   spci_msg_send_size(ret) == sizeof(enable_message) &&
-			   memcmp(recv_buf->payload, enable_message,
+			   memcmp(recv_buf, enable_message,
 				  sizeof(enable_message)) == 0) {
 			/* Enable interrupt ID C. */
 			hf_interrupt_enable(EXTERNAL_INTERRUPT_ID_C, true);
diff --git a/test/vmapi/primary_with_secondaries/services/interruptible_echo.c b/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
index 560c47e..814cce1 100644
--- a/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
+++ b/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
@@ -39,8 +39,8 @@
 
 	for (;;) {
 		struct spci_value res = spci_msg_wait();
-		struct spci_message *message = SERVICE_SEND_BUFFER();
-		struct spci_message *recv_message = SERVICE_RECV_BUFFER();
+		void *message = SERVICE_SEND_BUFFER();
+		void *recv_message = SERVICE_RECV_BUFFER();
 
 		/* Retry if interrupted but made visible with the yield. */
 		while (res.func == SPCI_ERROR_32 &&
@@ -50,12 +50,11 @@
 		}
 
 		ASSERT_EQ(res.func, SPCI_MSG_SEND_32);
-		memcpy_s(message->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_message->payload, spci_msg_send_size(res));
-		spci_message_init(message, spci_msg_send_size(res),
-				  HF_PRIMARY_VM_ID, SERVICE_VM0);
+		memcpy_s(message, SPCI_MSG_PAYLOAD_MAX, recv_message,
+			 spci_msg_send_size(res));
 
 		hf_mailbox_clear();
-		spci_msg_send(0);
+		spci_msg_send(SERVICE_VM0, HF_PRIMARY_VM_ID,
+			      spci_msg_send_size(res), 0);
 	}
 }
diff --git a/test/vmapi/primary_with_secondaries/services/memory.c b/test/vmapi/primary_with_secondaries/services/memory.c
index bd12409..cf15554 100644
--- a/test/vmapi/primary_with_secondaries/services/memory.c
+++ b/test/vmapi/primary_with_secondaries/services/memory.c
@@ -21,6 +21,7 @@
 
 #include "hftest.h"
 #include "primary_with_secondary.h"
+#include "util.h"
 
 alignas(PAGE_SIZE) static uint8_t page[PAGE_SIZE];
 
@@ -35,10 +36,8 @@
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 
 		/* Check the memory was cleared. */
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		ptr = *(uint8_t **)recv_buf->payload;
-		spci_message_init(SERVICE_SEND_BUFFER(), sizeof(ptr),
-				  spci_msg_send_sender(ret), hf_vm_get_id());
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		ptr = *(uint8_t **)recv_buf;
 
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ASSERT_EQ(ptr[i], 0);
@@ -54,7 +53,8 @@
 
 		/* Signal completion and reset. */
 		hf_mailbox_clear();
-		spci_msg_send(0);
+		spci_msg_send(hf_vm_get_id(), spci_msg_send_sender(ret),
+			      sizeof(ptr), 0);
 	}
 }
 
@@ -64,11 +64,14 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
+		uint32_t msg_size;
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
@@ -85,10 +88,11 @@
 
 		hf_mailbox_clear();
 		/* Give the memory back and notify the sender. */
-		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		spci_msg_send(0);
+		msg_size = spci_memory_relinquish_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0);
+		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
 
 		/*
 		 * Try and access the memory which will cause a fault unless the
@@ -108,10 +112,8 @@
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 
 		/* Check the memory was cleared. */
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		ptr = *(uint8_t **)recv_buf->payload;
-		spci_message_init(SERVICE_SEND_BUFFER(), sizeof(ptr),
-				  spci_msg_send_sender(ret), hf_vm_get_id());
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		ptr = *(uint8_t **)recv_buf;
 
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ASSERT_EQ(ptr[i], 0);
@@ -123,7 +125,8 @@
 					  HF_MEMORY_GIVE),
 			  0);
 		hf_mailbox_clear();
-		spci_msg_send(0);
+		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
@@ -147,11 +150,12 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, &ptr,
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, &ptr,
 		 sizeof(ptr));
-	spci_message_init(SERVICE_SEND_BUFFER(), sizeof(ptr), HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-	EXPECT_EQ(spci_msg_send(0), 0);
+	EXPECT_EQ(
+		spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ptr), 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	/* Try using the memory that isn't valid unless it's been returned. */
 	page[16] = 123;
@@ -171,11 +175,12 @@
 	 *       API is still to be agreed on so the address is passed
 	 *       explicitly to test the mechanism.
 	 */
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, &ptr,
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, &ptr,
 		 sizeof(ptr));
-	spci_message_init(SERVICE_SEND_BUFFER(), sizeof(ptr), HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
-	EXPECT_EQ(spci_msg_send(0), 0);
+	EXPECT_EQ(
+		spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(ptr), 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	/* Try using the memory that isn't valid unless it's been returned. */
 	page[633] = 180;
@@ -187,12 +192,15 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		uint32_t msg_size;
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			spci_get_donated_memory_region(recv_buf);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -203,10 +211,11 @@
 		}
 
 		/* Give the memory back and notify the sender. */
-		spci_memory_donate(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		spci_msg_send(0);
+		msg_size = spci_memory_donate_init(send_buf,
+						   memory_region->constituents,
+						   memory_region->count, 0);
+		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
 
 		/*
 		 * Try and access the memory which will cause a fault unless the
@@ -220,11 +229,12 @@
 {
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -237,11 +247,12 @@
 {
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -257,21 +268,25 @@
 {
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+	uint32_t msg_size;
+	void *recv_buf = SERVICE_RECV_BUFFER();
+	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
 
 	/* Donate memory to next VM. */
-	spci_memory_donate(send_buf, SERVICE_VM1, spci_msg_send_receiver(ret),
-			   memory_region->constituents, memory_region->count,
-			   0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret), SERVICE_VM1,
+				msg_size, SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Ensure that we are unable to modify memory any more. */
 	ptr[0] = 'c';
@@ -284,29 +299,37 @@
  */
 TEST_SERVICE(spci_donate_twice)
 {
+	uint32_t msg_size;
 	struct spci_value ret = spci_msg_wait();
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
+	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
 	struct spci_memory_region_constituent constituent =
 		memory_region->constituents[0];
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	/* Yield to allow attempt to re donate from primary. */
 	spci_yield();
 
 	/* Give the memory back and notify the sender. */
-	spci_memory_donate(send_buf, HF_PRIMARY_VM_ID, SERVICE_VM0,
-			   &constituent, memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(send_buf, &constituent,
+					   memory_region->count, 0);
+	EXPECT_EQ(spci_msg_send(SERVICE_VM0, HF_PRIMARY_VM_ID, msg_size,
+				SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Attempt to donate the memory to another VM. */
-	spci_memory_donate(send_buf, SERVICE_VM1, spci_msg_send_receiver(ret),
-			   &constituent, memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_donate_init(send_buf, &constituent,
+					   memory_region->count, 0);
+	EXPECT_SPCI_ERROR(
+		spci_msg_send(spci_msg_send_receiver(ret), SERVICE_VM1,
+			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY),
+		SPCI_INVALID_PARAMETERS);
 
 	spci_yield();
 }
@@ -320,11 +343,13 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
 		struct spci_memory_region *memory_region =
 			spci_get_donated_memory_region(recv_buf);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -342,26 +367,31 @@
  */
 TEST_SERVICE(spci_donate_invalid_source)
 {
+	uint32_t msg_size;
 	struct spci_value ret = spci_msg_wait();
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
+	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	/* Give the memory back and notify the sender. */
-	spci_memory_donate(
-		send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-		memory_region->constituents, memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_donate_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+				msg_size, SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Fail to donate the memory from the primary to VM1. */
-	spci_memory_donate(send_buf, SERVICE_VM1, HF_PRIMARY_VM_ID,
-			   memory_region->constituents, memory_region->count,
-			   0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_donate_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 	spci_yield();
 }
 
@@ -371,15 +401,18 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
+		uint32_t msg_size;
 
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
 							      ->payload);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		ptr = (uint8_t *)memory_region->constituents[0].address;
 		/* Relevant information read, mailbox can be cleared. */
 		hf_mailbox_clear();
@@ -391,10 +424,11 @@
 
 		hf_mailbox_clear();
 		/* Give the memory back and notify the sender. */
-		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		spci_msg_send(0);
+		msg_size = spci_memory_relinquish_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0);
+		spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY);
 
 		/*
 		 * Try and access the memory which will cause a fault unless the
@@ -412,13 +446,16 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
+		uint32_t msg_size;
 
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			spci_get_donated_memory_region(recv_buf);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -428,10 +465,13 @@
 			ptr[i]++;
 		}
 		/* Give the memory back and notify the sender. */
-		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_relinquish_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0);
+		EXPECT_SPCI_ERROR(spci_msg_send(spci_msg_send_receiver(ret),
+						HF_PRIMARY_VM_ID, msg_size,
+						SPCI_MSG_SEND_LEGACY_MEMORY),
+				  SPCI_INVALID_PARAMETERS);
 
 		/* Ensure we still have access to the memory. */
 		ptr[0] = 123;
@@ -445,35 +485,43 @@
  */
 TEST_SERVICE(spci_lend_invalid_source)
 {
+	uint32_t msg_size;
 	struct spci_value ret = spci_msg_wait();
 
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
+	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region *memory_region =
 		(struct spci_memory_region *)(spci_get_lend_descriptor(recv_buf)
 						      ->payload);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	/* Attempt to relinquish from primary VM. */
-	spci_memory_relinquish(send_buf, spci_msg_send_receiver(ret),
-			       HF_PRIMARY_VM_ID, memory_region->constituents,
-			       memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_relinquish_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_SPCI_ERROR(
+		spci_msg_send(HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
+			      msg_size, SPCI_MSG_SEND_LEGACY_MEMORY),
+		SPCI_INVALID_PARAMETERS);
 
 	/* Give the memory back and notify the sender. */
-	spci_memory_relinquish(
-		send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-		memory_region->constituents, memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_relinquish_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+				msg_size, SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 
 	/* Ensure we cannot lend from the primary to another secondary. */
-	spci_memory_lend(send_buf, SERVICE_VM1, HF_PRIMARY_VM_ID,
-			 memory_region->constituents, memory_region->count, 0,
-			 SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			 SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	msg_size = spci_memory_lend_init(
+		send_buf, memory_region->constituents, memory_region->count, 0,
+		SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
+		SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
+	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY),
+			  SPCI_INVALID_PARAMETERS);
 	spci_yield();
 }
 
@@ -485,15 +533,18 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint64_t *ptr;
+		uint32_t msg_size;
 
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
 							      ->payload);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		hf_mailbox_clear();
 
 		ptr = (uint64_t *)memory_region->constituents[0].address;
@@ -506,10 +557,14 @@
 		__asm__ volatile("blr %0" ::"r"(ptr));
 
 		/* Release the memory again. */
-		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+		msg_size = spci_memory_relinquish_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0);
+		EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret),
+					HF_PRIMARY_VM_ID, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY)
+				  .func,
+			  SPCI_SUCCESS_32);
 	}
 }
 
@@ -521,15 +576,18 @@
 	for (;;) {
 		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
+		uint32_t msg_size;
 
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
 							      ->payload);
 
 		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_attributes(ret),
+			  SPCI_MSG_SEND_LEGACY_MEMORY);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -547,10 +605,14 @@
 			ptr[i]++;
 		}
 
-		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-			memory_region->constituents, memory_region->count, 0);
-		EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+		msg_size = spci_memory_relinquish_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0);
+		EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret),
+					HF_PRIMARY_VM_ID, msg_size,
+					SPCI_MSG_SEND_LEGACY_MEMORY)
+				  .func,
+			  SPCI_SUCCESS_32);
 	}
 }
 
@@ -562,12 +624,13 @@
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_memory_region *memory_region =
 		(struct spci_memory_region *)(spci_get_lend_descriptor(recv_buf)
 						      ->payload);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -584,12 +647,13 @@
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_memory_region *memory_region =
 		(struct spci_memory_region *)(spci_get_lend_descriptor(recv_buf)
 						      ->payload);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -602,14 +666,16 @@
 {
 	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
+	uint32_t msg_size;
 
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-	struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
+	void *send_buf = SERVICE_SEND_BUFFER();
 	struct spci_memory_region *memory_region =
 		(struct spci_memory_region *)(spci_get_lend_descriptor(recv_buf)
 						      ->payload);
 
 	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_attributes(ret), SPCI_MSG_SEND_LEGACY_MEMORY);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -631,16 +697,21 @@
 		memory_region->constituents[0].address = (uint64_t)ptr + i;
 
 		/* Fail to lend the memory back to the primary. */
-		spci_memory_lend(
-			send_buf, SERVICE_VM1, HF_PRIMARY_VM_ID,
-			memory_region->constituents, memory_region->count, 0,
-			SPCI_LEND_RW_X, SPCI_LEND_NORMAL_MEM,
-			SPCI_LEND_CACHE_WRITE_BACK, SPCI_LEND_OUTER_SHAREABLE);
-		EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+		msg_size = spci_memory_lend_init(
+			send_buf, memory_region->constituents,
+			memory_region->count, 0, SPCI_LEND_RW_X,
+			SPCI_LEND_NORMAL_MEM, SPCI_LEND_CACHE_WRITE_BACK,
+			SPCI_LEND_OUTER_SHAREABLE);
+		EXPECT_SPCI_ERROR(
+			spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM1, msg_size,
+				      SPCI_MSG_SEND_LEGACY_MEMORY),
+			SPCI_INVALID_PARAMETERS);
 	}
 
-	spci_memory_relinquish(
-		send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
-		memory_region->constituents, memory_region->count, 0);
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	msg_size = spci_memory_relinquish_init(
+		send_buf, memory_region->constituents, memory_region->count, 0);
+	EXPECT_EQ(spci_msg_send(spci_msg_send_receiver(ret), HF_PRIMARY_VM_ID,
+				msg_size, SPCI_MSG_SEND_LEGACY_MEMORY)
+			  .func,
+		  SPCI_SUCCESS_32);
 }
diff --git a/test/vmapi/primary_with_secondaries/services/receive_block.c b/test/vmapi/primary_with_secondaries/services/receive_block.c
index 666754f..c8c4de2 100644
--- a/test/vmapi/primary_with_secondaries/services/receive_block.c
+++ b/test/vmapi/primary_with_secondaries/services/receive_block.c
@@ -24,6 +24,7 @@
 
 #include "hftest.h"
 #include "primary_with_secondary.h"
+#include "util.h"
 
 /*
  * Secondary VM that enables an interrupt, disables interrupts globally, and
@@ -47,14 +48,11 @@
 
 	for (i = 0; i < 10; ++i) {
 		struct spci_value res = spci_msg_wait();
-		EXPECT_EQ(res.func, SPCI_ERROR_32);
-		EXPECT_EQ(res.arg1, SPCI_INTERRUPTED);
+		EXPECT_SPCI_ERROR(res, SPCI_INTERRUPTED);
 	}
 
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, message,
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, message,
 		 sizeof(message));
-	spci_message_init(SERVICE_SEND_BUFFER(), sizeof(message),
-			  HF_PRIMARY_VM_ID, hf_vm_get_id());
 
-	spci_msg_send(0);
+	spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(message), 0);
 }
diff --git a/test/vmapi/primary_with_secondaries/services/relay.c b/test/vmapi/primary_with_secondaries/services/relay.c
index 1003699..61e26b9 100644
--- a/test/vmapi/primary_with_secondaries/services/relay.c
+++ b/test/vmapi/primary_with_secondaries/services/relay.c
@@ -40,23 +40,21 @@
 		ASSERT_EQ(ret.func, SPCI_MSG_SEND_32);
 
 		/* Prepare to relay the message. */
-		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
-		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
+		void *recv_buf = SERVICE_RECV_BUFFER();
+		void *send_buf = SERVICE_SEND_BUFFER();
 		ASSERT_GE(spci_msg_send_size(ret), sizeof(spci_vm_id_t));
 
-		chain = (spci_vm_id_t *)recv_buf->payload;
+		chain = (spci_vm_id_t *)recv_buf;
 		next_vm_id = le16toh(*chain);
 		next_message = chain + 1;
 		next_message_size =
 			spci_msg_send_size(ret) - sizeof(spci_vm_id_t);
 
 		/* Send the message to the next stage. */
-		memcpy_s(send_buf->payload, SPCI_MSG_PAYLOAD_MAX, next_message,
+		memcpy_s(send_buf, SPCI_MSG_PAYLOAD_MAX, next_message,
 			 next_message_size);
-		spci_message_init(send_buf, next_message_size, next_vm_id,
-				  hf_vm_get_id());
 
 		hf_mailbox_clear();
-		spci_msg_send(0);
+		spci_msg_send(hf_vm_get_id(), next_vm_id, next_message_size, 0);
 	}
 }
diff --git a/test/vmapi/primary_with_secondaries/services/smp.c b/test/vmapi/primary_with_secondaries/services/smp.c
index 5ad31d0..cd8fe9e 100644
--- a/test/vmapi/primary_with_secondaries/services/smp.c
+++ b/test/vmapi/primary_with_secondaries/services/smp.c
@@ -41,12 +41,10 @@
 /** Send a message back to the primary. */
 void send_message(const char *message, uint32_t size)
 {
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 size);
-	spci_message_init(SERVICE_SEND_BUFFER(), size, HF_PRIMARY_VM_ID,
-			  hf_vm_get_id());
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, message, size);
 
-	ASSERT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	ASSERT_EQ(spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, size, 0).func,
+		  SPCI_SUCCESS_32);
 }
 
 /**
diff --git a/test/vmapi/primary_with_secondaries/services/spci_check.c b/test/vmapi/primary_with_secondaries/services/spci_check.c
index 3ce9a1f..0cb1cc0 100644
--- a/test/vmapi/primary_with_secondaries/services/spci_check.c
+++ b/test/vmapi/primary_with_secondaries/services/spci_check.c
@@ -21,24 +21,12 @@
 
 #include "hftest.h"
 #include "primary_with_secondary.h"
+#include "util.h"
 
 TEST_SERVICE(spci_check)
 {
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	const char message[] = "spci_msg_send";
-	struct spci_message expected_message = {
-		.flags = SPCI_MESSAGE_IMPDEF_MASK,
-		.length = sizeof(message),
-		.target_vm_id = hf_vm_get_id(),
-		.source_vm_id = HF_PRIMARY_VM_ID,
-
-		/*
-		 * TODO: Padding fields may be set to MBZ in the next SPCI spec
-		 * versions.
-		 */
-		.reserved_1 = 0,
-		.reserved_2 = 0,
-	};
 
 	/* Wait for single message to be sent by the primary VM. */
 	struct spci_value ret = spci_msg_wait();
@@ -49,18 +37,16 @@
 	EXPECT_EQ(spci_msg_send_size(ret), sizeof(message));
 	EXPECT_EQ(spci_msg_send_receiver(ret), hf_vm_get_id());
 	EXPECT_EQ(spci_msg_send_sender(ret), HF_PRIMARY_VM_ID);
-	EXPECT_EQ(memcmp(recv_buf, &expected_message, sizeof(expected_message)),
-		  0);
 
 	/* Ensure that the payload was correctly transmitted. */
-	EXPECT_EQ(memcmp(recv_buf->payload, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(recv_buf, message, sizeof(message)), 0);
 
 	spci_yield();
 }
 
 TEST_SERVICE(spci_length)
 {
-	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
+	void *recv_buf = SERVICE_RECV_BUFFER();
 	const char message[] = "this should be truncated";
 
 	/* Wait for single message to be sent by the primary VM. */
@@ -72,9 +58,8 @@
 	EXPECT_EQ(16, spci_msg_send_size(ret));
 
 	/* Check only part of the message is sent correctly. */
-	EXPECT_NE(memcmp(recv_buf->payload, message, sizeof(message)), 0);
-	EXPECT_EQ(memcmp(recv_buf->payload, message, spci_msg_send_size(ret)),
-		  0);
+	EXPECT_NE(memcmp(recv_buf, message, sizeof(message)), 0);
+	EXPECT_EQ(memcmp(recv_buf, message, spci_msg_send_size(ret)), 0);
 
 	spci_yield();
 }
@@ -84,8 +69,7 @@
 	/* Wait for single message to be sent by the primary VM. */
 	struct spci_value ret = spci_msg_poll();
 
-	EXPECT_EQ(ret.func, SPCI_ERROR_32);
-	EXPECT_EQ(ret.arg1, SPCI_RETRY);
+	EXPECT_SPCI_ERROR(ret, SPCI_RETRY);
 
 	spci_yield();
 }
diff --git a/test/vmapi/primary_with_secondaries/services/wfi.c b/test/vmapi/primary_with_secondaries/services/wfi.c
index 6935107..7dbd372 100644
--- a/test/vmapi/primary_with_secondaries/services/wfi.c
+++ b/test/vmapi/primary_with_secondaries/services/wfi.c
@@ -48,10 +48,8 @@
 		interrupt_wait();
 	}
 
-	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, message,
+	memcpy_s(SERVICE_SEND_BUFFER(), SPCI_MSG_PAYLOAD_MAX, message,
 		 sizeof(message));
-	spci_message_init(SERVICE_SEND_BUFFER(), sizeof(message),
-			  HF_PRIMARY_VM_ID, hf_vm_get_id());
 
-	spci_msg_send(0);
+	spci_msg_send(hf_vm_get_id(), HF_PRIMARY_VM_ID, sizeof(message), 0);
 }
diff --git a/test/vmapi/primary_with_secondaries/smp.c b/test/vmapi/primary_with_secondaries/smp.c
index de91d78..af5c637 100644
--- a/test/vmapi/primary_with_secondaries/smp.c
+++ b/test/vmapi/primary_with_secondaries/smp.c
@@ -48,7 +48,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM2, 1);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response_1));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response_1,
+	EXPECT_EQ(memcmp(mb.recv, expected_response_1,
 			 sizeof(expected_response_1)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -58,7 +58,7 @@
 	run_res = hf_vcpu_run(SERVICE_VM2, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
 	EXPECT_EQ(run_res.message.size, sizeof(expected_response_0));
-	EXPECT_EQ(memcmp(mb.recv->payload, expected_response_0,
+	EXPECT_EQ(memcmp(mb.recv, expected_response_0,
 			 sizeof(expected_response_0)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
diff --git a/test/vmapi/primary_with_secondaries/spci.c b/test/vmapi/primary_with_secondaries/spci.c
index ac54da7..f551830 100644
--- a/test/vmapi/primary_with_secondaries/spci.c
+++ b/test/vmapi/primary_with_secondaries/spci.c
@@ -39,11 +39,11 @@
 	SERVICE_SELECT(SERVICE_VM0, "spci_check", mb.send);
 
 	/* Set the payload, init the message header and send the message. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0,
-			  HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), 0);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_EQ(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, sizeof(message), 0)
+			.func,
+		SPCI_SUCCESS_32);
 
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
@@ -60,10 +60,10 @@
 	SERVICE_SELECT(SERVICE_VM0, "spci_check", mb.send);
 
 	/* Set the payload, init the message header and send the message. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), SERVICE_VM0, SERVICE_VM1);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_SPCI_ERROR(
+		spci_msg_send(SERVICE_VM1, SERVICE_VM0, sizeof(message), 0),
+		SPCI_INVALID_PARAMETERS);
 }
 
 /**
@@ -76,10 +76,10 @@
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_check", mb.send);
 	/* Set the payload, init the message header and send the message. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
-	spci_message_init(mb.send, sizeof(message), -1, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
+	EXPECT_SPCI_ERROR(
+		spci_msg_send(HF_PRIMARY_VM_ID, -1, sizeof(message), 0),
+		SPCI_INVALID_PARAMETERS);
 }
 
 /**
@@ -94,12 +94,10 @@
 	SERVICE_SELECT(SERVICE_VM0, "spci_length", mb.send);
 
 	/* Send the message and compare if truncated. */
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
 	/* Hard code incorrect length. */
-	spci_message_init(mb.send, 16, SERVICE_VM0, HF_PRIMARY_VM_ID);
-
-	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
+	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 16, 0).func,
+		  SPCI_SUCCESS_32);
 	run_res = hf_vcpu_run(SERVICE_VM0, 0);
 	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
 }
@@ -112,11 +110,11 @@
 	const char message[] = "fail to send";
 	struct mailbox_buffers mb = set_up_mailbox();
 
-	memcpy_s(mb.send->payload, SPCI_MSG_PAYLOAD_MAX, message,
-		 sizeof(message));
+	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
 	/* Send a message that is larger than the mailbox supports (4KB). */
-	spci_message_init(mb.send, 4 * 1024, SERVICE_VM0, HF_PRIMARY_VM_ID);
-	EXPECT_EQ(spci_msg_send(0), SPCI_INVALID_PARAMETERS);
+	EXPECT_SPCI_ERROR(
+		spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 4 * 1024 + 1, 0),
+		SPCI_INVALID_PARAMETERS);
 }
 
 /**
diff --git a/test/vmapi/primary_with_secondaries/util.c b/test/vmapi/primary_with_secondaries/util.c
index 082daf6..419ec6c 100644
--- a/test/vmapi/primary_with_secondaries/util.c
+++ b/test/vmapi/primary_with_secondaries/util.c
@@ -36,7 +36,7 @@
 {
 	ASSERT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
 	return (struct mailbox_buffers){
-		.send = ((struct spci_message *)send_page),
-		.recv = ((struct spci_message *)recv_page),
+		.send = send_page,
+		.recv = recv_page,
 	};
 }