diff --git a/inc/hf/api.h b/inc/hf/api.h
index cc45a05..ebc6b20 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -56,7 +56,8 @@
 
 spci_return_t api_spci_msg_send(uint32_t attributes, struct vcpu *current,
 				struct vcpu **next);
-int32_t api_spci_msg_recv(bool block, 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,
diff --git a/inc/hf/arch/cpu.h b/inc/hf/arch/cpu.h
index f244a3c..5a97681 100644
--- a/inc/hf/arch/cpu.h
+++ b/inc/hf/arch/cpu.h
@@ -58,4 +58,4 @@
  * This function must only be called on an arch_regs that is known not be in use
  * by any other physical CPU.
  */
-void arch_regs_set_retval(struct arch_regs *r, uintreg_t v);
+void arch_regs_set_retval(struct arch_regs *r, struct spci_value v);
diff --git a/inc/hf/spci_internal.h b/inc/hf/spci_internal.h
index 3877283..8f2a500 100644
--- a/inc/hf/spci_internal.h
+++ b/inc/hf/spci_internal.h
@@ -63,6 +63,11 @@
 	return mode;
 }
 
+static inline struct spci_value spci_error(uint64_t error_code)
+{
+	return (struct spci_value){.func = SPCI_ERROR_32, .arg1 = error_code};
+}
+
 spci_return_t spci_msg_handle_architected_message(
 	struct vm_locked to_locked, struct vm_locked from_locked,
 	const struct spci_architected_message_header
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index b99f15b..a920a58 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -138,14 +138,13 @@
  * that a message becoming available is also treated like a wake-up event.
  *
  * Returns:
- *  - SPCI_SUCCESS if a message is successfully received.
- *  - SPCI_INTERRUPTED if the caller is the primary VM or an interrupt happened
- *    during the call.
- *  - SPCI_RETRY if there was no pending message, and `block` was false.
+ *  - SPCI_MSG_SEND if a message is successfully received.
+ *  - SPCI_ERROR SPCI_NOT_SUPPORTED if called from the primary VM.
+ *  - SPCI_ERROR SPCI_INTERRUPTED if an interrupt happened during the call.
  */
-static inline int32_t spci_msg_wait(void)
+static inline struct spci_value spci_msg_wait(void)
 {
-	return hf_call(SPCI_MSG_WAIT_32, 0, 0, 0);
+	return spci_call((struct spci_value){.func = SPCI_MSG_WAIT_32});
 }
 
 /**
@@ -155,14 +154,14 @@
  * The mailbox must be cleared before a new message can be received.
  *
  * Returns:
- *  - SPCI_SUCCESS if a message is successfully received.
- *  - SPCI_INTERRUPTED if the caller is the primary VM or an interrupt happened
- *    during the call.
- *  - SPCI_RETRY if there was no pending message, and `block` was false.
+ *  - SPCI_MSG_SEND if a message is successfully received.
+ *  - SPCI_ERROR SPCI_NOT_SUPPORTED if called from the primary VM.
+ *  - SPCI_ERROR SPCI_INTERRUPTED if an interrupt happened during the call.
+ *  - SPCI_ERROR SPCI_RETRY if there was no pending message.
  */
-static inline int32_t spci_msg_poll(void)
+static inline struct spci_value spci_msg_poll(void)
 {
-	return hf_call(SPCI_MSG_POLL_32, 0, 0, 0);
+	return spci_call((struct spci_value){.func = SPCI_MSG_POLL_32});
 }
 
 /**
diff --git a/inc/vmapi/hf/spci.h b/inc/vmapi/hf/spci.h
index 0883038..125380b 100644
--- a/inc/vmapi/hf/spci.h
+++ b/inc/vmapi/hf/spci.h
@@ -193,6 +193,21 @@
 	uint64_t arg7;
 };
 
+static inline spci_vm_id_t spci_msg_send_sender(struct spci_value args)
+{
+	return (args.arg1 >> 16) & 0xffff;
+}
+
+static inline spci_vm_id_t spci_msg_send_receiver(struct spci_value args)
+{
+	return args.arg1 & 0xffff;
+}
+
+static inline uint32_t spci_msg_send_size(struct spci_value args)
+{
+	return args.arg3;
+}
+
 /** SPCI common message header. */
 struct spci_message {
 	/*
diff --git a/src/api.c b/src/api.c
index 0db632a..d2cdd11 100644
--- a/src/api.c
+++ b/src/api.c
@@ -91,8 +91,10 @@
 	}
 
 	/* Set the return value for the primary VM's call to HF_VCPU_RUN. */
-	arch_regs_set_retval(&next->regs,
-			     hf_vcpu_run_return_encode(primary_ret));
+	arch_regs_set_retval(
+		&next->regs,
+		(struct spci_value){
+			.func = hf_vcpu_run_return_encode(primary_ret)});
 
 	/* Mark the current vcpu as waiting. */
 	sl_lock(&current->lock);
@@ -343,6 +345,19 @@
 }
 
 /**
+ * Constructs an SPCI_MSG_SEND value to return from a successful SPCI_MSG_POLL
+ * or SPCI_MSG_WAIT call.
+ */
+static struct spci_value spci_msg_recv_return(const struct vm *receiver)
+{
+	return (struct spci_value){
+		.func = SPCI_MSG_SEND_32,
+		.arg1 = receiver->mailbox.recv->source_vm_id << 16 |
+			receiver->id,
+		.arg3 = receiver->mailbox.recv->length};
+}
+
+/**
  * Prepares the vcpu to run by updating its state and fetching whether a return
  * value needs to be forced onto the vCPU.
  */
@@ -422,7 +437,8 @@
 		 * be delivered directly.
 		 */
 		if (vcpu->vm->mailbox.state == MAILBOX_STATE_RECEIVED) {
-			arch_regs_set_retval(&vcpu->regs, SPCI_SUCCESS);
+			arch_regs_set_retval(&vcpu->regs,
+					     spci_msg_recv_return(vcpu->vm));
 			vcpu->vm->mailbox.state = MAILBOX_STATE_READ;
 			break;
 		}
@@ -1037,17 +1053,18 @@
  *
  * No new messages can be received until the mailbox has been cleared.
  */
-int32_t api_spci_msg_recv(bool block, struct vcpu *current, struct vcpu **next)
+struct spci_value api_spci_msg_recv(bool block, struct vcpu *current,
+				    struct vcpu **next)
 {
 	struct vm *vm = current->vm;
-	int32_t return_code;
+	struct spci_value return_code;
 
 	/*
 	 * The primary VM will receive messages as a status code from running
 	 * vcpus and must not call this function.
 	 */
 	if (vm->id == HF_PRIMARY_VM_ID) {
-		return SPCI_INTERRUPTED;
+		return spci_error(SPCI_NOT_SUPPORTED);
 	}
 
 	sl_lock(&vm->lock);
@@ -1055,13 +1072,13 @@
 	/* Return pending messages without blocking. */
 	if (vm->mailbox.state == MAILBOX_STATE_RECEIVED) {
 		vm->mailbox.state = MAILBOX_STATE_READ;
-		return_code = SPCI_SUCCESS;
+		return_code = spci_msg_recv_return(vm);
 		goto out;
 	}
 
 	/* No pending message so fail if not allowed to block. */
 	if (!block) {
-		return_code = SPCI_RETRY;
+		return_code = spci_error(SPCI_RETRY);
 		goto out;
 	}
 
@@ -1070,7 +1087,7 @@
 	 * received. If a message is received the return value will be set at
 	 * that time to SPCI_SUCCESS.
 	 */
-	return_code = SPCI_INTERRUPTED;
+	return_code = spci_error(SPCI_INTERRUPTED);
 	if (api_spci_msg_recv_block_interrupted(current)) {
 		goto out;
 	}
diff --git a/src/arch/aarch64/cpu.c b/src/arch/aarch64/cpu.c
index 50b295e..0fe4e3e 100644
--- a/src/arch/aarch64/cpu.c
+++ b/src/arch/aarch64/cpu.c
@@ -21,6 +21,7 @@
 #include <stdint.h>
 
 #include "hf/addr.h"
+#include "hf/spci.h"
 #include "hf/std.h"
 
 #include "hypervisor/perfmon.h"
@@ -129,7 +130,14 @@
 	r->r[0] = arg;
 }
 
-void arch_regs_set_retval(struct arch_regs *r, uintreg_t v)
+void arch_regs_set_retval(struct arch_regs *r, struct spci_value v)
 {
-	r->r[0] = v;
+	r->r[0] = v.func;
+	r->r[1] = v.arg1;
+	r->r[2] = v.arg2;
+	r->r[3] = v.arg3;
+	r->r[4] = v.arg4;
+	r->r[5] = v.arg5;
+	r->r[6] = v.arg6;
+	r->r[7] = v.arg7;
 }
diff --git a/src/arch/aarch64/hypervisor/handler.c b/src/arch/aarch64/hypervisor/handler.c
index 26b5496..d58a600 100644
--- a/src/arch/aarch64/hypervisor/handler.c
+++ b/src/arch/aarch64/hypervisor/handler.c
@@ -320,10 +320,10 @@
 		args->func = api_spci_msg_send(args->arg1, current(), next);
 		return true;
 	case SPCI_MSG_WAIT_32:
-		args->func = api_spci_msg_recv(true, current(), next);
+		*args = api_spci_msg_recv(true, current(), next);
 		return true;
 	case SPCI_MSG_POLL_32:
-		args->func = api_spci_msg_recv(false, current(), next);
+		*args = api_spci_msg_recv(false, current(), next);
 		return true;
 	}
 
