diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index dd39c26..90397c4 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -60,15 +60,24 @@
 }
 
 /**
- * Runs the given vcpu of the given vm.
+ * Runs the given vCPU of the given VM.
+ */
+static inline struct spci_value spci_run(spci_vm_id_t vm_id,
+					 spci_vcpu_index_t vcpu_idx)
+{
+	return spci_call((struct spci_value){.func = SPCI_RUN_32,
+					     (uint32_t)vm_id << 16 | vcpu_idx});
+}
+
+/**
+ * Runs the given vCPU of the given VM.
  *
  * Returns an hf_vcpu_run_return struct telling the scheduler what to do next.
  */
 static inline struct hf_vcpu_run_return hf_vcpu_run(spci_vm_id_t vm_id,
 						    spci_vcpu_index_t vcpu_idx)
 {
-	return hf_vcpu_run_return_decode(spci_call((struct spci_value){
-		.func = SPCI_RUN_32, (uint32_t)vm_id << 16 | vcpu_idx}));
+	return hf_vcpu_run_return_decode(spci_run(vm_id, vcpu_idx));
 }
 
 /**
diff --git a/test/hftest/inc/hftest_impl.h b/test/hftest/inc/hftest_impl.h
index f3c9ffa..ed2fa91 100644
--- a/test/hftest/inc/hftest_impl.h
+++ b/test/hftest/inc/hftest_impl.h
@@ -280,7 +280,7 @@
  */
 #define HFTEST_SERVICE_SELECT(vm_id, service, send_buffer)                    \
 	do {                                                                  \
-		struct hf_vcpu_run_return run_res;                            \
+		struct spci_value run_res;                                    \
 		uint32_t msg_length =                                         \
 			strnlen_s(service, SERVICE_NAME_MAX_LENGTH);          \
                                                                               \
@@ -288,9 +288,9 @@
 		 * Let the service configure its mailbox and wait for a       \
 		 * message.                                                   \
 		 */                                                           \
-		run_res = hf_vcpu_run(vm_id, 0);                              \
-		ASSERT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);        \
-		ASSERT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);             \
+		run_res = spci_run(vm_id, 0);                                 \
+		ASSERT_EQ(run_res.func, SPCI_MSG_WAIT_32);                    \
+		ASSERT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);               \
                                                                               \
 		/* Send the selected service to run and let it be handled. */ \
 		memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, service,          \
@@ -299,8 +299,8 @@
 		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);                   \
+		run_res = spci_run(vm_id, 0);                                 \
+		ASSERT_EQ(run_res.func, SPCI_YIELD_32);                       \
 	} while (0)
 
 #define HFTEST_SERVICE_SEND_BUFFER() hftest_get_context()->send
diff --git a/test/vmapi/arch/aarch64/gicv3/busy_secondary.c b/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
index 1ed1031..3bf660b 100644
--- a/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
+++ b/test/vmapi/arch/aarch64/gicv3/busy_secondary.c
@@ -45,7 +45,7 @@
 TEST(busy_secondary, virtual_timer)
 {
 	const char message[] = "loop";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	interrupt_enable(VIRTUAL_TIMER_IRQ, true);
 	interrupt_set_priority(VIRTUAL_TIMER_IRQ, 0x80);
@@ -62,9 +62,9 @@
 	arch_irq_enable();
 
 	/* Let the secondary get started and wait for our message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Check that no interrupts are active or pending to start with. */
 	EXPECT_EQ(io_read32_array(GICD_ISPENDR, 0), 0);
@@ -84,8 +84,8 @@
 		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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_INTERRUPT_32);
 
 	dlog("Waiting for interrupt\n");
 	while (last_interrupt_id == 0) {
@@ -111,7 +111,7 @@
 TEST(busy_secondary, physical_timer)
 {
 	const char message[] = "loop";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	interrupt_enable(PHYSICAL_TIMER_IRQ, true);
 	interrupt_set_priority(PHYSICAL_TIMER_IRQ, 0x80);
@@ -120,9 +120,9 @@
 	arch_irq_enable();
 
 	/* Let the secondary get started and wait for our message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Check that no interrupts are active or pending to start with. */
 	EXPECT_EQ(io_read32_array(GICD_ISPENDR, 0), 0);
@@ -142,8 +142,8 @@
 		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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_INTERRUPT_32);
 
 	dlog("Waiting for interrupt\n");
 	while (last_interrupt_id == 0) {
diff --git a/test/vmapi/arch/aarch64/gicv3/gicv3.c b/test/vmapi/arch/aarch64/gicv3/gicv3.c
index a2418d0..71c3994 100644
--- a/test/vmapi/arch/aarch64/gicv3/gicv3.c
+++ b/test/vmapi/arch/aarch64/gicv3/gicv3.c
@@ -86,13 +86,14 @@
  */
 TEST(system, icc_ctlr_read_trapped_secondary)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
 	SERVICE_SELECT(SERVICE_VM0, "read_systemreg_ctlr", send_buffer);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_ERROR_32);
+	EXPECT_EQ(run_res.arg2, SPCI_ABORTED);
 }
 
 /*
@@ -101,13 +102,14 @@
  */
 TEST(system, icc_ctlr_write_trapped_secondary)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
 	SERVICE_SELECT(SERVICE_VM0, "write_systemreg_ctlr", send_buffer);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_ERROR_32);
+	EXPECT_EQ(run_res.arg2, SPCI_ABORTED);
 }
 
 /*
@@ -116,12 +118,13 @@
  */
 TEST(system, icc_sre_write_trapped_secondary)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	EXPECT_EQ(hf_vm_configure(send_page_addr, recv_page_addr), 0);
 	SERVICE_SELECT(SERVICE_VM0, "write_systemreg_sre", send_buffer);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_TRUE(run_res.code == HF_VCPU_RUN_ABORTED ||
-		    run_res.code == HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_TRUE((run_res.func == SPCI_ERROR_32 &&
+		     run_res.arg2 == SPCI_ABORTED) ||
+		    run_res.func == SPCI_YIELD_32);
 }
