diff --git a/driver/linux b/driver/linux
index bb7ae41..0973a2e 160000
--- a/driver/linux
+++ b/driver/linux
@@ -1 +1 @@
-Subproject commit bb7ae41a9456dc4e051468e61320cac0d5248f87
+Subproject commit 0973a2ec678062affef66303b1e057b7c0be555e
diff --git a/inc/hf/api.h b/inc/hf/api.h
index a936558..35aba8d 100644
--- a/inc/hf/api.h
+++ b/inc/hf/api.h
@@ -8,10 +8,9 @@
 int64_t api_vcpu_run(uint32_t vm_id, uint32_t vcpu_idx, struct vcpu **next);
 int64_t api_vm_configure(ipaddr_t send, ipaddr_t recv);
 
-int64_t api_rpc_request(uint32_t vm_id, size_t size);
-int64_t api_rpc_read_request(bool block, struct vcpu **next);
-int64_t api_rpc_reply(size_t size, bool ack, struct vcpu **next);
-int64_t api_rpc_ack(void);
+int64_t api_mailbox_send(uint32_t vm_id, size_t size, struct vcpu **next);
+int64_t api_mailbox_receive(bool block, struct vcpu **next);
+int64_t api_mailbox_clear(void);
 
 struct vcpu *api_wait_for_interrupt(void);
 struct vcpu *api_yield(void);
diff --git a/inc/hf/cpu.h b/inc/hf/cpu.h
index b263e39..d598296 100644
--- a/inc/hf/cpu.h
+++ b/inc/hf/cpu.h
@@ -10,10 +10,19 @@
 #include "hf/spinlock.h"
 
 enum vcpu_state {
+	/* The vcpu is switched off. */
 	vcpu_state_off,
+
+	/* The vcpu is ready to be run. */
 	vcpu_state_ready,
+
+	/* The vcpu is currently running. */
 	vcpu_state_running,
-	vcpu_state_blocked_rpc,
+
+	/* The vcpu is waiting for a message. */
+	vcpu_state_blocked_mailbox,
+
+	/* The vcpu is waiting for an interrupt. */
 	vcpu_state_blocked_interrupt,
 };
 
@@ -21,7 +30,7 @@
 	struct spinlock lock;
 	enum vcpu_state state;
 	struct vm *vm;
-	struct vcpu *rpc_next;
+	struct vcpu *mailbox_next;
 	struct arch_regs regs;
 };
 
diff --git a/inc/hf/vm.h b/inc/hf/vm.h
index 3d7bf2e..64e4ee0 100644
--- a/inc/hf/vm.h
+++ b/inc/hf/vm.h
@@ -3,14 +3,20 @@
 #include "hf/cpu.h"
 #include "hf/mm.h"
 