diff --git a/src/arch/fake/hypervisor/cpu.c b/src/arch/fake/hypervisor/cpu.c
index f5885fd..71d6f92 100644
--- a/src/arch/fake/hypervisor/cpu.c
+++ b/src/arch/fake/hypervisor/cpu.c
@@ -16,6 +16,8 @@
 
 #include "hf/arch/cpu.h"
 
+#include "hf/spci.h"
+
 void arch_irq_disable(void)
 {
 	/* TODO */
@@ -42,7 +44,14 @@
 	r->r[0] = arg;
 }
 
-void arch_regs_set_retval(struct arch_regs *r, uintreg_t v)
+void arch_regs_set_retval(struct arch_regs *r, struct spci_value v)
 {
-	r->r[0] = v;
+	r->r[0] = v.func;
+	r->r[1] = v.arg1;
+	r->r[2] = v.arg2;
+	r->r[3] = v.arg3;
+	r->r[4] = v.arg4;
+	r->r[5] = v.arg5;
+	r->r[6] = v.arg6;
+	r->r[7] = v.arg7;
 }
diff --git a/src/arch/fake/inc/hf/arch/types.h b/src/arch/fake/inc/hf/arch/types.h
index 8a0eccb..24e16ae 100644
--- a/src/arch/fake/inc/hf/arch/types.h
+++ b/src/arch/fake/inc/hf/arch/types.h
@@ -46,7 +46,7 @@
 
 /** Type to represent the register state of a VM.  */
 struct arch_regs {
-	uintreg_t r[5];
+	uintreg_t r[8];
 	cpu_id_t vcpu_id;
 	bool virtual_interrupt;
 };