diff --git a/test/vmapi/arch/aarch64/gicv3/timer_secondary.c b/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
index e38a2fc..4ac87a8 100644
--- a/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
+++ b/test/vmapi/arch/aarch64/gicv3/timer_secondary.c
@@ -41,12 +41,12 @@
 {
 	const char message[] = "loop 0099999";
 	const char expected_response[] = "Got IRQ 03.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	/* Let the secondary get started and wait for our message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
 	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -58,23 +58,23 @@
 	/*
 	 * Let the secondary handle the message and set the timer. It will loop
 	 * until the hardware interrupt fires, at which point we'll get and
-	 * ignore the interrupt, and see a HF_VCPU_RUN_YIELD return code.
+	 * ignore the interrupt, and see a SPCI_YIELD return code.
 	 */
 	dlog("running secondary after sending timer message.\n");
 	last_interrupt_id = 0;
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_PREEMPTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_INTERRUPT_32);
 	dlog("secondary yielded after receiving timer message\n");
 	EXPECT_EQ(last_interrupt_id, VIRTUAL_TIMER_IRQ);
 
 	/*
-	 * Now that the timer has expired, when we call hf_vcpu_run again
-	 * Hafnium should inject a virtual timer interrupt into the secondary,
-	 * which should get it and respond.
+	 * Now that the timer has expired, when we call spci_run again Hafnium
+	 * should inject a virtual timer interrupt into the secondary, which
+	 * should get it and respond.
 	 */
-	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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(recv_buffer, expected_response,
 			 sizeof(expected_response)),
 		  0);
@@ -95,17 +95,16 @@
 	timer_busywait_secondary();
 }
 
