diff --git a/inc/api.h b/inc/api.h
new file mode 100644
index 0000000..edc9797
--- /dev/null
+++ b/inc/api.h
@@ -0,0 +1,17 @@
+#ifndef _API_H
+#define _API_H
+
+#include "cpu.h"
+#include "vm.h"
+
+/* TODO: Can we hide these? */
+extern struct vm secondary_vm[MAX_VMS];
+extern uint32_t secondary_vm_count;
+extern struct vm primary_vm;
+
+int32_t api_vm_get_count(void);
+int32_t api_vcpu_get_count(uint32_t vm_idx);
+int32_t api_vcpu_run(uint32_t vm_idx, uint32_t vcpu_idx, struct vcpu **next);
+struct vcpu *api_wait_for_interrupt(void);
+
+#endif  /* _API_H */
diff --git a/inc/cpu.h b/inc/cpu.h
index 2eae33b..43bd356 100644
--- a/inc/cpu.h
+++ b/inc/cpu.h
@@ -37,7 +37,10 @@
 	void *stack_bottom;
 };
 
+void cpu_module_init(void);
+
 void cpu_init(struct cpu *c);
+size_t cpu_index(struct cpu *c);
 void cpu_irq_enable(struct cpu *c);
 void cpu_irq_disable(struct cpu *c);
 bool cpu_on(struct cpu *c);
diff --git a/src/api.c b/src/api.c
new file mode 100644
index 0000000..a105f6d
--- /dev/null
+++ b/src/api.c
@@ -0,0 +1,72 @@
+#include "api.h"
+
+#include "arch_api.h"
+#include "vm.h"
+
+struct vm secondary_vm[MAX_VMS];
+uint32_t secondary_vm_count;
+struct vm primary_vm;
+
+/**
+ * Returns the number of VMs configured to run.
+ */
+int32_t api_vm_get_count(void)
+{
+	return secondary_vm_count;
+}
+
+/**
+ * Returns the number of vcpus configured in the given VM.
+ */
+int32_t api_vcpu_get_count(uint32_t vm_idx)
+{
+	if (vm_idx >= secondary_vm_count)
+		return -1;
+
+	return secondary_vm[vm_idx].vcpu_count;
+}
+
+/**
+ * Runs the given vcpu of the given vm.
+ */
+int32_t api_vcpu_run(uint32_t vm_idx, uint32_t vcpu_idx, struct vcpu **next)
+{
+	struct vm *vm = secondary_vm + vm_idx;
+	struct vcpu *vcpu;
+
+	/* Only the primary VM can switch vcpus. */
+	if (cpu()->current->vm != &primary_vm)
+		return HF_VCPU_WAIT_FOR_INTERRUPT;
+
+	if (vm_idx >= secondary_vm_count)
+		return HF_VCPU_WAIT_FOR_INTERRUPT;
+
+	vcpu = vm->vcpus + vcpu_idx;
+	if (vcpu_idx >= vm->vcpu_count || !vcpu->is_on)
+		return HF_VCPU_WAIT_FOR_INTERRUPT;
+
+	arch_set_vm_mm(&vm->page_table);
+	*next = vcpu;
+
+	return HF_VCPU_YIELD;
+}
+
+/**
+ * Puts current vcpu in wait for interrupt mode, and returns to the primary
+ * vm.
+ */
+struct vcpu *api_wait_for_interrupt(void)
+{
+	struct vcpu *vcpu = &primary_vm.vcpus[cpu_index(cpu())];
+
+	/* Switch back to primary VM. */
+	arch_set_vm_mm(&primary_vm.page_table);
+
+	/*
+	 * Inidicate to primary VM that this vcpu blocked waiting for an
+	 * interrupt.
+	 */
+	arch_regs_set_retval(&vcpu->regs, HF_VCPU_WAIT_FOR_INTERRUPT);
+
+	return vcpu;
+}
diff --git a/src/arch/aarch64/handler.c b/src/arch/aarch64/handler.c
index 1844e37..48de85d 100644
--- a/src/arch/aarch64/handler.c
+++ b/src/arch/aarch64/handler.c
@@ -1,3 +1,5 @@
+#include "api.h"
+#include "arch_api.h"
 #include "cpu.h"
 #include "dlog.h"
 #include "vm.h"