diff --git a/test/hftest/service.c b/test/hftest/service.c
index 3031772..c04c253 100644
--- a/test/hftest/service.c
+++ b/test/hftest/service.c
@@ -82,6 +82,7 @@
 	struct memiter args;
 	hftest_test_fn service;
 	struct hftest_context *ctx;
+	struct spci_value ret;
 
 	/*
 	 * Initialize the stage-1 MMU and identity-map the entire address space.
@@ -102,8 +103,8 @@
 	hf_vm_configure(send_addr, recv_addr);
 
 	/* Receive the name of the service to run. */
-	spci_msg_wait();
-	memiter_init(&args, recv_msg->payload, recv_msg->length);
+	ret = spci_msg_wait();
+	memiter_init(&args, recv_msg->payload, spci_msg_send_size(ret));
 	service = find_service(&args);
 	hf_mailbox_clear();
 
diff --git a/test/linux/hftest_socket.c b/test/linux/hftest_socket.c
index 7a9d7f1..7caf1bb 100644
--- a/test/linux/hftest_socket.c
+++ b/test/linux/hftest_socket.c
@@ -79,26 +79,28 @@
 	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. */
-		spci_msg_wait();
-		EXPECT_LE(recv_buf->length, SPCI_MSG_PAYLOAD_MAX);
+		ret = spci_msg_wait();
+		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, recv_buf->length);
+			 recv_buf->payload, 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;
 		swap(&(hdr->src_port), &(hdr->dst_port));
 
 		/* Swap the destination and source ids. */
-		spci_vm_id_t dst_id = recv_buf->source_vm_id;
-		spci_vm_id_t src_id = recv_buf->target_vm_id;
+		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, recv_buf->length, dst_id, src_id);
+		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);
diff --git a/test/vmapi/arch/aarch64/gicv3/services/common.c b/test/vmapi/arch/aarch64/gicv3/services/common.c
index d5d3cd2..1a10fbd 100644
--- a/test/vmapi/arch/aarch64/gicv3/services/common.c
+++ b/test/vmapi/arch/aarch64/gicv3/services/common.c
@@ -19,17 +19,19 @@
 #include "vmapi/hf/call.h"
 
 #include "hftest.h"