-static void timer_secondary(const char message[],
-			    enum hf_vcpu_run_code expected_code)
+static void timer_secondary(const char message[], uint64_t expected_code)
 {
 	const char expected_response[] = "Got IRQ 03.";
 	size_t message_length = strnlen_s(message, 64) + 1;
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	/* Let the secondary get started and wait for our message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
 	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, message_length);
@@ -116,63 +115,62 @@
 
 	/* Let the secondary handle the message and set the timer. */
 	last_interrupt_id = 0;
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
+	run_res = spci_run(SERVICE_VM0, 0);
 
 	/*
 	 * There's a race for whether the secondary manages to block and switch
 	 * to the primary before the hardware timer fires, so we need to handle
 	 * three cases:
-	 * 1. The (hardware) timer fires immediately, we get
-	 *   HF_VCPU_RUN_PREEMPTED.
+	 * 1. The (hardware) timer fires immediately, we get SPCI_INTERRUPT.
 	 * 2. The secondary blocks and switches back, we get expected_code until
 	 *   the timer fires.
 	 *  2a. The timer then expires while we are in the primary, so Hafnium
-	 *   can inject the timer interrupt the next time we call hf_vcpu_run.
+	 *   can inject the timer interrupt the next time we call spci_run.
 	 *  2b. The timer fires while the secondary is running, so we get
-	 *   HF_VCPU_RUN_PREEMPTED as in case 1.
+	 *   SPCI_INTERRUPT as in case 1.
 	 */
 
-	if (run_res.code != expected_code &&
-	    run_res.code != HF_VCPU_RUN_PREEMPTED) {
-		FAIL("Expected run to return HF_VCPU_RUN_PREEMPTED or %d, but "
-		     "got %d",
-		     expected_code, run_res.code);
+	if (run_res.func != expected_code &&
+	    run_res.func != SPCI_INTERRUPT_32) {
+		FAIL("Expected run to return SPCI_INTERRUPT or %#x, but "
+		     "got %#x",
+		     expected_code, run_res.func);
 	}
 
 	/* Loop until the timer fires. */
-	while (run_res.code == expected_code) {
+	while (run_res.func == expected_code) {
 		/*
 		 * This case happens if the secondary manages to block and
 		 * switch to the primary before the timer fires.
 		 */
 		dlog("Primary looping until timer fires\n");
-		if (expected_code == HF_VCPU_RUN_WAIT_FOR_INTERRUPT ||
-		    expected_code == HF_VCPU_RUN_WAIT_FOR_MESSAGE) {
-			EXPECT_NE(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
-			dlog("%d ns remaining\n", run_res.sleep.ns);
+		if (expected_code == HF_SPCI_RUN_WAIT_FOR_INTERRUPT ||
+		    expected_code == SPCI_MSG_WAIT_32) {
+			EXPECT_NE(run_res.arg2, SPCI_SLEEP_INDEFINITE);
+			dlog("%d ns remaining\n", run_res.arg2);
 		}
-		run_res = hf_vcpu_run(SERVICE_VM0, 0);
+		run_res = spci_run(SERVICE_VM0, 0);
 	}
 	dlog("Primary done looping\n");
 
-	if (run_res.code == HF_VCPU_RUN_PREEMPTED) {
+	if (run_res.func == SPCI_INTERRUPT_32) {
 		/*
 		 * This case happens if the (hardware) timer fires before the
 		 * secondary blocks and switches to the primary, either
 		 * immediately after setting the timer or during the loop above.
 		 * Then we get the interrupt to the primary, ignore it, and see
-		 * a HF_VCPU_RUN_PREEMPTED code from the hf_vcpu_run call, so we
-		 * should call it again for the timer interrupt to be injected
+		 * a SPCI_INTERRUPT code from the spci_run call, so we should
+		 * call it again for the timer interrupt to be injected
 		 * automatically by Hafnium.
 		 */
 		EXPECT_EQ(last_interrupt_id, VIRTUAL_TIMER_IRQ);
 		dlog("Preempted by timer interrupt, running again\n");
-		run_res = hf_vcpu_run(SERVICE_VM0, 0);
+		run_res = spci_run(SERVICE_VM0, 0);
 	}
 
 	/* 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(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(recv_buffer, expected_response,
 			 sizeof(expected_response)),
 		  0);
@@ -192,8 +190,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("WFI  0000001", HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	timer_secondary("WFI  0000001", HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+	timer_secondary("WFI  0000001", HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
+	timer_secondary("WFI  0000001", HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
 }
 
 TEST(timer_secondary, wfi_long)
@@ -202,8 +200,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("WFI  0099999", HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	timer_secondary("WFI  0099999", HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+	timer_secondary("WFI  0099999", HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
+	timer_secondary("WFI  0099999", HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
 }
 
 TEST(timer_secondary, wfe_short)
@@ -212,8 +210,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("WFE  0000001", HF_VCPU_RUN_YIELD);
-	timer_secondary("WFE  0000001", HF_VCPU_RUN_YIELD);
+	timer_secondary("WFE  0000001", SPCI_YIELD_32);
+	timer_secondary("WFE  0000001", SPCI_YIELD_32);
 }
 
 TEST(timer_secondary, wfe_long)
@@ -222,8 +220,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("WFE  0099999", HF_VCPU_RUN_YIELD);
-	timer_secondary("WFE  0099999", HF_VCPU_RUN_YIELD);
+	timer_secondary("WFE  0099999", SPCI_YIELD_32);
+	timer_secondary("WFE  0099999", SPCI_YIELD_32);
 }
 
 TEST(timer_secondary, receive_short)
@@ -232,8 +230,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("RECV 0000001", HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	timer_secondary("RECV 0000001", HF_VCPU_RUN_WAIT_FOR_MESSAGE);
+	timer_secondary("RECV 0000001", SPCI_MSG_WAIT_32);
+	timer_secondary("RECV 0000001", SPCI_MSG_WAIT_32);
 }
 
 TEST(timer_secondary, receive_long)
@@ -242,8 +240,8 @@
 	 * Run the test twice in a row, to check that the state doesn't get
 	 * messed up.
 	 */
-	timer_secondary("RECV 0099999", HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	timer_secondary("RECV 0099999", HF_VCPU_RUN_WAIT_FOR_MESSAGE);
+	timer_secondary("RECV 0099999", SPCI_MSG_WAIT_32);
+	timer_secondary("RECV 0099999", SPCI_MSG_WAIT_32);
 }
 
 /**
@@ -253,12 +251,12 @@
 {
 	const char message[] = "WFI  9999999";
 	size_t message_length = strnlen_s(message, 64) + 1;
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	/* Let the secondary get started and wait for our message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Send the message for the secondary to set a timer. */
 	memcpy_s(send_buffer, SPCI_MSG_PAYLOAD_MAX, message, message_length);
@@ -272,10 +270,10 @@
 	 */
 	last_interrupt_id = 0;
 	for (int i = 0; i < 20; ++i) {
-		run_res = hf_vcpu_run(SERVICE_VM0, 0);
-		EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
+		run_res = spci_run(SERVICE_VM0, 0);
+		EXPECT_EQ(run_res.func, HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
 		dlog("Primary looping until timer fires; %d ns "
 		     "remaining\n",
-		     run_res.sleep.ns);
+		     run_res.arg2);
 	}
 }
diff --git a/test/vmapi/primary_only/primary_only.c b/test/vmapi/primary_only/primary_only.c
index 74302c6..067cfc1 100644
--- a/test/vmapi/primary_only/primary_only.c
+++ b/test/vmapi/primary_only/primary_only.c
@@ -85,25 +85,23 @@
 }
 
 /**
- * Confirm it is a no-op with a valid return code when running a vcpu from the
- * primary VM.
+ * Confirm it is an error when running a vcpu from the primary VM.
  */
-TEST(hf_vcpu_run, cannot_run_primary)
+TEST(spci_run, cannot_run_primary)
 {
-	struct hf_vcpu_run_return res = hf_vcpu_run(HF_PRIMARY_VM_ID, 0);
-	EXPECT_EQ(res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(res.sleep.ns, HF_SLEEP_INDEFINITE);
+	struct spci_value res = spci_run(HF_PRIMARY_VM_ID, 0);
+	EXPECT_EQ(res.func, SPCI_ERROR_32);
+	EXPECT_EQ(res.arg2, SPCI_INVALID_PARAMETERS);
 }
 
 /**
- * Confirm it is a no-op with a valid return code when running a vcpu from a
- * non-existant secondary VM.
+ * Confirm it is an error when running a vcpu from a non-existant secondary VM.
  */
-TEST(hf_vcpu_run, cannot_run_absent_secondary)
+TEST(spci_run, cannot_run_absent_secondary)
 {
-	struct hf_vcpu_run_return res = hf_vcpu_run(1, 0);
-	EXPECT_EQ(res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(res.sleep.ns, HF_SLEEP_INDEFINITE);
+	struct spci_value res = spci_run(1, 0);
+	EXPECT_EQ(res.func, SPCI_ERROR_32);
+	EXPECT_EQ(res.arg2, SPCI_INVALID_PARAMETERS);
 }
 
 /**
diff --git a/test/vmapi/primary_with_secondaries/abort.c b/test/vmapi/primary_with_secondaries/abort.c
index ce7f778..5337d18 100644
--- a/test/vmapi/primary_with_secondaries/abort.c
+++ b/test/vmapi/primary_with_secondaries/abort.c
@@ -25,13 +25,13 @@
  */
 TEST(abort, data_abort)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "data_abort", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -39,13 +39,13 @@
  */
 TEST(abort, straddling_data_abort)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "straddling_data_abort", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -53,13 +53,13 @@
  */
 TEST(abort, instruction_abort)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "instruction_abort", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -67,11 +67,11 @@
  */
 TEST(abort, straddling_instruction_abort)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "straddling_instruction_abort", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
diff --git a/test/vmapi/primary_with_secondaries/boot.c b/test/vmapi/primary_with_secondaries/boot.c
index d6aa553..a793d28 100644
--- a/test/vmapi/primary_with_secondaries/boot.c
+++ b/test/vmapi/primary_with_secondaries/boot.c
@@ -27,13 +27,13 @@
  */
 TEST(boot, memory_size)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "boot_memory", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -41,13 +41,13 @@
  */
 TEST(boot, beyond_memory_size)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "boot_memory_overrun", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -55,11 +55,11 @@
  */
 TEST(boot, memory_before_image)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "boot_memory_underrun", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
diff --git a/test/vmapi/primary_with_secondaries/debug_el1.c b/test/vmapi/primary_with_secondaries/debug_el1.c
index 74d2647..5f826c8 100644
--- a/test/vmapi/primary_with_secondaries/debug_el1.c
+++ b/test/vmapi/primary_with_secondaries/debug_el1.c
@@ -33,57 +33,57 @@
 
 TEST(debug_el1, secondary_mdccint_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "debug_el1_secondary_mdccint_el1", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(debug_el1, secondary_dbgbcr0_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "debug_el1_secondary_dbgbcr0_el1", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(debug_el1, secondary_dbgbvr0_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "debug_el1_secondary_dbgbvr0_el1", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(debug_el1, secondary_dbgwcr0_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "debug_el1_secondary_dbgwcr0_el1", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(debug_el1, secondary_dbgwvr0_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "debug_el1_secondary_dbgwvr0_el1", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
diff --git a/test/vmapi/primary_with_secondaries/floating_point.c b/test/vmapi/primary_with_secondaries/floating_point.c
index a480a8b..23660ce 100644
--- a/test/vmapi/primary_with_secondaries/floating_point.c
+++ b/test/vmapi/primary_with_secondaries/floating_point.c
@@ -35,18 +35,18 @@
 {
 	const double first = 1.2;
 	const double second = -2.3;
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	fill_fp_registers(first);
 	SERVICE_SELECT(SERVICE_VM0, "fp_fill", mb.send);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 	EXPECT_EQ(check_fp_register(first), true);
 
 	fill_fp_registers(second);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 	EXPECT_EQ(check_fp_register(second), true);
 }
 
@@ -57,17 +57,17 @@
 TEST(floating_point, fp_fpcr)
 {
 	uintreg_t value = 0;
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	EXPECT_EQ(read_msr(fpcr), value);
 
 	SERVICE_SELECT(SERVICE_VM0, "fp_fpcr", mb.send);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 	EXPECT_EQ(read_msr(fpcr), value);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 	EXPECT_EQ(read_msr(fpcr), value);
 }
diff --git a/test/vmapi/primary_with_secondaries/interrupts.c b/test/vmapi/primary_with_secondaries/interrupts.c
index 31db0b0..dfd6b20 100644
--- a/test/vmapi/primary_with_secondaries/interrupts.c
+++ b/test/vmapi/primary_with_secondaries/interrupts.c
@@ -32,14 +32,14 @@
 {
 	const char message[] = "Ping";
 	const char expected_response[] = "Got IRQ 05.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Set the message, echo it and wait for a response. */
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -47,9 +47,9 @@
 		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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -63,29 +63,29 @@
 TEST(interrupts, inject_interrupt_twice)
 {
 	const char expected_response[] = "Got IRQ 07.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Inject the interrupt and wait for a message. */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
 	/* Inject the interrupt again, and wait for the same message. */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -99,29 +99,29 @@
 {
 	const char expected_response[] = "Got IRQ 07.";
 	const char expected_response_2[] = "Got IRQ 08.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Inject the interrupt and wait for a message. */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
 	/* Inject a different interrupt and wait for a different message. */
 	hf_interrupt_inject(SERVICE_VM0, 0, EXTERNAL_INTERRUPT_ID_B);
-	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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response_2));
 	EXPECT_EQ(memcmp(mb.recv, expected_response_2,
 			 sizeof(expected_response_2)),
 		  0);
@@ -138,27 +138,27 @@
 	const char expected_response[] = "Got IRQ 07.";
 	const char message[] = "Ping";
 	const char expected_response_2[] = "Got IRQ 05.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Inject the interrupt and wait for a message. */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Now send a message to the secondary. */
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -166,9 +166,9 @@
 		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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response_2));
 	EXPECT_EQ(memcmp(mb.recv, expected_response_2,
 			 sizeof(expected_response_2)),
 		  0);
@@ -184,16 +184,16 @@
 {
 	const char expected_response[] = "Got IRQ 09.";
 	const char message[] = "Enable interrupt C";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible", mb.send);
 
 	/* Inject the interrupt and expect not to get a message. */
 	hf_interrupt_inject(SERVICE_VM0, 0, EXTERNAL_INTERRUPT_ID_C);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/*
 	 * Now send a message to the secondary to enable the interrupt ID, and
@@ -204,9 +204,9 @@
 		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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -220,7 +220,7 @@
 TEST(interrupts, pending_interrupt_no_blocking_receive)
 {
 	const char expected_response[] = "Done waiting";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "receive_block", mb.send);
@@ -231,9 +231,9 @@
 	 * back after failing to receive a message a few times.
 	 */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -247,7 +247,7 @@
 TEST(interrupts, pending_interrupt_wfi_not_trapped)
 {
 	const char expected_response[] = "Done waiting";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "wfi", mb.send);
@@ -258,9 +258,9 @@
 	 * back after running WFI a few times.
 	 */
 	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(expected_response));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response));
 	EXPECT_EQ(memcmp(mb.recv, expected_response, sizeof(expected_response)),
 		  0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
@@ -273,14 +273,14 @@
 TEST(interrupts, deliver_interrupt_and_message)
 {
 	const char message[] = "I\'ll see you again.";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "interruptible_echo", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
 	EXPECT_EQ(
@@ -288,9 +288,9 @@
 			.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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 	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 934f741..9593dc7 100644
--- a/test/vmapi/primary_with_secondaries/mailbox.c
+++ b/test/vmapi/primary_with_secondaries/mailbox.c
@@ -79,14 +79,14 @@
 TEST(mailbox, echo)
 {
 	const char message[] = "Echo this back to me!";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "echo", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Set the message, echo it and check it didn't change. */
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -94,10 +94,10 @@
 		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, message, sizeof(message)), 0);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
+	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
 
@@ -107,7 +107,7 @@
 TEST(mailbox, repeated_echo)
 {
 	char message[] = "Echo this back to me!";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	uint8_t i;
 	struct mailbox_buffers mb = set_up_mailbox();
 
@@ -115,9 +115,9 @@
 
 	for (i = 0; i < 100; i++) {
 		/* Run secondary until it reaches the wait for messages. */
-		run_res = hf_vcpu_run(SERVICE_VM0, 0);
-		EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-		EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+		run_res = spci_run(SERVICE_VM0, 0);
+		EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+		EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 		/* Set the message, echo it and check it didn't change. */
 		next_permutation(message, sizeof(message) - 1);
@@ -127,9 +127,9 @@
 					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));
+		run_res = spci_run(SERVICE_VM0, 0);
+		EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+		EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 		EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 		EXPECT_EQ(hf_mailbox_clear(), 0);
 	}
@@ -142,18 +142,18 @@
 TEST(mailbox, relay)
 {
 	const char message[] = "Send this round the relay!";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "relay", mb.send);
 	SERVICE_SELECT(SERVICE_VM1, "relay", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
-	run_res = hf_vcpu_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/*
 	 * Build the message chain so the message is sent from here to
@@ -176,18 +176,18 @@
 	}
 
 	/* Let SERVICE_VM0 forward the message. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
-	EXPECT_EQ(run_res.message.vm_id, SERVICE_VM1);
-	EXPECT_EQ(run_res.message.size, 0);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_receiver(run_res), SERVICE_VM1);
+	EXPECT_EQ(spci_msg_send_size(run_res), 0);
 
 	/* Let SERVICE_VM1 forward the message. */
-	run_res = hf_vcpu_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* 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(spci_msg_send_receiver(run_res), HF_PRIMARY_VM_ID);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 	EXPECT_EQ(hf_mailbox_clear(), 0);
 }
@@ -198,15 +198,16 @@
  */
 TEST(mailbox, no_primary_to_secondary_notification_on_configure)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
+
 	set_up_mailbox();
 
 	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0, 0),
 			  SPCI_BUSY);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	EXPECT_EQ(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0, 0).func,
 		  SPCI_SUCCESS_32);
@@ -218,7 +219,8 @@
  */
 TEST(mailbox, secondary_to_primary_notification_on_configure)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
+
 	set_up_mailbox();
 
 	EXPECT_SPCI_ERROR(spci_msg_send(HF_PRIMARY_VM_ID, SERVICE_VM0, 0,
@@ -229,8 +231,8 @@
 	 * Run first VM for it to configure itself. It should result in
 	 * notifications having to be issued.
 	 */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_NOTIFY_WAITERS);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_RX_RELEASE_32);
 
 	/* A single waiter is returned. */
 	EXPECT_EQ(hf_mailbox_waiter_get(SERVICE_VM0), HF_PRIMARY_VM_ID);
@@ -249,14 +251,14 @@
 TEST(mailbox, primary_to_secondary)
 {
 	char message[] = "not ready echo";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "echo_with_notification", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Send a message to echo service, and get response back. */
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -264,15 +266,15 @@
 		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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 	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);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Without clearing our mailbox, send message again. */
 	reverse(message, strnlen_s(message, sizeof(message)));
@@ -283,9 +285,9 @@
 		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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Clear the mailbox. We expect to be told there are pending waiters. */
 	EXPECT_EQ(hf_mailbox_clear(), 1);
@@ -301,9 +303,9 @@
 	EXPECT_EQ(
 		hf_interrupt_inject(SERVICE_VM0, 0, HF_MAILBOX_WRITABLE_INTID),
 		1);
-	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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 	EXPECT_EQ(memcmp(mb.recv, message, sizeof(message)), 0);
 }
 
@@ -315,14 +317,14 @@
 TEST(mailbox, secondary_to_primary_notification)
 {
 	const char message[] = "not ready echo";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "echo_with_notification", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 
 	/* Send a message to echo service twice. The second should fail. */
 	memcpy_s(mb.send, SPCI_MSG_PAYLOAD_MAX, message, sizeof(message));
@@ -335,14 +337,14 @@
 			  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));
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(message));
 	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);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_NOTIFY_WAITERS);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_RX_RELEASE_32);
 
 	/* Retrieve a single waiter. */
 	EXPECT_EQ(hf_mailbox_waiter_get(SERVICE_VM0), HF_PRIMARY_VM_ID);