@@ -21,17 +23,6 @@
 	for (;;);
 }
 
-/* TODO: Define constants below according to spec. */
-#define HF_VCPU_RUN       0xff00
-#define HF_VM_GET_COUNT   0xff01
-#define HF_VCPU_GET_COUNT 0xff02
-
-/* TODO: Move these decl elsewhere. */
-extern struct vm secondary_vm[MAX_VMS];
-extern uint32_t secondary_vm_count;
-extern struct vm primary_vm;
-extern struct cpu cpus[];
-
 struct hvc_handler_return hvc_handler(size_t arg0, size_t arg1, size_t arg2,
 				      size_t arg3)
 {
@@ -49,28 +40,15 @@
 		break;
 
 	case HF_VM_GET_COUNT:
-		ret.user_ret = secondary_vm_count;
+		ret.user_ret = api_vm_get_count();
 		break;
 
 	case HF_VCPU_GET_COUNT:
-		if (arg1 >= secondary_vm_count)
-			ret.user_ret = -1;
-		else
-			ret.user_ret = secondary_vm[arg1].vcpu_count;
+		ret.user_ret = api_vcpu_get_count(arg1);
 		break;
 
 	case HF_VCPU_RUN:
-		/* TODO: Make sure we don't allow secondary VMs to make this
-		 * hvc call. */
-		ret.user_ret = 1; /* WFI */
-		if (arg1 < secondary_vm_count &&
-		    arg2 < secondary_vm[arg1].vcpu_count &&
-		    secondary_vm[arg1].vcpus[arg2].is_on) {
-			arch_set_vm_mm(&secondary_vm[arg1].page_table);
-			/* TODO: Update the virtual memory. */
-			ret.new = secondary_vm[arg1].vcpus + arg2;
-			ret.user_ret = 0;
-		}
+		ret.user_ret = api_vcpu_run(arg1, arg2, &ret.new);
 		break;
 
 	default:
@@ -87,7 +65,7 @@
 
 	/* Switch back to primary VM, interrupts will be handled there. */
 	arch_set_vm_mm(&primary_vm.page_table);
-	return &primary_vm.vcpus[cpus - cpu()];
+	return &primary_vm.vcpus[cpu_index(cpu())];
 }
 
 struct vcpu *sync_lower_exception(uint64_t esr)
@@ -100,18 +78,7 @@
 		/* Check TI bit of ISS, 0 = WFI, 1 = WFE. */
 		if (esr & 1)
 			return NULL;
-
-		/* Switch back to primary VM. */
-		arch_set_vm_mm(&primary_vm.page_table);
-		vcpu = &primary_vm.vcpus[cpus - cpu()];
-
-		dlog("Returning due to WFI\n");
-
-		/* TODO: Use constant. */
-		/* Set return value to 1, indicating to primary VM that this
-		 * vcpu blocked on a WFI. */
-		arch_regs_set_retval(&vcpu->regs, 1);
-		return vcpu;
+		return api_wait_for_interrupt();
 
 	case 0x24: /* EC = 100100, Data abort. */
 		dlog("Data abort: pc=0x%x, esr=0x%x, ec=0x%x", vcpu->regs.pc, esr, esr >> 26);