+
 /**
  * Try to receive a message from the mailbox, blocking if necessary, and
  * retrying if interrupted.
  */
-int32_t mailbox_receive_retry(void)
+struct spci_value mailbox_receive_retry(void)
 {
-	int32_t received;
+	struct spci_value received;
 
 	do {
 		received = spci_msg_wait();
-	} while (received == SPCI_INTERRUPTED);
+	} while (received.func == SPCI_ERROR_32 &&
+		 received.arg1 == SPCI_INTERRUPTED);
 
 	return received;
 }
diff --git a/test/vmapi/arch/aarch64/gicv3/services/common.h b/test/vmapi/arch/aarch64/gicv3/services/common.h
index 635fa0f..ced8baf 100644
--- a/test/vmapi/arch/aarch64/gicv3/services/common.h
+++ b/test/vmapi/arch/aarch64/gicv3/services/common.h
@@ -14,6 +14,6 @@
  * limitations under the License.
  */
 
-#include "vmapi/hf/call.h"
+#include "vmapi/hf/spci.h"
 
-int32_t mailbox_receive_retry(void);
+struct spci_value mailbox_receive_retry(void);
diff --git a/test/vmapi/arch/aarch64/gicv3/services/timer.c b/test/vmapi/arch/aarch64/gicv3/services/timer.c
index d99aa78..5d3dd2d 100644
--- a/test/vmapi/arch/aarch64/gicv3/services/timer.c
+++ b/test/vmapi/arch/aarch64/gicv3/services/timer.c
@@ -49,7 +49,7 @@
 	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, buffer,
 		 size);
 	spci_message_init(SERVICE_SEND_BUFFER(), size, HF_PRIMARY_VM_ID,
-			  SERVICE_RECV_BUFFER()->target_vm_id);
+			  hf_vm_get_id());
 	spci_msg_send(0);
 	dlog("secondary IRQ %d ended\n", interrupt_id);
 	event_send_local();
@@ -68,13 +68,13 @@
 		bool wfi, wfe, receive;
 		bool disable_interrupts;
 		uint32_t ticks;
-		mailbox_receive_retry();
+		struct spci_value ret = mailbox_receive_retry();
 
-		if (message_header->source_vm_id != HF_PRIMARY_VM_ID ||
-		    message_header->length != sizeof(timer_wfi_message)) {
+		if (spci_msg_send_sender(ret) != HF_PRIMARY_VM_ID ||
+		    spci_msg_send_size(ret) != sizeof(timer_wfi_message)) {
 			FAIL("Got unexpected message from VM %d, size %d.\n",
-			     message_header->source_vm_id,
-			     message_header->length);
+			     spci_msg_send_sender(ret),
+			     spci_msg_send_size(ret));
 		}
 
 		message = message_header->payload;