diff --git a/test/vmapi/primary_with_secondaries/memory_sharing.c b/test/vmapi/primary_with_secondaries/memory_sharing.c
index 76d0739..745bd8b 100644
--- a/test/vmapi/primary_with_secondaries/memory_sharing.c
+++ b/test/vmapi/primary_with_secondaries/memory_sharing.c
@@ -286,7 +286,7 @@
  */
 TEST(memory_sharing, concurrent)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -307,15 +307,15 @@
 			  .func,
 		  SPCI_SUCCESS_32);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		page[i] = i;
 	}
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		uint8_t value = i + 1;
@@ -329,7 +329,7 @@
  */
 TEST(memory_sharing, share_concurrently_and_get_back)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -352,15 +352,15 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -387,7 +387,7 @@
  */
 TEST(memory_sharing, spci_give_and_get_back)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -411,10 +411,10 @@
 				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
+	run_res = spci_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Ensure that the secondary VM accessed the region. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -422,8 +422,8 @@
 	}
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -431,7 +431,7 @@
  */
 TEST(memory_sharing, spci_lend_relinquish)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -454,10 +454,10 @@
 				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
+	run_res = spci_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Ensure that the secondary VM accessed the region. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -465,8 +465,8 @@
 	}
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -474,7 +474,7 @@
  */
 TEST(memory_sharing, give_and_get_back)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -497,15 +497,15 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -513,7 +513,7 @@
  */
 TEST(memory_sharing, lend_and_get_back)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -536,15 +536,15 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 	for (int i = 0; i < PAGE_SIZE; ++i) {
 		ASSERT_EQ(ptr[i], 0);
 	}
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -552,7 +552,7 @@
  */
 TEST(memory_sharing, reshare_after_return)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -574,8 +574,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Share the memory again after it has been returned. */
 	ASSERT_EQ(hf_share_memory(SERVICE_VM0, (hf_ipaddr_t)&page, PAGE_SIZE,
@@ -583,9 +583,9 @@
 		  0);
 
 	/* Observe the service doesn't fault when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 }
 
 /**
@@ -593,7 +593,7 @@
  */
 TEST(memory_sharing, share_elsewhere_after_return)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 
@@ -615,8 +615,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be returned. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Share the memory with a differnt VM after it has been returned. */
 	ASSERT_EQ(hf_share_memory(SERVICE_VM1, (hf_ipaddr_t)&page, PAGE_SIZE,
@@ -624,8 +624,8 @@
 		  0);
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -633,15 +633,15 @@
  */
 TEST(memory_sharing, give_memory_and_lose_access)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM0, "give_memory_and_fault", mb.send);
 
 	/* Have the memory be given. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Check the memory was cleared. */
 	ptr = *(uint8_t **)mb.recv;
@@ -650,8 +650,8 @@
 	}
 
 	/* Observe the service fault when it tries to access it. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -659,15 +659,15 @@
  */
 TEST(memory_sharing, lend_memory_and_lose_access)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr;
 
 	SERVICE_SELECT(SERVICE_VM0, "lend_memory_and_fault", mb.send);
 
 	/* Have the memory be lent. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Check the memory was cleared. */
 	ptr = *(uint8_t **)mb.recv;