-enum rpc_state {
-	rpc_state_idle,
-	rpc_state_pending,
-	rpc_state_inflight,
+enum mailbox_state {
+	/* There is no message in the mailbox. */
+	mailbox_state_empty,
+
+	/* There is a message in the mailbox that is waiting for a reader. */
+	mailbox_state_received,
+
+	/* There is a message in the mailbox that has been read. */
+	mailbox_state_read,
 };
 
-struct rpc {
-	enum rpc_state state;
+struct mailbox {
+	enum mailbox_state state;
+	uint32_t recv_from_id;
 	int16_t recv_bytes;
 	void *recv;
 	const void *send;
@@ -23,7 +29,7 @@
 	uint32_t vcpu_count;
 	struct vcpu vcpus[MAX_CPUS];
 	struct mm_ptable ptable;
-	struct rpc rpc;
+	struct mailbox mailbox;
 };
 
 bool vm_init(uint32_t vcpu_count, struct vm **new_vm);
diff --git a/inc/vmapi/hf/call.h b/inc/vmapi/hf/call.h
index 0650868..4f6e05b 100644
--- a/inc/vmapi/hf/call.h
+++ b/inc/vmapi/hf/call.h
@@ -24,10 +24,9 @@
 #define HF_VM_GET_COUNT     0xff01
 #define HF_VCPU_GET_COUNT   0xff02
 #define HF_VM_CONFIGURE     0xff03
-#define HF_RPC_REQUEST      0xff04
-#define HF_RPC_READ_REQUEST 0xff05
-#define HF_RPC_ACK          0xff06
-#define HF_RPC_REPLY        0xff07
+#define HF_MAILBOX_SEND     0xff04
+#define HF_MAILBOX_RECEIVE  0xff05
+#define HF_MAILBOX_CLEAR    0xff06
 
 /* The ID of the primary VM which is responsile for scheduling. */
 #define HF_PRIMARY_VM_ID 0
@@ -36,14 +35,26 @@
 #define HF_VCPU_RUN_YIELD              0x00
 #define HF_VCPU_RUN_WAIT_FOR_INTERRUPT 0x01
 #define HF_VCPU_RUN_WAKE_UP            0x02
-#define HF_VCPU_RUN_RESPONSE_READY     0x03
+#define HF_VCPU_RUN_MESSAGE            0x03
 
 /* Construct and destruct the hf_vcpu_run() response. */
-#define HF_VCPU_RUN_RESPONSE(code, data) ((code & 0xff) | (data << 8))
+#define HF_VCPU_RUN_RESPONSE(code, vm_id, data)               \
+	((code & 0xff) | ((uint64_t)(vm_id & 0xffff) << 16) | \
+	 ((uint64_t)data << 32))
 #define HF_VCPU_RUN_CODE(ret) (ret & 0xff)
-#define HF_VCPU_RUN_DATA(ret) (ret >> 8)
+#define HF_VCPU_RUN_VM_ID(ret) ((ret >> 16) & 0xffff)
+#define HF_VCPU_RUN_DATA(ret) (ret >> 32)
 
-#define HF_RPC_REQUEST_MAX_SIZE 4096
+/* Construct and destruct the hf_mailbox_receive() response. */
+#define HF_MAILBOX_RECEIVE_RESPONSE(vm_id, size) \
+	((vm_id & 0xffff) | ((uint64_t)size << 32))
+#define HF_MAILBOX_RECEIVE_VM_ID(ret) (ret & 0xffff)
+#define HF_MAILBOX_RECEIVE_SIZE(ret) (ret >> 32)
+
+#define HF_MAILBOX_SIZE 4096
+
+#define HF_INVALID_VM_ID 0xffff
+#define HF_INVALID_VCPU  0xffff
 
 /* clang-format on */
 
@@ -87,45 +98,28 @@
 }
 
 /**
- * Called by the primary VM to send an RPC request to a secondary VM. Data is
- * copied from the caller's send buffer to the destination's receive buffer.
+ * Copies data from the sender's send buffer to the recipient's receive buffer.
  */
-static inline int64_t hf_rpc_request(uint32_t vm_id, size_t size)
+static inline int64_t hf_mailbox_send(uint32_t vm_id, size_t size)
 {
-	return hf_call(HF_RPC_REQUEST, vm_id, size, 0);
+	return hf_call(HF_MAILBOX_SEND, vm_id, size, 0);
 }
 
 /**
- * Called by the primary VM to read a request sent from a previous call to
- * api_rpc_request. If one isn't available, this function can optionally block
- * the caller until one becomes available.
+ * Called by secondary VMs to receive a message. The call can optionally block
+ * until a message is received.
  *
- * Once the caller has completed handling a request, it must indicate it by
- * either calling api_rpc_reply or api_rpc_ack. No new requests can be accepted
- * until the current one is acknowledged.
+ * The mailbox must be cleared before a new message can be received.
  */
-static inline int64_t hf_rpc_read_request(bool block)
+static inline int64_t hf_mailbox_receive(bool block)
 {
-	return hf_call(HF_RPC_READ_REQUEST, block, 0, 0);
+	return hf_call(HF_MAILBOX_RECEIVE, block, 0, 0);
 }
 
 /**
- * Acknowledges that either a request or a reply has been received and handled.
- * After this call completes, the caller will be able to receive additional
- * requests or replies.
+ * Clears the mailbox so a new message can be received.
  */
-static inline int64_t hf_rpc_ack(void)
+static inline int64_t hf_mailbox_clear(void)
 {
-	return hf_call(HF_RPC_ACK, 0, 0, 0);
-}
-
-/**
- * Called by a secondary VM to send a reply to the primary VM. Data is copied
- * from the caller's send buffer to the destination's receive buffer.
- *
- * It can optionally acknowledge the pending request.
- */
-static inline int64_t hf_rpc_reply(size_t size, bool ack)
-{
-	return hf_call(HF_RPC_REPLY, size, ack, 0);
+	return hf_call(HF_MAILBOX_CLEAR, 0, 0, 0);
 }
diff --git a/src/api.c b/src/api.c
index 11a2632..cd90205 100644
--- a/src/api.c
+++ b/src/api.c
@@ -7,12 +7,16 @@
 
 #include "vmapi/hf/call.h"
 
-static_assert(HF_RPC_REQUEST_MAX_SIZE == PAGE_SIZE,
+static_assert(HF_MAILBOX_SIZE == PAGE_SIZE,
 	      "Currently, a page is mapped for the send and receive buffers so "
 	      "the maximum request is the size of a page.");
 
 /**
  * Switches the physical CPU back to the corresponding vcpu of the primary VM.
+ *
+ * This triggers the scheduling logic to run. Run in the context of secondary VM
+ * to cause HF_VCPU_RUN to return and the primary VM to regain control of the
+ * cpu.
  */
 static struct vcpu *api_switch_to_primary(size_t primary_retval,
 					  enum vcpu_state secondary_state)
@@ -25,8 +29,7 @@
 	vm_set_current(primary);
 
 	/*
-	 * Inidicate to primary VM that this vcpu blocked waiting for an
-	 * interrupt.
+	 * Set the return valuefor the primary VM's call to HF_VCPU_RUN.
 	 */
 	arch_regs_set_retval(&next->regs, primary_retval);
 
@@ -39,6 +42,28 @@
 }
 
 /**
+ * Returns to the primary vm leaving the current vcpu ready to be scheduled
+ * again.
+ */
+struct vcpu *api_yield(void)
+{
+	return api_switch_to_primary(
+		HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_YIELD, 0, 0),
+		vcpu_state_ready);
+}
+
+/**
+ * Puts the current vcpu in wait for interrupt mode, and returns to the primary
+ * vm.
+ */
+struct vcpu *api_wait_for_interrupt(void)
+{
+	return api_switch_to_primary(
+		HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0, 0),
+		vcpu_state_blocked_interrupt);
+}
+
+/**
  * Returns the number of VMs configured to run.
  */
 int64_t api_vm_get_count(void)