@@ -113,9 +113,10 @@
 				event_wait();
 			}
 		} else if (receive) {
-			int32_t res = spci_msg_wait();
+			struct spci_value res = spci_msg_wait();
 
-			EXPECT_EQ(res, SPCI_INTERRUPTED);
+			EXPECT_EQ(res.func, SPCI_ERROR_32);
+			EXPECT_EQ(res.arg1, SPCI_INTERRUPTED);
 		} else {
 			/* Busy wait until the timer fires. */
 			while (!timer_fired) {
diff --git a/test/vmapi/primary_with_secondaries/no_services.c b/test/vmapi/primary_with_secondaries/no_services.c
index 40da63d..0f60bed 100644
--- a/test/vmapi/primary_with_secondaries/no_services.c
+++ b/test/vmapi/primary_with_secondaries/no_services.c
@@ -166,8 +166,8 @@
  */
 TEST(hf_mailbox_receive, cannot_receive_from_primary_blocking)
 {
-	int32_t res = spci_msg_wait();
-	EXPECT_NE(res, SPCI_SUCCESS);
+	struct spci_value res = spci_msg_wait();
+	EXPECT_NE(res.func, SPCI_SUCCESS_32);
 }
 
 /**
@@ -175,6 +175,6 @@
  */
 TEST(hf_mailbox_receive, cannot_receive_from_primary_non_blocking)
 {
-	int32_t res = spci_msg_poll();
-	EXPECT_NE(res, SPCI_SUCCESS);
+	struct spci_value res = spci_msg_poll();
+	EXPECT_NE(res.func, SPCI_SUCCESS_32);
 }
diff --git a/test/vmapi/primary_with_secondaries/services/echo.c b/test/vmapi/primary_with_secondaries/services/echo.c
index a9d5b02..87695a8 100644
--- a/test/vmapi/primary_with_secondaries/services/echo.c
+++ b/test/vmapi/primary_with_secondaries/services/echo.c
@@ -25,15 +25,18 @@
 {
 	/* Loop, echo messages back to the sender. */
 	for (;;) {
-		spci_msg_wait();
+		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();
 
+		ASSERT_EQ(ret.func, SPCI_MSG_SEND_32);
 		memcpy_s(send_buf->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_buf->payload, recv_buf->length);
-		spci_message_init(SERVICE_SEND_BUFFER(), recv_buf->length,
-				  recv_buf->source_vm_id,
-				  recv_buf->target_vm_id);
+			 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);
 
 		hf_mailbox_clear();
 		spci_msg_send(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 b32a6f6..ffd1e12 100644
--- a/test/vmapi/primary_with_secondaries/services/echo_with_notification.c
+++ b/test/vmapi/primary_with_secondaries/services/echo_with_notification.c
@@ -53,19 +53,19 @@
 
 	/* Loop, echo messages back to the sender. */
 	for (;;) {
-		spci_msg_wait();
-
 		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_message *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, recv_buf->length);
-		spci_message_init(send_buf, recv_buf->length,
-				  recv_buf->source_vm_id,
-				  recv_buf->target_vm_id);
+			 recv_buf->payload, spci_msg_send_size(ret));
+		spci_message_init(send_buf, spci_msg_send_size(ret),
+				  source_vm_id, target_vm_id);
 
 		while (spci_msg_send(SPCI_MSG_SEND_NOTIFY) != SPCI_SUCCESS) {
-			wait_for_vm(recv_buf->source_vm_id);
+			wait_for_vm(source_vm_id);
 		}
 
 		hf_mailbox_clear();
diff --git a/test/vmapi/primary_with_secondaries/services/interruptible.c b/test/vmapi/primary_with_secondaries/services/interruptible.c
index adc9b16..94ac007 100644
--- a/test/vmapi/primary_with_secondaries/services/interruptible.c
+++ b/test/vmapi/primary_with_secondaries/services/interruptible.c
@@ -51,13 +51,14 @@
  * Try to receive a message from the mailbox, blocking if necessary, and
  * retrying if interrupted.
  */
-int32_t mailbox_receive_retry()
+struct spci_value mailbox_receive_retry()
 {
-	int32_t received;
+	struct spci_value received;
 
 	do {
 		received = spci_msg_wait();
-	} while (received == SPCI_INTERRUPTED);
+	} while (received.func == SPCI_ERROR_32 &&
+		 received.arg1 == SPCI_INTERRUPTED);
 
 	return received;
 }
@@ -77,22 +78,25 @@
 		const char ping_message[] = "Ping";
 		const char enable_message[] = "Enable interrupt C";
 
-		mailbox_receive_retry();
-		if (recv_buf->source_vm_id == HF_PRIMARY_VM_ID &&
-		    recv_buf->length == sizeof(ping_message) &&
+		struct spci_value ret = mailbox_receive_retry();
+
+		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) {
 			/* Interrupt ourselves */
 			hf_interrupt_inject(this_vm_id, 0, SELF_INTERRUPT_ID);
-		} else if (recv_buf->source_vm_id == HF_PRIMARY_VM_ID &&
-			   recv_buf->length == sizeof(enable_message) &&
+		} 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,
 				  sizeof(enable_message)) == 0) {
 			/* Enable interrupt ID C. */
 			hf_interrupt_enable(EXTERNAL_INTERRUPT_ID_C, true);
 		} else {
 			dlog("Got unexpected message from VM %d, size %d.\n",
-			     recv_buf->source_vm_id, recv_buf->length);
+			     spci_msg_send_sender(ret),
+			     spci_msg_send_size(ret));
 			FAIL("Unexpected message");
 		}
 		hf_mailbox_clear();