@@ -676,8 +676,8 @@
 	}
 
 	/* Observe the service fault when it tries to access it. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -685,7 +685,7 @@
  */
 TEST(memory_sharing, spci_donate_check_upper_bounds)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -709,8 +709,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -718,7 +718,7 @@
  */
 TEST(memory_sharing, spci_donate_check_lower_bounds)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -742,8 +742,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Observe the service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -752,7 +752,7 @@
  */
 TEST(memory_sharing, spci_donate_elsewhere_after_return)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -776,10 +776,10 @@
 				SPCI_MSG_SEND_LEGACY_MEMORY)
 			  .func,
 		  SPCI_SUCCESS_32);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
+	run_res = spci_run(SERVICE_VM0, 0);
 
 	/* Let the memory be returned. */
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Share the memory with another VM. */
 	msg_size = spci_memory_donate_init(
@@ -792,8 +792,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Observe the original service faulting when accessing the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -802,7 +802,7 @@
  */
 TEST(memory_sharing, spci_donate_vms)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -818,8 +818,8 @@
 	};
 
 	/* Set up VM1 to wait for message. */
-	run_res = hf_vcpu_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_MESSAGE);
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_WAIT_32);
 
 	/* Donate memory. */
 	msg_size = spci_memory_donate_init(
@@ -832,20 +832,20 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be sent from VM0 to VM1. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Receive memory in VM1. */
-	run_res = hf_vcpu_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Try to access memory in VM0 and fail. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 
 	/* Ensure that memory in VM1 remains the same. */
-	run_res = hf_vcpu_run(SERVICE_VM1, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM1, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -853,7 +853,7 @@
  */
 TEST(memory_sharing, spci_donate_twice)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -879,8 +879,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be received. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Fail to share memory again with any VM. */
 	spci_check_cannot_donate_memory(mb, constituents, 1, -1);
@@ -888,15 +888,15 @@
 	spci_check_cannot_relinquish_memory(mb, constituents, 1);
 
 	/* Let the memory be sent from VM0 to PRIMARY (returned). */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Check we have access again. */
 	ptr[0] = 'f';
 
 	/* Try and fail to donate memory from VM0 to VM1. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -977,7 +977,7 @@
  */
 TEST(memory_sharing, spci_donate_invalid_source)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1027,12 +1027,12 @@
 		  SPCI_SUCCESS_32);
 
 	/* Receive and return memory from VM0. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Use VM0 to fail to donate memory from the primary to VM1. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -1074,7 +1074,7 @@
  */
 TEST(memory_sharing, spci_lend_invalid_source)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1107,12 +1107,12 @@
 		  SPCI_SUCCESS_32);
 
 	/* Receive and return memory from VM0. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Try to lend memory from primary in VM0. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -1121,7 +1121,7 @@
  */
 TEST(memory_sharing, spci_lend_relinquish_X_RW)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1146,12 +1146,12 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Let service write to and return memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Re-initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