@@ -100,19 +125,20 @@
 
 	sl_lock(&vcpu->lock);
 	if (vcpu->state != vcpu_state_ready) {
-		ret = HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0);
+		ret = HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0,
+					   0);
 	} else {
 		vcpu->state = vcpu_state_running;
 		vm_set_current(vm);
 		*next = vcpu;
-		ret = HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_YIELD, 0);
+		ret = HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_YIELD, 0, 0);
 	}
 	sl_unlock(&vcpu->lock);
 
 	return ret;
 
 fail:
-	return HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0);
+	return HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0, 0);
 }
 
 /**
@@ -137,7 +163,7 @@
 	sl_lock(&vm->lock);
 
 	/* We only allow these to be setup once. */
-	if (vm->rpc.send || vm->rpc.recv) {
+	if (vm->mailbox.send || vm->mailbox.recv) {
 		ret = -1;
 		goto exit;
 	}
@@ -168,8 +194,9 @@
 	pa_recv_end = pa_add(pa_recv_begin, PAGE_SIZE);
 
 	/* Map the send page as read-only in the hypervisor address space. */
-	vm->rpc.send = mm_identity_map(pa_send_begin, pa_send_end, MM_MODE_R);
-	if (!vm->rpc.send) {
+	vm->mailbox.send =
+		mm_identity_map(pa_send_begin, pa_send_end, MM_MODE_R);
+	if (!vm->mailbox.send) {
 		ret = -1;
 		goto exit;
 	}
@@ -178,9 +205,10 @@
 	 * Map the receive page as writable in the hypervisor address space. On
 	 * failure, unmap the send page before returning.
 	 */
-	vm->rpc.recv = mm_identity_map(pa_recv_begin, pa_recv_end, MM_MODE_W);
-	if (!vm->rpc.recv) {
-		vm->rpc.send = NULL;
+	vm->mailbox.recv =
+		mm_identity_map(pa_recv_begin, pa_recv_end, MM_MODE_W);
+	if (!vm->mailbox.recv) {
+		vm->mailbox.send = NULL;
 		mm_unmap(pa_send_begin, pa_send_end, 0);
 		ret = -1;
 		goto exit;
@@ -196,18 +224,20 @@
 }
 
 /**
- * Sends an RPC request from the primary VM to a secondary VM. Data is copied
- * from the caller's send buffer to the destination's receive buffer.
+ * Copies data from the sender's send buffer to the recipient's receive buffer
+ * and notifies the recipient.
  */
-int64_t api_rpc_request(uint32_t vm_id, size_t size)
+int64_t api_mailbox_send(uint32_t vm_id, size_t size, struct vcpu **next)
 {
 	struct vm *from = cpu()->current->vm;
 	struct vm *to;
 	const void *from_buf;
+	uint16_t vcpu;
 	int64_t ret;
+	int64_t primary_ret;
 
-	/* Basic argument validation. */
-	if (size > HF_RPC_REQUEST_MAX_SIZE) {
+	/* Limit the size of transfer. */
+	if (size > HF_MAILBOX_SIZE) {
 		return -1;
 	}
 
@@ -222,199 +252,169 @@
 		return -1;
 	}
 
-	/* Only the primary VM can make calls. */
-	if (from->id != HF_PRIMARY_VM_ID) {
-		return -1;
-	}
-
 	/*
 	 * Check that the sender has configured its send buffer. It is safe to
 	 * use from_buf after releasing the lock because the buffer cannot be
 	 * modified once it's configured.
 	 */
 	sl_lock(&from->lock);
-	from_buf = from->rpc.send;
+	from_buf = from->mailbox.send;
 	sl_unlock(&from->lock);
-	if (!from_buf) {
+	if (from_buf == NULL) {
 		return -1;
 	}
 
 	sl_lock(&to->lock);
 
-	if (to->rpc.state != rpc_state_idle || !to->rpc.recv) {
+	if (to->mailbox.state != mailbox_state_empty ||
+	    to->mailbox.recv == NULL) {
 		/* Fail if the target isn't currently ready to receive data. */
 		ret = -1;
-	} else {
-		/* Copy data. */
-		memcpy(to->rpc.recv, from_buf, size);
-		to->rpc.recv_bytes = size;
-
-		if (!to->rpc.recv_waiter) {
-			to->rpc.state = rpc_state_pending;
-			ret = to->vcpu_count;
-		} else {
-			struct vcpu *to_vcpu = to->rpc.recv_waiter;
-
-			to->rpc.state = rpc_state_inflight;
-
-			/*
-			 * Take target vcpu out of waiter list and mark as ready
-			 * to run again.
-			 */
-			sl_lock(&to_vcpu->lock);
-			to->rpc.recv_waiter = to_vcpu->rpc_next;
-			to_vcpu->state = vcpu_state_ready;
-			arch_regs_set_retval(&to_vcpu->regs, size);
-			sl_unlock(&to_vcpu->lock);
-
-			ret = to_vcpu - to->vcpus;
-		}
+		goto out;
 	}
 
+	/* Copy data. */
+	memcpy(to->mailbox.recv, from_buf, size);
+	to->mailbox.recv_bytes = size;
+	to->mailbox.recv_from_id = from->id;
+	to->mailbox.state = mailbox_state_read;
+
+	/* Messages for the primary VM are delivered directly. */
+	if (to->id == HF_PRIMARY_VM_ID) {
+		primary_ret =
+			HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_MESSAGE, 0, size);
+		ret = 0;
+		goto out;
+	}
+
+	/*
+	 * Try to find a vcpu to handle the message and tell the scheduler to
+	 * run it.
+	 */
+	if (to->mailbox.recv_waiter == NULL) {
+		/*
+		 * The scheduler must choose a vcpu to interrupt so it can
+		 * handle the message.
+		 */
+		to->mailbox.state = mailbox_state_received;
+		vcpu = HF_INVALID_VCPU;
+	} else {
+		struct vcpu *to_vcpu = to->mailbox.recv_waiter;
+
+		/*
+		 * Take target vcpu out of waiter list and mark as ready
+		 * to run again.
+		 */
+		sl_lock(&to_vcpu->lock);
+		to->mailbox.recv_waiter = to_vcpu->mailbox_next;
+		to_vcpu->state = vcpu_state_ready;
+
+		/* Return from HF_MAILBOX_RECEIVE. */
+		arch_regs_set_retval(&to_vcpu->regs,
+				     HF_MAILBOX_RECEIVE_RESPONSE(
+					     to->mailbox.recv_from_id, size));
+
+		sl_unlock(&to_vcpu->lock);
+
+		vcpu = to_vcpu - to->vcpus;
+	}
+
+	/* Return to the primary VM directly or with a switch. */
+	primary_ret = HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAKE_UP, to->id, vcpu);
+	ret = 0;
+
+out:
+	/*
+	 * Unlock before routing the return values as switching to the primary
+	 * will acquire more locks and nesting the locks is avoidable.
+	 */
 	sl_unlock(&to->lock);
 
-	return ret;
+	/* Report errors to the sender. */
+	if (ret != 0) {
+		return ret;
+	}
+
+	/* If the sender is the primary, return the vcpu to schedule. */
+	if (from->id == HF_PRIMARY_VM_ID) {
+		return vcpu;
+	}
+
+	/* Switch to primary for scheduling and return success to the sender. */
+	*next = api_switch_to_primary(primary_ret, vcpu_state_ready);
+	return 0;
 }
 
 /**
- * Reads a request sent from a previous call to api_rpc_request. If one isn't
- * available, this function can optionally block the caller until one becomes
- * available.
+ * Receives a message from the mailbox. If one isn't available, this function
+ * can optionally block the caller until one becomes available.
  *
- * Once the caller has completed handling a request, it must indicate it by
- * either calling api_rpc_reply or api_rpc_ack. No new requests can be accepted
- * until the current one is acknowledged.
+ * No new messages can be received until the mailbox has been cleared.
  */
-int64_t api_rpc_read_request(bool block, struct vcpu **next)
+int64_t api_mailbox_receive(bool block, struct vcpu **next)
 {
 	struct vcpu *vcpu = cpu()->current;
 	struct vm *vm = vcpu->vm;
-	struct vm *primary = vm_get(HF_PRIMARY_VM_ID);
-	int64_t ret;
+	int64_t ret = 0;
 
-	/* Only the secondary VMs can receive calls. */
+	/*
+	 * 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 -1;
 	}
 
 	sl_lock(&vm->lock);
-	if (vm->rpc.state == rpc_state_pending) {
-		ret = vm->rpc.recv_bytes;
-		vm->rpc.state = rpc_state_inflight;
-	} else if (!block) {
-		ret = -1;
-	} else {
-		sl_lock(&vcpu->lock);
-		vcpu->state = vcpu_state_blocked_rpc;
 
-		/* Push vcpu into waiter list. */
-		vcpu->rpc_next = vm->rpc.recv_waiter;
-		vm->rpc.recv_waiter = vcpu;
-		sl_unlock(&vcpu->lock);
-
-		/* Switch back to primary vm. */
-		*next = &primary->vcpus[cpu_index(cpu())];
-		vm_set_current(primary);
-
-		/*
-		 * Inidicate to primary VM that this vcpu blocked waiting for an
-		 * interrupt.
-		 */
-		arch_regs_set_retval(
-			&(*next)->regs,
-			HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT,
-					     0));
-		ret = 0;
+	/* Return pending messages without blocking. */
+	if (vm->mailbox.state == mailbox_state_received) {
+		vm->mailbox.state = mailbox_state_read;
+		block = false;
+		ret = HF_MAILBOX_RECEIVE_RESPONSE(vm->mailbox.recv_from_id,
+						  vm->mailbox.recv_bytes);
+		goto out;
 	}
+
+	/* No pending message so fail if not allowed to block. */
+	if (!block) {
+		ret = -1;
+		goto out;
+	}
+
+	sl_lock(&vcpu->lock);
+	vcpu->state = vcpu_state_blocked_mailbox;
+
+	/* Push vcpu into waiter list. */
+	vcpu->mailbox_next = vm->mailbox.recv_waiter;
+	vm->mailbox.recv_waiter = vcpu;
+	sl_unlock(&vcpu->lock);
+
+	/* Switch back to primary vm to block. */
+	*next = api_wait_for_interrupt();
+
+out:
 	sl_unlock(&vm->lock);
 
 	return ret;
 }
 
 /**
- * Sends a reply from a secondary VM to the primary VM. Data is copied from the
- * caller's send buffer to the destination's receive buffer.
- *
- * It can optionally acknowledge the pending request.
+ * Clears the caller's mailbox so that a new message can be received. The caller
+ * must have copied out all data they wish to preserve as new messages will
+ * overwrite the old and will arrive asynchronously.
  */
-int64_t api_rpc_reply(size_t size, bool ack, struct vcpu **next)
-{
-	struct vm *from = cpu()->current->vm;
-	struct vm *to;
-	const void *from_buf;
-
-	/* Basic argument validation. */
-	if (size > PAGE_SIZE) {
-		return -1;
-	}
-
-	/* Only the secondary VM can send responses. */
-	if (from->id == HF_PRIMARY_VM_ID) {
-		return -1;
-	}
-
-	/* Acknowledge the current pending request if requested. */
-	if (ack) {
-		api_rpc_ack();
-	}
-
-	/*
-	 * Check that the sender has configured its send buffer. It is safe to
-	 * use from_buf after releasing the lock because the buffer cannot be
-	 * modified once it's configured.
-	 */
-	sl_lock(&from->lock);
-	from_buf = from->rpc.send;
-	sl_unlock(&from->lock);
-	if (!from_buf) {
-		return -1;
-	}
-
-	to = vm_get(HF_PRIMARY_VM_ID);
-	sl_lock(&to->lock);
-
-	if (to->rpc.state != rpc_state_idle || !to->rpc.recv) {
-		/*
-		 * Fail if the target isn't currently ready to receive a
-		 * response.
-		 */
-		sl_unlock(&to->lock);
-		return -1;
-	}
-
-	/* Copy data. */
-	memcpy(to->rpc.recv, from_buf, size);
-	to->rpc.recv_bytes = size;
-	to->rpc.state = rpc_state_inflight;
-	sl_unlock(&to->lock);
-
-	/*
-	 * Switch back to primary VM so that it is aware that a response was
-	 * received. But we leave the current vcpu still runnable.
-	 */
-	*next = api_switch_to_primary(
-		HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_RESPONSE_READY, size),
-		vcpu_state_ready);
-
-	return 0;
-}
-
-/**
- * Acknowledges that either a request or a reply has been received and handled.
- * After this call completes, the caller will be able to receive additional
- * requests or replies.
- */
-int64_t api_rpc_ack(void)
+int64_t api_mailbox_clear(void)
 {
 	struct vm *vm = cpu()->current->vm;
 	int64_t ret;
 
 	sl_lock(&vm->lock);
-	if (vm->rpc.state != rpc_state_inflight) {
-		ret = -1;
-	} else {
+	if (vm->mailbox.state == mailbox_state_read) {
 		ret = 0;
-		vm->rpc.state = rpc_state_idle;
+		vm->mailbox.state = mailbox_state_empty;
+	} else {
+		ret = -1;
 	}
 	sl_unlock(&vm->lock);
 
@@ -424,24 +424,3 @@
 
 	return ret;
 }
-
-/**
- * Returns to the primary vm leaving the current vcpu ready to be scheduled
- * again.
- */
-struct vcpu *api_yield(void)
-{
-	return api_switch_to_primary(HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_YIELD, 0),
-				     vcpu_state_ready);
-}
-
-/**
- * Puts the current vcpu in wait for interrupt mode, and returns to the primary
- * vm.
- */
-struct vcpu *api_wait_for_interrupt(void)
-{
-	return api_switch_to_primary(
-		HF_VCPU_RUN_RESPONSE(HF_VCPU_RUN_WAIT_FOR_INTERRUPT, 0),
-		vcpu_state_blocked_interrupt);
-}
diff --git a/src/arch/aarch64/handler.c b/src/arch/aarch64/handler.c
index b982bf9..4bdbb04 100644
--- a/src/arch/aarch64/handler.c
+++ b/src/arch/aarch64/handler.c
@@ -189,20 +189,16 @@
 		ret.user_ret = api_vm_configure(ipa_init(arg1), ipa_init(arg2));
 		break;
 
-	case HF_RPC_REQUEST:
-		ret.user_ret = api_rpc_request(arg1, arg2);
+	case HF_MAILBOX_SEND:
+		ret.user_ret = api_mailbox_send(arg1, arg2, &ret.new);
 		break;
 
-	case HF_RPC_READ_REQUEST:
-		ret.user_ret = api_rpc_read_request(arg1, &ret.new);
+	case HF_MAILBOX_RECEIVE:
+		ret.user_ret = api_mailbox_receive(arg1, &ret.new);
 		break;
 
-	case HF_RPC_ACK:
-		ret.user_ret = api_rpc_ack();
-		break;
-
-	case HF_RPC_REPLY:
-		ret.user_ret = api_rpc_reply(arg1, arg2, &ret.new);
+	case HF_MAILBOX_CLEAR:
+		ret.user_ret = api_mailbox_clear();
 		break;
 
 	default:
diff --git a/src/vm.c b/src/vm.c
index 0958682..b62238d 100644
--- a/src/vm.c
+++ b/src/vm.c
@@ -24,7 +24,7 @@
 
 	vm->id = vm_count;
 	vm->vcpu_count = vcpu_count;
-	vm->rpc.state = rpc_state_idle;
+	vm->mailbox.state = mailbox_state_empty;
 
 	/* Do basic initialization of vcpus. */
 	for (i = 0; i < vcpu_count; i++) {