diff --git a/test/vmapi/primary_with_secondaries/services/interruptible_echo.c b/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
index 07a4cbc..560c47e 100644
--- a/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
+++ b/test/vmapi/primary_with_secondaries/services/interruptible_echo.c
@@ -38,19 +38,21 @@
 	arch_irq_enable();
 
 	for (;;) {
-		uint32_t res = spci_msg_wait();
+		struct spci_value res = spci_msg_wait();
 		struct spci_message *message = SERVICE_SEND_BUFFER();
 		struct spci_message *recv_message = SERVICE_RECV_BUFFER();
 
 		/* Retry if interrupted but made visible with the yield. */
-		while (res == SPCI_INTERRUPTED) {
+		while (res.func == SPCI_ERROR_32 &&
+		       res.arg1 == SPCI_INTERRUPTED) {
 			spci_yield();
 			res = spci_msg_wait();
 		}
 
+		ASSERT_EQ(res.func, SPCI_MSG_SEND_32);
 		memcpy_s(message->payload, SPCI_MSG_PAYLOAD_MAX,
-			 recv_message->payload, recv_message->length);
-		spci_message_init(message, recv_message->length,
+			 recv_message->payload, spci_msg_send_size(res));
+		spci_message_init(message, spci_msg_send_size(res),
 				  HF_PRIMARY_VM_ID, SERVICE_VM0);
 
 		hf_mailbox_clear();
diff --git a/test/vmapi/primary_with_secondaries/services/memory.c b/test/vmapi/primary_with_secondaries/services/memory.c
index 8e4dc6f..bd12409 100644
--- a/test/vmapi/primary_with_secondaries/services/memory.c
+++ b/test/vmapi/primary_with_secondaries/services/memory.c
@@ -28,15 +28,17 @@
 {
 	/* Loop, writing message to the shared memory. */
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), 0);
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 		size_t i;
 
+		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),
-				  recv_buf->source_vm_id, hf_vm_get_id());
+				  spci_msg_send_sender(ret), hf_vm_get_id());
 
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ASSERT_EQ(ptr[i], 0);
@@ -60,9 +62,11 @@
 {
 	/* Loop, giving memory back to the sender. */
 	for (;;) {
-		spci_msg_wait();
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
+
 		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
 		struct spci_message *send_buf = SERVICE_SEND_BUFFER();
 		struct spci_memory_region *memory_region =
@@ -82,7 +86,7 @@
 		hf_mailbox_clear();
 		/* Give the memory back and notify the sender. */
 		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
 			memory_region->constituents, memory_region->count, 0);
 		spci_msg_send(0);
 
@@ -98,21 +102,23 @@
 {
 	/* Loop, giving memory back to the sender. */
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), 0);
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 
+		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),
-				  recv_buf->source_vm_id, hf_vm_get_id());
+				  spci_msg_send_sender(ret), hf_vm_get_id());
 
 		for (int i = 0; i < PAGE_SIZE; ++i) {
 			ASSERT_EQ(ptr[i], 0);
 		}
 
 		/* Give the memory back and notify the sender. */
-		ASSERT_EQ(hf_share_memory(recv_buf->source_vm_id,
+		ASSERT_EQ(hf_share_memory(spci_msg_send_sender(ret),
 					  (hf_ipaddr_t)ptr, PAGE_SIZE,
 					  HF_MEMORY_GIVE),
 			  0);
@@ -179,13 +185,14 @@
 {
 	/* Loop, giving memory back to the sender. */
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), 0);
+		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();
 		struct spci_memory_region *memory_region =
 			spci_get_donated_memory_region(recv_buf);
+
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -197,7 +204,7 @@
 
 		/* Give the memory back and notify the sender. */
 		spci_memory_donate(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
 			memory_region->constituents, memory_region->count, 0);
 		spci_msg_send(0);
 
@@ -211,12 +218,13 @@
 
 TEST_SERVICE(spci_donate_check_upper_bound)
 {
-	EXPECT_EQ(spci_msg_wait(), 0);
+	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
-
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -227,12 +235,13 @@
 
 TEST_SERVICE(spci_donate_check_lower_bound)
 {
-	EXPECT_EQ(spci_msg_wait(), 0);
+	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
-
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -246,19 +255,20 @@
  */
 TEST_SERVICE(spci_donate_secondary_and_fault)
 {
-	EXPECT_EQ(spci_msg_wait(), 0);
+	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();
 	struct spci_memory_region *memory_region =
 		spci_get_donated_memory_region(recv_buf);
+
+	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
 
 	/* Donate memory to next VM. */
-	spci_memory_donate(send_buf, SERVICE_VM1, recv_buf->target_vm_id,
+	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);
@@ -274,14 +284,15 @@
  */
 TEST_SERVICE(spci_donate_twice)
 {
-	EXPECT_EQ(spci_msg_wait(), 0);
-
+	struct spci_value ret = spci_msg_wait();
 	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	/* Yield to allow attempt to re donate from primary. */
@@ -293,7 +304,7 @@
 	EXPECT_EQ(spci_msg_send(0), SPCI_SUCCESS);
 
 	/* Attempt to donate the memory to another VM. */
-	spci_memory_donate(send_buf, SERVICE_VM1, recv_buf->target_vm_id,
+	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);
 
@@ -307,12 +318,13 @@
 TEST_SERVICE(spci_memory_receive)
 {
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), 0);
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
-
 		struct spci_message *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);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -330,18 +342,19 @@
  */
 TEST_SERVICE(spci_donate_invalid_source)
 {
-	EXPECT_EQ(spci_msg_wait(), 0);
-
+	struct spci_value ret = spci_msg_wait();
 	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	/* Give the memory back and notify the sender. */
-	spci_memory_donate(send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
-			   memory_region->constituents, memory_region->count,
-			   0);
+	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);
 
 	/* Fail to donate the memory from the primary to VM1. */
@@ -356,7 +369,7 @@
 {
 	/* Loop, giving memory back to the sender. */
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 
 		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
@@ -366,6 +379,7 @@
 							      recv_buf)
 							      ->payload);
 
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		ptr = (uint8_t *)memory_region->constituents[0].address;
 		/* Relevant information read, mailbox can be cleared. */
 		hf_mailbox_clear();
@@ -378,7 +392,7 @@
 		hf_mailbox_clear();
 		/* Give the memory back and notify the sender. */
 		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			send_buf, HF_PRIMARY_VM_ID, spci_msg_send_receiver(ret),
 			memory_region->constituents, memory_region->count, 0);
 		spci_msg_send(0);
 
@@ -396,13 +410,15 @@
 TEST_SERVICE(spci_memory_donate_relinquish)
 {
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+		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();
 		struct spci_memory_region *memory_region =
 			spci_get_donated_memory_region(recv_buf);
+
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -413,7 +429,7 @@
 		}
 		/* Give the memory back and notify the sender. */
 		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			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);
 