@@ -1167,12 +1167,12 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Observe the service faulting when writing to the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -1181,7 +1181,7 @@
  */
 TEST(memory_sharing, spci_share_relinquish_X_RW)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1206,8 +1206,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1216,8 +1216,8 @@
 	}
 
 	/* Let service write to and return memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Re-initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
@@ -1233,8 +1233,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1243,8 +1243,8 @@
 	}
 
 	/* Observe the service faulting when writing to the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -1253,7 +1253,7 @@
  */
 TEST(memory_sharing, spci_share_relinquish_NX_RW)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1278,8 +1278,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1287,8 +1287,8 @@
 	}
 
 	/* Let service write to and return memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_MESSAGE);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	/* Re-initialise the memory before giving it. */
 	memset_s(ptr, sizeof(page), 'b', PAGE_SIZE);
@@ -1304,8 +1304,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we still have access. */
 	for (int i = 0; i < PAGE_SIZE; ++i) {
@@ -1314,8 +1314,8 @@
 	}
 
 	/* Observe the service faulting when writing to the memory. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -1323,7 +1323,7 @@
  */
 TEST(memory_sharing, spci_lend_relinquish_RW_X)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1351,8 +1351,8 @@
 		  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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	msg_size = spci_memory_lend_init(
 		mb.send, SERVICE_VM0, constituents, 1, 0, SPCI_MEMORY_RW_NX,
@@ -1364,8 +1364,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Try and fail to execute from the memory region. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -1373,7 +1373,7 @@
  */
 TEST(memory_sharing, spci_lend_relinquish_RO_X)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1401,8 +1401,8 @@
 		  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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
 
 	msg_size = spci_memory_lend_init(
 		mb.send, SERVICE_VM0, constituents, 1, 0, SPCI_MEMORY_RO_NX,
@@ -1414,8 +1414,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Try and fail to execute from the memory region. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
@@ -1423,7 +1423,7 @@
  */
 TEST(memory_sharing, spci_lend_donate)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1449,8 +1449,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we can't donate any sub section of memory to another VM. */
 	constituents[0].page_count = 1;
@@ -1483,7 +1483,7 @@
  */
 TEST(memory_sharing, spci_share_donate)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1509,8 +1509,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Ensure we can't donate any sub section of memory to another VM. */
 	constituents[0].page_count = 1;
@@ -1543,7 +1543,7 @@
  */
 TEST(memory_sharing, spci_lend_twice)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1569,8 +1569,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Attempt to lend the same area of memory. */
 	spci_check_cannot_lend_memory(mb, constituents);
@@ -1602,7 +1602,7 @@
  */
 TEST(memory_sharing, spci_share_twice)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 	uint8_t *ptr = page;
 	uint32_t msg_size;
@@ -1628,8 +1628,8 @@
 		  SPCI_SUCCESS_32);
 
 	/* Let the memory be accessed. */
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 
 	/* Attempt to share the same area of memory. */
 	spci_check_cannot_share_memory(mb, constituents);
diff --git a/test/vmapi/primary_with_secondaries/no_services.c b/test/vmapi/primary_with_secondaries/no_services.c
index 0f60bed..9d43cd7 100644
--- a/test/vmapi/primary_with_secondaries/no_services.c
+++ b/test/vmapi/primary_with_secondaries/no_services.c
@@ -25,6 +25,7 @@
 
 #include "hftest.h"
 #include "primary_with_secondary.h"
+#include "util.h"
 
 static alignas(PAGE_SIZE) uint8_t send_page[PAGE_SIZE];
 static alignas(PAGE_SIZE) uint8_t recv_page[PAGE_SIZE];
@@ -82,31 +83,28 @@
 /**
  * The primary can't be run by the hypervisor.
  */
-TEST(hf_vcpu_run, cannot_run_primary)
+TEST(spci_run, cannot_run_primary)
 {
-	struct hf_vcpu_run_return res = hf_vcpu_run(HF_PRIMARY_VM_ID, 0);
-	EXPECT_EQ(res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(res.sleep.ns, HF_SLEEP_INDEFINITE);
+	struct spci_value res = spci_run(HF_PRIMARY_VM_ID, 0);
+	EXPECT_SPCI_ERROR(res, SPCI_INVALID_PARAMETERS);
 }
 
 /**
  * Can only run a VM that exists.
  */
-TEST(hf_vcpu_run, cannot_run_absent_secondary)
+TEST(spci_run, cannot_run_absent_secondary)
 {
-	struct hf_vcpu_run_return res = hf_vcpu_run(1234, 0);
-	EXPECT_EQ(res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(res.sleep.ns, HF_SLEEP_INDEFINITE);
+	struct spci_value res = spci_run(1234, 0);
+	EXPECT_SPCI_ERROR(res, SPCI_INVALID_PARAMETERS);
 }
 
 /**
  * Can only run a vcpu that exists.
  */
-TEST(hf_vcpu_run, cannot_run_absent_vcpu)
+TEST(spci_run, cannot_run_absent_vcpu)
 {
-	struct hf_vcpu_run_return res = hf_vcpu_run(SERVICE_VM0, 1234);
-	EXPECT_EQ(res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(res.sleep.ns, HF_SLEEP_INDEFINITE);
+	struct spci_value res = spci_run(SERVICE_VM0, 1234);
+	EXPECT_SPCI_ERROR(res, SPCI_INVALID_PARAMETERS);
 }
 
 /**
@@ -162,7 +160,7 @@
 }
 
 /**
- * The primary receives messages from hf_vcpu_run().
+ * The primary receives messages from spci_run().
  */
 TEST(hf_mailbox_receive, cannot_receive_from_primary_blocking)
 {
@@ -171,7 +169,7 @@
 }
 
 /**
- * The primary receives messages from hf_vcpu_run().
+ * The primary receives messages from spci_run().
  */
 TEST(hf_mailbox_receive, cannot_receive_from_primary_non_blocking)
 {
diff --git a/test/vmapi/primary_with_secondaries/perfmon.c b/test/vmapi/primary_with_secondaries/perfmon.c
index 34165da..8fd0aba 100644
--- a/test/vmapi/primary_with_secondaries/perfmon.c
+++ b/test/vmapi/primary_with_secondaries/perfmon.c
@@ -30,36 +30,36 @@
 
 TEST(perfmon, secondary_pmccfiltr_el0)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "perfmon_secondary_pmccfiltr_el0", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(perfmon, secondary_pmcr_el0)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "perfmon_secondary_pmcr_el0", mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 TEST(perfmon, secondary_pmintenset_el1)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "perfmon_secondary_pmintenset_el1",
 		       mb.send);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_ABORTED);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_SPCI_ERROR(run_res, SPCI_ABORTED);
 }
 
 /**
diff --git a/test/vmapi/primary_with_secondaries/run_race.c b/test/vmapi/primary_with_secondaries/run_race.c
index 0ef3387..3a9ffcb 100644
--- a/test/vmapi/primary_with_secondaries/run_race.c
+++ b/test/vmapi/primary_with_secondaries/run_race.c
@@ -34,19 +34,19 @@
  */
 static bool run_loop(struct mailbox_buffers *mb)
 {
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	bool ok = false;
 
 	for (;;) {
 		/* Run until it manages to schedule vCPU on this CPU. */
 		do {
-			run_res = hf_vcpu_run(SERVICE_VM0, 0);
-		} while (run_res.code == HF_VCPU_RUN_WAIT_FOR_INTERRUPT &&
-			 run_res.sleep.ns == HF_SLEEP_INDEFINITE);
+			run_res = spci_run(SERVICE_VM0, 0);
+		} while (run_res.func == HF_SPCI_RUN_WAIT_FOR_INTERRUPT &&
+			 run_res.arg2 == HF_SLEEP_INDEFINITE);
 
 		/* Break out if we received a message with non-zero length. */
-		if (run_res.code == HF_VCPU_RUN_MESSAGE &&
-		    run_res.message.size != 0) {
+		if (run_res.func == SPCI_MSG_SEND_32 &&
+		    spci_msg_send_size(run_res) != 0) {
 			break;
 		}
 
@@ -55,7 +55,7 @@
 	}
 
 	/* Copies the contents of the received boolean to the return value. */
-	if (run_res.message.size == sizeof(ok)) {
+	if (spci_msg_send_size(run_res) == sizeof(ok)) {
 		ok = *(bool *)mb->recv;
 	}
 
diff --git a/test/vmapi/primary_with_secondaries/smp.c b/test/vmapi/primary_with_secondaries/smp.c
index af5c637..5ffda15 100644
--- a/test/vmapi/primary_with_secondaries/smp.c
+++ b/test/vmapi/primary_with_secondaries/smp.c
@@ -32,22 +32,22 @@
 {
 	const char expected_response_0[] = "vCPU 0";
 	const char expected_response_1[] = "vCPU 1";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM2, "smp", mb.send);
 
 	/* Let the first vCPU start the second vCPU. */
-	run_res = hf_vcpu_run(SERVICE_VM2, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAKE_UP);
-	EXPECT_EQ(run_res.wake_up.vm_id, SERVICE_VM2);
-	EXPECT_EQ(run_res.wake_up.vcpu, 1);
+	run_res = spci_run(SERVICE_VM2, 0);
+	EXPECT_EQ(run_res.func, HF_SPCI_RUN_WAKE_UP);
+	EXPECT_EQ(wake_up_get_vm_id(run_res), SERVICE_VM2);
+	EXPECT_EQ(wake_up_get_vcpu(run_res), 1);
 
 	/* Run the second vCPU and wait for a message. */
 	dlog("Run second vCPU for message\n");
-	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));
+	run_res = spci_run(SERVICE_VM2, 1);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response_1));
 	EXPECT_EQ(memcmp(mb.recv, expected_response_1,
 			 sizeof(expected_response_1)),
 		  0);