diff --git a/src/arch/aarch64/inc/arch_api.h b/src/arch/aarch64/inc/arch_api.h
new file mode 100644
index 0000000..733d818
--- /dev/null
+++ b/src/arch/aarch64/inc/arch_api.h
@@ -0,0 +1,14 @@
+#ifndef _ARCH_API_H
+#define _ARCH_API_H
+
+/* Return values for vcpu_run() hypervisor call. */
+#define HF_VCPU_YIELD              0x00
+#define HF_VCPU_WAIT_FOR_INTERRUPT 0x01
+#define HF_VCPU_WAKE_UP            0x02
+
+/* TODO: Define constants below according to spec. */
+#define HF_VCPU_RUN       0xff00
+#define HF_VM_GET_COUNT   0xff01
+#define HF_VCPU_GET_COUNT 0xff02
+
+#endif  /* _ARCH_API_H */
diff --git a/src/cpu.c b/src/cpu.c
index 73a2d1c..bb84bbb 100644
--- a/src/cpu.c
+++ b/src/cpu.c
@@ -5,6 +5,35 @@
 #include "std.h"
 #include "vm.h"
 
+/* The stack to be used by the CPUs. */
+alignas(2 * sizeof(size_t)) static char callstacks[STACK_SIZE * MAX_CPUS];
+
+/* State of all supported CPUs. The stack of the first one is initialized. */
+struct cpu cpus[MAX_CPUS] = {
+	{
+		.is_on = 1,
+		.stack_bottom = callstacks + STACK_SIZE,
+	},
+};
+
+void cpu_module_init(void)
+{
+	size_t i;
+
+	/* Initialize all CPUs. */
+	for (i = 0; i < MAX_CPUS; i++) {
+		struct cpu *c = cpus + i;
+		cpu_init(c);
+		c->id = i; /* TODO: Initialize ID. */
+		c->stack_bottom = callstacks + STACK_SIZE * (i + 1);
+	}
+}
+
+size_t cpu_index(struct cpu *c)
+{
+	return cpus - c;
+}
+
 void cpu_init(struct cpu *c)
 {
 	/* TODO: Assumes that c is zeroed out already. */
diff --git a/src/main.c b/src/main.c
index 885f577..946dceb 100644
--- a/src/main.c
+++ b/src/main.c
@@ -11,17 +11,6 @@
 
 void *fdt;
 
-/* The stack to be used by the CPUs. */
-alignas(2 * sizeof(size_t)) char callstacks[STACK_SIZE * MAX_CPUS];
-
-/* State of all supported CPUs. The stack of the first one is initialized. */
-struct cpu cpus[MAX_CPUS] = {
-	{
-		.is_on = 1,
-		.stack_bottom = callstacks + STACK_SIZE,
-	},
-};
-
 bool fdt_find_node(struct fdt_node *node, const char *path)
 {
 	while (*path) {
@@ -411,17 +400,9 @@
 
 static void one_time_init(void)
 {
-	size_t i;
-
 	dlog("Initializing hafnium\n");
 
-	/* Initialize all CPUs. */
-	for (i = 0; i < MAX_CPUS; i++) {
-		struct cpu *c = cpus + i;
-		cpu_init(c);
-		c->id = i; /* TODO: Initialize ID. */
-		c->stack_bottom = callstacks + STACK_SIZE * (i + 1);
-	}
+	cpu_module_init();
 
 	/* TODO: Code below this point should be removed from this function. */
 	/* TODO: Remove this. */
@@ -470,7 +451,7 @@
 	if (!atomic_flag_test_and_set_explicit(&inited, memory_order_acq_rel))
 		one_time_init();
 
-	dlog("Starting up cpu %d\n", c - cpus);
+	dlog("Starting up cpu %d\n", cpu_index(c));
 
-	return primary_vm.vcpus + (c - cpus);
+	return primary_vm.vcpus + cpu_index(c);
 }
diff --git a/src/rules.mk b/src/rules.mk
index e8022f2..313748d 100644
--- a/src/rules.mk
+++ b/src/rules.mk
@@ -1,4 +1,5 @@
 SRCS += alloc.c
+SRCS += api.c
 SRCS += cpio.c
 SRCS += cpu.c
 SRCS += fdt.c