@@ -429,24 +445,26 @@
  */
 TEST_SERVICE(spci_lend_invalid_source)
 {
-	EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+	struct spci_value ret = spci_msg_wait();
 
 	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	/* Attempt to relinquish from primary VM. */
-	spci_memory_relinquish(send_buf, recv_buf->target_vm_id,
+	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);
 
 	/* Give the memory back and notify the sender. */
 	spci_memory_relinquish(
-		send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+		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);
 
@@ -465,7 +483,7 @@
 TEST_SERVICE(spci_memory_lend_relinquish_X)
 {
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+		struct spci_value ret = spci_msg_wait();
 		uint64_t *ptr;
 
 		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
@@ -474,6 +492,8 @@
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
 							      ->payload);
+
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		hf_mailbox_clear();
 
 		ptr = (uint64_t *)memory_region->constituents[0].address;
@@ -487,7 +507,7 @@
 
 		/* Release the memory again. */
 		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			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);
 	}
@@ -499,7 +519,7 @@
 TEST_SERVICE(spci_memory_lend_relinquish_RW)
 {
 	for (;;) {
-		EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+		struct spci_value ret = spci_msg_wait();
 		uint8_t *ptr;
 
 		struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
@@ -508,6 +528,8 @@
 			(struct spci_memory_region *)(spci_get_lend_descriptor(
 							      recv_buf)
 							      ->payload);
+
+		EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 		hf_mailbox_clear();
 
 		ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -526,7 +548,7 @@
 		}
 
 		spci_memory_relinquish(
-			send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+			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);
 	}
@@ -537,13 +559,15 @@
  */
 TEST_SERVICE(spci_lend_check_lower_bound)
 {
-	EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -557,13 +581,15 @@
  */
 TEST_SERVICE(spci_lend_check_upper_bound)
 {
-	EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 
 	struct spci_message *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);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -574,7 +600,7 @@
 
 TEST_SERVICE(spci_memory_lend_twice)
 {
-	EXPECT_EQ(spci_msg_wait(), SPCI_SUCCESS);
+	struct spci_value ret = spci_msg_wait();
 	uint8_t *ptr;
 
 	struct spci_message *recv_buf = SERVICE_RECV_BUFFER();
@@ -582,6 +608,8 @@
 	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);
 	hf_mailbox_clear();
 
 	ptr = (uint8_t *)memory_region->constituents[0].address;
@@ -612,7 +640,7 @@
 	}
 
 	spci_memory_relinquish(
-		send_buf, HF_PRIMARY_VM_ID, recv_buf->target_vm_id,
+		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);
 }