@@ -55,9 +55,9 @@
 
 	/* Run the first vCPU and wait for a different message. */
 	dlog("Run first vCPU for message\n");
-	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));
+	run_res = spci_run(SERVICE_VM2, 0);
+	EXPECT_EQ(run_res.func, SPCI_MSG_SEND_32);
+	EXPECT_EQ(spci_msg_send_size(run_res), sizeof(expected_response_0));
 	EXPECT_EQ(memcmp(mb.recv, expected_response_0,
 			 sizeof(expected_response_0)),
 		  0);
@@ -65,7 +65,7 @@
 
 	/* Run the second vCPU again, and expect it to turn itself off. */
 	dlog("Run second vCPU for poweroff.\n");
-	run_res = hf_vcpu_run(SERVICE_VM2, 1);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_WAIT_FOR_INTERRUPT);
-	EXPECT_EQ(run_res.sleep.ns, HF_SLEEP_INDEFINITE);
+	run_res = spci_run(SERVICE_VM2, 1);
+	EXPECT_EQ(run_res.func, HF_SPCI_RUN_WAIT_FOR_INTERRUPT);
+	EXPECT_EQ(run_res.arg2, SPCI_SLEEP_INDEFINITE);
 }
diff --git a/test/vmapi/primary_with_secondaries/spci.c b/test/vmapi/primary_with_secondaries/spci.c
index f551830..017b080 100644
--- a/test/vmapi/primary_with_secondaries/spci.c
+++ b/test/vmapi/primary_with_secondaries/spci.c
@@ -33,7 +33,7 @@
 TEST(spci, msg_send)
 {
 	const char message[] = "spci_msg_send";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_check", mb.send);
@@ -45,8 +45,8 @@
 			.func,
 		SPCI_SUCCESS_32);
 
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -88,7 +88,7 @@
 TEST(spci, spci_incorrect_length)
 {
 	const char message[] = "this should be truncated";
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 	struct mailbox_buffers mb = set_up_mailbox();
 
 	SERVICE_SELECT(SERVICE_VM0, "spci_length", mb.send);
@@ -98,8 +98,8 @@
 	/* Hard code incorrect length. */
 	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);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }
 
 /**
@@ -123,10 +123,10 @@
 TEST(spci, spci_recv_non_blocking)
 {
 	struct mailbox_buffers mb = set_up_mailbox();
-	struct hf_vcpu_run_return run_res;
+	struct spci_value run_res;
 
 	/* Check is performed in secondary vm. */
 	SERVICE_SELECT(SERVICE_VM0, "spci_recv_non_blocking", mb.send);
-	run_res = hf_vcpu_run(SERVICE_VM0, 0);
-	EXPECT_EQ(run_res.code, HF_VCPU_RUN_YIELD);
+	run_res = spci_run(SERVICE_VM0, 0);
+	EXPECT_EQ(run_res.func, SPCI_YIELD_32);
 }