diff --git a/test/vmapi/primary_with_secondaries/services/receive_block.c b/test/vmapi/primary_with_secondaries/services/receive_block.c
index 1b03506..666754f 100644
--- a/test/vmapi/primary_with_secondaries/services/receive_block.c
+++ b/test/vmapi/primary_with_secondaries/services/receive_block.c
@@ -46,8 +46,9 @@
 	hf_interrupt_enable(EXTERNAL_INTERRUPT_ID_A, true);
 
 	for (i = 0; i < 10; ++i) {
-		int32_t res = spci_msg_wait();
-		EXPECT_EQ(res, SPCI_INTERRUPTED);
+		struct spci_value res = spci_msg_wait();
+		EXPECT_EQ(res.func, SPCI_ERROR_32);
+		EXPECT_EQ(res.arg1, SPCI_INTERRUPTED);
 	}
 
 	memcpy_s(SERVICE_SEND_BUFFER()->payload, SPCI_MSG_PAYLOAD_MAX, message,
diff --git a/test/vmapi/primary_with_secondaries/services/relay.c b/test/vmapi/primary_with_secondaries/services/relay.c
index 86eed79..1003699 100644
--- a/test/vmapi/primary_with_secondaries/services/relay.c
+++ b/test/vmapi/primary_with_secondaries/services/relay.c
@@ -36,17 +36,19 @@
 		uint32_t next_message_size;
 
 		/* Receive the message to relay. */
-		spci_msg_wait();
+		struct spci_value ret = spci_msg_wait();
+		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();
-		ASSERT_GE(recv_buf->length, sizeof(spci_vm_id_t));
+		ASSERT_GE(spci_msg_send_size(ret), sizeof(spci_vm_id_t));
 
 		chain = (spci_vm_id_t *)recv_buf->payload;
 		next_vm_id = le16toh(*chain);
 		next_message = chain + 1;
-		next_message_size = recv_buf->length - sizeof(spci_vm_id_t);
+		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,
diff --git a/test/vmapi/primary_with_secondaries/services/spci_check.c b/test/vmapi/primary_with_secondaries/services/spci_check.c
index 1d626ba..3ce9a1f 100644
--- a/test/vmapi/primary_with_secondaries/services/spci_check.c
+++ b/test/vmapi/primary_with_secondaries/services/spci_check.c
@@ -29,7 +29,7 @@
 	struct spci_message expected_message = {
 		.flags = SPCI_MESSAGE_IMPDEF_MASK,
 		.length = sizeof(message),
-		.target_vm_id = SERVICE_VM0,
+		.target_vm_id = hf_vm_get_id(),
 		.source_vm_id = HF_PRIMARY_VM_ID,
 
 		/*
@@ -41,20 +41,14 @@
 	};
 
 	/* Wait for single message to be sent by the primary VM. */
-	spci_msg_wait();
+	struct spci_value ret = spci_msg_wait();
+
+	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 
 	/* Ensure message header has all fields correctly set. */
-	EXPECT_EQ(recv_buf->flags, expected_message.flags);
-	EXPECT_EQ(recv_buf->length, expected_message.length);
-	EXPECT_EQ(recv_buf->target_vm_id, expected_message.target_vm_id);
-	EXPECT_EQ(recv_buf->source_vm_id, expected_message.source_vm_id);
-
-	/* TODO: Padding fields may be set to MBZ in the next SPCI spec
-	 * versions. */
-	EXPECT_EQ(recv_buf->reserved_1, expected_message.reserved_1);
-	EXPECT_EQ(recv_buf->reserved_2, expected_message.reserved_2);
-
-	/* Ensure message header has all fields correctly set. */
+	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);
 
@@ -70,14 +64,17 @@
 	const char message[] = "this should be truncated";
 
 	/* Wait for single message to be sent by the primary VM. */
-	spci_msg_wait();
+	struct spci_value ret = spci_msg_wait();
+
+	EXPECT_EQ(ret.func, SPCI_MSG_SEND_32);
 
 	/* Verify the length is as expected. */
-	EXPECT_EQ(16, recv_buf->length);
+	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, recv_buf->length), 0);
+	EXPECT_EQ(memcmp(recv_buf->payload, message, spci_msg_send_size(ret)),
+		  0);
 
 	spci_yield();
 }
@@ -85,7 +82,10 @@
 TEST_SERVICE(spci_recv_non_blocking)
 {
 	/* Wait for single message to be sent by the primary VM. */
-	EXPECT_EQ(spci_msg_poll(), SPCI_RETRY);
+	struct spci_value ret = spci_msg_poll();
+
+	EXPECT_EQ(ret.func, SPCI_ERROR_32);
+	EXPECT_EQ(ret.arg1, SPCI_RETRY);
 
 	spci_yield();
 }