#include <stdio.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <parlib/arch/arch.h>
#include <parlib/ros_debug.h>
#include <unistd.h>
#include <gelf.h>
#include <errno.h>
#include <libelf.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <ros/syscall.h>
#include <sys/mman.h>
#include <vmm/vmm.h>
#include <vmm/acpi/acpi.h>
#include <ros/arch/mmu.h>
#include <ros/arch/membar.h>
#include <ros/vmm.h>
#include <parlib/uthread.h>
#include <vmm/linux_bootparam.h>
#include <getopt.h>
#include <parlib/alarm.h>

#include <vmm/virtio.h>
#include <vmm/virtio_blk.h>
#include <vmm/virtio_mmio.h>
#include <vmm/virtio_ids.h>
#include <vmm/virtio_config.h>
#include <vmm/virtio_console.h>
#include <vmm/virtio_net.h>
#include <vmm/virtio_lguest_console.h>

#include <vmm/sched.h>
#include <vmm/net.h>
#include <sys/eventfd.h>
#include <sys/uio.h>
#include <parlib/opts.h>

struct virtual_machine local_vm = {.mtx = UTH_MUTEX_INIT},
                            *vm = &local_vm;

struct vmm_gpcore_init *gpcis;

void vapic_status_dump(FILE *f, void *vapic);

#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 1)
#error "Get a gcc newer than 4.4.0"
#else
#define BITOP_ADDR(x) "+m" (*(volatile long *) (x))
#endif

static void virtio_poke_guest(uint8_t vec, uint32_t dest)
{
	if (dest < vm->nr_gpcs) {
		vmm_interrupt_guest(vm, dest, vec);
		return;
	}
	if (dest != 0xffffffff)
		panic("INVALID DESTINATION: 0x%02x\n", dest);

	for (int i = 0; i < vm->nr_gpcs; i++)
		vmm_interrupt_guest(vm, i, vec);
}

static struct virtio_mmio_dev cons_mmio_dev = {
	.poke_guest = virtio_poke_guest,
};

static struct virtio_console_config cons_cfg;
static struct virtio_console_config cons_cfg_d;

static struct virtio_vq_dev cons_vqdev = {
	.name = "console",
	.dev_id = VIRTIO_ID_CONSOLE,
	.dev_feat =
	(1ULL << VIRTIO_F_VERSION_1) | (1 << VIRTIO_RING_F_INDIRECT_DESC),
	.num_vqs = 2,
	.cfg = &cons_cfg,
	.cfg_d = &cons_cfg_d,
	.cfg_sz = sizeof(struct virtio_console_config),
	.transport_dev = &cons_mmio_dev,
	.vqs = {
		{
			.name = "cons_receiveq",
			.qnum_max = 64,
			.srv_fn = cons_receiveq_fn,
			.vqdev = &cons_vqdev
		},
		{
			.name = "cons_transmitq",
			.qnum_max = 64,
			.srv_fn = cons_transmitq_fn,
			.vqdev = &cons_vqdev
		},
	}
};

static struct virtio_mmio_dev net_mmio_dev = {
	.poke_guest = virtio_poke_guest,
};

static struct virtio_net_config net_cfg = {
	.max_virtqueue_pairs = 1
};
static struct virtio_net_config net_cfg_d = {
	.max_virtqueue_pairs = 1
};

static struct virtio_vq_dev net_vqdev = {
	.name = "network",
	.dev_id = VIRTIO_ID_NET,
	.dev_feat = (1ULL << VIRTIO_F_VERSION_1 | 1 << VIRTIO_NET_F_MAC),

	.num_vqs = 2,
	.cfg = &net_cfg,
	.cfg_d = &net_cfg_d,
	.cfg_sz = sizeof(struct virtio_net_config),
	.transport_dev = &net_mmio_dev,
	.vqs = {
		{
			.name = "net_receiveq",
			.qnum_max = 64,
			.srv_fn = net_receiveq_fn,
			.vqdev = &net_vqdev
		},
		{
			.name = "net_transmitq",
			.qnum_max = 64,
			.srv_fn = net_transmitq_fn,
			.vqdev = &net_vqdev
		},
	}
};

static struct virtio_mmio_dev blk_mmio_dev = {
	.poke_guest = virtio_poke_guest,
};

static struct virtio_blk_config blk_cfg = {
};

static struct virtio_blk_config blk_cfg_d = {
};

static struct virtio_vq_dev blk_vqdev = {
	.name = "block",
	.dev_id = VIRTIO_ID_BLOCK,
	.dev_feat = (1ULL << VIRTIO_F_VERSION_1),

	.num_vqs = 1,
	.cfg = &blk_cfg,
	.cfg_d = &blk_cfg_d,
	.cfg_sz = sizeof(struct virtio_blk_config),
	.transport_dev = &blk_mmio_dev,
	.vqs = {
		{
			.name = "blk_request",
			.qnum_max = 64,
			.srv_fn = blk_request,
			.vqdev = &blk_vqdev
		},
	}
};

/* Parse func: given a line of text, it sets any vnet options */
static void __parse_vnet_opts(char *_line)
{
	char *eq, *spc;

	/* Check all bools first */
	if (!strcmp(_line, "snoop")) {
		vnet_snoop = TRUE;
		return;
	}
	if (!strcmp(_line, "map_diagnostics")) {
		vnet_map_diagnostics = TRUE;
		return;
	}
	if (!strcmp(_line, "real_address")) {
		vnet_real_ip_addrs = TRUE;
		return;
	}
	/* Numeric fields, must have an = */
	eq = strchr(_line, '=');
	if (!eq)
		return;
	*eq++ = 0;
	/* Drop spaces before =.  atoi trims any spaces after =. */
	while ((spc = strrchr(_line, ' ')))
		*spc = 0;
	if (!strcmp(_line, "nat_timeout")) {
		vnet_nat_timeout = atoi(eq);
		return;
	}
}

static void set_vnet_opts(char *net_opts)
{
	if (parse_opts_file(net_opts, __parse_vnet_opts))
		perror("parse opts file");
}

/* Parse func: given a line of text, it builds any vnet port forwardings. */
static void __parse_vnet_port_fwds(char *_line)
{
	char *tok, *tok_save = 0;
	char *proto, *host_port, *guest_port;

	tok = strtok_r(_line, ":", &tok_save);
	if (!tok)
		return;
	if (strcmp(tok, "port"))
		return;
	tok = strtok_r(NULL, ":", &tok_save);
	if (!tok) {
		fprintf(stderr, "%s, port with no proto!", __func__);
		return;
	}
	proto = tok;
	tok = strtok_r(NULL, ":", &tok_save);
	if (!tok) {
		fprintf(stderr, "%s, port with no host port!", __func__);
		return;
	}
	host_port = tok;
	tok = strtok_r(NULL, ":", &tok_save);
	if (!tok) {
		fprintf(stderr, "%s, port with no guest port!", __func__);
		return;
	}
	guest_port = tok;
	vnet_port_forward(proto, host_port, guest_port);
}

static void set_vnet_port_fwds(char *net_opts)
{
	if (parse_opts_file(net_opts, __parse_vnet_port_fwds))
		perror("parse opts file");
}

/* We map the APIC-access page, the per core Virtual APIC page and the
 * per core Posted Interrupt Descriptors.
 * Note: check if the PID/PIR needs to be a 4k page. */
void alloc_intr_pages(void)
{
	void *a_page;
	void *pages, *pir;

	a_page = mmap((void *)APIC_GPA, PGSIZE, PROT_READ | PROT_WRITE,
	              MAP_POPULATE | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	fprintf(stderr, "a_page mmap pointer %p\n", a_page);

	if (a_page != (void *)APIC_GPA) {
		perror("Could not mmap APIC");
		exit(1);
	}
	/* The VM should never actually read from this page. */
	for (int i = 0; i < PGSIZE/4; i++)
		((uint32_t *)a_page)[i] = 0xDEADBEEF;

	/* Allocate VAPIC and PIR pages. */
	pages = mmap((void*)0, vm->nr_gpcs * 2 * PGSIZE, PROT_READ | PROT_WRITE,
	             MAP_POPULATE | MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	if (pages == MAP_FAILED) {
		perror("Unable to map VAPIC and PIR pages.");
		exit(1);
	}

	/* We use the first vm->nr_gpcs pages for the VAPIC, and the second set
	 * for the PIRs. Each VAPIC and PIR gets its own 4k page. */
	pir = pages + (vm->nr_gpcs * PGSIZE);

	/* Set the addresses in the gpcis.  These gpcis get copied into the
	 * guest_threads during their construction. */
	for (int i = 0; i < vm->nr_gpcs; i++) {
		gpcis[i].posted_irq_desc = pir + (PGSIZE * i);
		gpcis[i].vapic_addr = pages + (PGSIZE * i);
		gpcis[i].apic_addr = a_page;
		gpcis[i].fsbase = 0;
		gpcis[i].gsbase = 0;

		/* Set APIC ID. */
		((uint32_t *)gpcis[i].vapic_addr)[0x20/4] = i;
		/* Set APIC VERSION. */
		((uint32_t *)gpcis[i].vapic_addr)[0x30/4] = 0x01060015;
		/* Set LOGICAL APIC ID. */
		((uint32_t *)gpcis[i].vapic_addr)[0xD0/4] = 1 << i;
	}
}

/* This rams all cores with a valid timer vector and initial count
 * with a timer interrupt. Used only for debugging/as a temporary workaround */
void *inject_timer_spurious(void *args)
{
	struct vmm_gpcore_init *curgpci;
	uint32_t initial_count;
	uint8_t vector;

	for (int i = 0; i < vm->nr_gpcs; i++) {
		curgpci = gth_to_gpci(gpcid_to_gth(vm, i));
		vector = ((uint32_t *)curgpci->vapic_addr)[0x32] & 0xff;
		initial_count = ((uint32_t *)curgpci->vapic_addr)[0x38];
		if (initial_count && vector)
			vmm_interrupt_guest(vm, i, vector);
	}
	return 0;
}

/* This injects the timer interrupt to the guest. */
void *inject_timer(void *args)
{
	struct guest_thread *gth = (struct guest_thread*)args;
	struct vmm_gpcore_init *gpci = gth_to_gpci(gth);
	uint8_t vector = ((uint32_t *)gpci->vapic_addr)[0x32] & 0xff;

	vmm_interrupt_guest(vm, gth->gpc_id, vector);
	return 0;
}

/* This handler must never call set_alarm after interrupting the guest,
 * otherwise the guest could try to write to the timer msrs and cause a
 * race condition. */
void timer_alarm_handler(struct alarm_waiter *waiter)
{
	uint8_t vector;
	uint32_t initial_count;
	uint32_t divide_config_reg;
	uint32_t multiplier;
	uint32_t timer_mode;
	struct guest_thread *gth = (struct guest_thread*)waiter->data;
	struct vmm_gpcore_init *gpci = gth_to_gpci(gth);

	vector = ((uint32_t *)gpci->vapic_addr)[0x32] & 0xff;
	timer_mode = (((uint32_t *)gpci->vapic_addr)[0x32] >> 17) & 0x03;
	initial_count = ((uint32_t *)gpci->vapic_addr)[0x38];
	divide_config_reg = ((uint32_t *)gpci->vapic_addr)[0x3E];

	/* Don't blame me for this. Look at the intel manual
	 * Vol 3 10.5.4 APIC Timer */
	multiplier = (((divide_config_reg & 0x08) >> 1) |
	              (divide_config_reg & 0x03)) + 1;
	multiplier &= 0x07;

	if (vector && initial_count && timer_mode == 0x01) {
		/* This is periodic, we reset the alarm */
		set_awaiter_rel(waiter, initial_count << multiplier);
		set_alarm(waiter);
	}

	/* We spin up a task to inject the timer because vmm_interrupt_guest
	 * may block and we can't do that from vcore context. */
	vmm_run_task(vm, inject_timer, gth);
}

/* This sets up the structs for each of the guest pcore's timers, but
 * doesn't actually start the alarms until the core writes all the reasonable
 * values to the x2apic msrs. */
void init_timer_alarms(void)
{
	for (uint64_t i = 0; i < vm->nr_gpcs; i++) {
		struct alarm_waiter *timer_alarm =
			malloc(sizeof(struct alarm_waiter));
		struct guest_thread *gth = gpcid_to_gth(vm, i);

		/* TODO: consider a struct to bundle a bunch of things, not just
		 * timer_alarm. */
		gth->user_data = (void *)timer_alarm;
		timer_alarm->data = gth;
		init_awaiter(timer_alarm, timer_alarm_handler);
	}
}

int main(int argc, char **argv)
{
	int debug = 0;
	unsigned long long memsize = GiB;
	uintptr_t memstart = MinMemory;
	uintptr_t memend;
	struct boot_params *bp;
	char cmdline_default[512] = {0};
	char *cmdline_extra = "\0";
	char *cmdline;
	void *a = (void *)0xe0000;
	int vmmflags = 0;
	uint64_t entry = 0;
	int ret;
	struct vm_trapframe *vm_tf;
	char *cmdlinep;
	int cmdlinesz, len, cmdline_fd;
	char *disk_image_file = NULL;
	int c;
	struct stat stat_result;
	int num_read;
	int option_index;
	char *smbiostable = NULL;
	char *net_opts = NULL;
	uint64_t num_pcs = 1;
	bool is_greedy = FALSE;
	bool is_scp = FALSE;
	char *initrd = NULL;
	uint64_t initrd_start = 0, initrd_size = 0;
	uint64_t kernel_max_address;

	static struct option long_options[] = {
		{"debug",         no_argument,       0, 'd'},
		{"vmm_vmcall",    no_argument,       0, 'v'},
		{"maxresume",     required_argument, 0, 'R'},
		{"memsize",       required_argument, 0, 'm'},
		{"memstart",      required_argument, 0, 'M'},
		{"cmdline_extra", required_argument, 0, 'c'},
		{"greedy",        no_argument,       0, 'g'},
		{"initrd",        required_argument, 0, 'i'},
		{"scp",           no_argument,       0, 's'},
		{"image_file",    required_argument, 0, 'f'},
		{"cmdline",       required_argument, 0, 'k'},
		{"net",           required_argument, 0, 'n'},
		{"num_cores",     required_argument, 0, 'N'},
		{"smbiostable",   required_argument, 0, 't'},
		{"help",          no_argument,       0, 'h'},
		{0, 0, 0, 0}
	};

	fprintf(stderr, "%p %p %p %p\n", PGSIZE, PGSHIFT, PML1_SHIFT,
	        PML1_PTE_REACH);

	if ((uintptr_t)__procinfo.program_end >= MinMemory) {
		fprintf(stderr,
		        "Panic: vmrunkernel binary extends into guest memory\n");
		exit(1);
	}

	vm->low4k = malloc(PGSIZE);
	memset(vm->low4k, 0xff, PGSIZE);
	vm->low4k[0x40e] = 0;
	vm->low4k[0x40f] = 0;
	// Why is this here? Because the static initializer is getting
	// set to 1.  Yes, 1. This might be part of the weirdness
	// Barrett is reporting with linker sets. So let's leave it
	// here until we trust our toolchain.
	if (memsize != GiB)
		fprintf(stderr, "static initializers are broken\n");
	memsize = GiB;

	while ((c = getopt_long(argc, argv, "dvi:m:M:c:gsf:k:N:n:t:hR:",
				long_options, &option_index)) != -1) {
		switch (c) {
		case 'd':
			debug++;
			break;
		case 'v':
			vmmflags |= VMM_CTL_FL_KERN_PRINTC;
			break;
		case 'm':
			memsize = strtoull(optarg, 0, 0);
			break;
		case 'M':
			memstart = strtoull(optarg, 0, 0);
			break;
		case 'c':
			cmdline_extra = optarg;
		case 'g':	/* greedy */
			parlib_never_yield = TRUE;
			if (is_scp) {
				fprintf(stderr,
					"Can't be both greedy and an SCP\n");
				exit(1);
			}
			is_greedy = TRUE;
			break;
		case 's':	/* scp */
			parlib_wants_to_be_mcp = FALSE;
			if (is_greedy) {
				fprintf(stderr,
					"Can't be both greedy and an SCP\n");
				exit(1);
			}
			is_scp = TRUE;
			break;
		case 'f':	/* file to pass to blk_init */
			disk_image_file = optarg;
			break;
		case 'i':
			initrd = optarg;
			break;
		case 'k':	/* specify file to get cmdline args from */
			cmdline_fd = open(optarg, O_RDONLY);
			if (cmdline_fd < 0) {
				fprintf(stderr, "failed to open file: %s\n",
					optarg);
				exit(1);
			}
			if (stat(optarg, &stat_result) == -1) {
				fprintf(stderr, "stat of %s failed\n", optarg);
				exit(1);
			}
			len = stat_result.st_size;
			if (len > 512) {
				fprintf(stderr, "command line options exceed 512 bytes!");
				exit(1);
			}
			num_read = read(cmdline_fd, cmdline_default, len);
			if (num_read != len) {
				fprintf(stderr, "read failed len was : %d, num_read was: %d\n",
				        len, num_read);
				exit(1);
			}
			close(cmdline_fd);
			break;
		case 't':
			smbiostable = optarg;
			break;
		case 'n':
			net_opts = optarg;
			break;
		case 'N':
			num_pcs = strtoull(optarg, 0, 0);
			break;
		case 'h':
		default:
			// Sadly, the getopt_long struct does
			// not have a pointer to help text.
			for (int i = 0;
			     i <
			     sizeof(long_options) / sizeof(long_options[0]) - 1;
			     i++) {
				struct option *l = &long_options[i];

				fprintf(stderr, "%s or %c%s\n", l->name, l->val,
				        l->has_arg ? " <arg>" : "");
			}
			exit(0);
		}
	}

	if (strlen(cmdline_default) == 0) {
		fprintf(stderr,
			"WARNING: No command line parameter file specified.\n");
	}
	argc -= optind;
	argv += optind;
	if (argc < 1) {
		fprintf(stderr, "Usage: %s vmimage [-n (no vmcall printf)]\n",
			argv[0]);
		exit(1);
	}

	// Set vm->nr_gpcs before it's referenced in the struct setups below.
	vm->nr_gpcs = num_pcs;
	fprintf(stderr, "NUM PCS: %d\n", num_pcs);
	/* These are only used to be passed to vmm_init, which makes copies
	 * internally */
	gpcis = (struct vmm_gpcore_init *)
	                malloc(num_pcs * sizeof(struct vmm_gpcore_init));
	alloc_intr_pages();

	memend = memstart + memsize - 1;
	if (memend >= BRK_START) {
		fprintf(stderr,
		        "memstart 0x%llx memsize 0x%llx -> 0x%llx is too large; overlaps BRK_START at %p\n",
		        memstart, memsize, memstart + memsize, BRK_START);
		exit(1);
	}

	mmap_memory(vm, memstart, memsize);

	entry = load_elf(argv[0], 0, &kernel_max_address, NULL);
	if (entry == 0) {
		fprintf(stderr, "Unable to load kernel %s\n", argv[0]);
		exit(1);
	}

	a = setup_biostables(vm, a, smbiostable);

	bp = a;
	a = init_e820map(vm, bp);

	if (initrd) {
		initrd_start = ROUNDUP(kernel_max_address, PGSIZE);
		fprintf(stderr,
			"kernel_max_address is %#p; Load initrd @ %#p\n",
		        kernel_max_address, initrd_start);
		initrd_size = setup_initrd(initrd, (void *)initrd_start,
		                           memend - initrd_start + 1);
		if (initrd_size <= 0) {
			fprintf(stderr, "Unable to load initrd %s\n", initrd);
			exit(1);
		}

		bp->hdr.ramdisk_image = initrd_start;
		bp->hdr.ramdisk_size = initrd_size;
		bp->hdr.root_dev = 0x100;
		bp->hdr.type_of_loader = 0xff;
		fprintf(stderr, "Set bp initrd to %p / %p\n",
		        initrd_start, initrd_size);
	}

	/* The MMIO address of the console device is really the address of an
	 * unbacked EPT page: accesses to this page will cause a page fault that
	 * traps to the host, which will examine the fault, see it was for the
	 * known MMIO address, and fulfill the MMIO read or write on the guest's
	 * behalf accordingly. We place the virtio space at 512 GB higher than
	 * the guest physical memory to avoid a full page table walk. */
	uintptr_t virtio_mmio_base_addr_hint;
	uintptr_t virtio_mmio_base_addr;

	virtio_mmio_base_addr_hint =
	    ROUNDUP((bp->e820_map[bp->e820_entries - 1].addr +
	             bp->e820_map[bp->e820_entries - 1].size),
	             PML4_PTE_REACH);

	/* mmap with prot_none so we don't accidentally mmap something else
	 * here.
	 * We give space for 512 devices right now.
	 * TODO(ganshun): Make it dynamic based on number of virtio devices. */
	virtio_mmio_base_addr =
	    (uintptr_t) mmap((void *) virtio_mmio_base_addr_hint, 512 * PGSIZE,
	                     PROT_NONE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

	if (!virtio_mmio_base_addr || virtio_mmio_base_addr >= BRK_START) {
		/* Either we were unable to mmap at all or we mapped it too
		 * high. */
		panic("Unable to mmap protect space for virtio devices, got 0x%016x",
		      virtio_mmio_base_addr);
	}

	cons_mmio_dev.addr =
		virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_CONSOLE_DEV;
	cons_mmio_dev.vqdev = &cons_vqdev;
	vm->virtio_mmio_devices[VIRTIO_MMIO_CONSOLE_DEV] = &cons_mmio_dev;

	net_mmio_dev.addr =
		virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_NETWORK_DEV;
	net_mmio_dev.vqdev = &net_vqdev;
	vm->virtio_mmio_devices[VIRTIO_MMIO_NETWORK_DEV] = &net_mmio_dev;

	if (disk_image_file != NULL) {
		blk_mmio_dev.addr =
			virtio_mmio_base_addr + PGSIZE * VIRTIO_MMIO_BLOCK_DEV;
		blk_mmio_dev.vqdev = &blk_vqdev;
		vm->virtio_mmio_devices[VIRTIO_MMIO_BLOCK_DEV] = &blk_mmio_dev;
		blk_init_fn(&blk_vqdev, disk_image_file);
	}

	set_vnet_opts(net_opts);
	vnet_init(vm, &net_vqdev);
	set_vnet_port_fwds(net_opts);

	/* Set the kernel command line parameters */
	a += 4096;
	cmdline = a;
	a += 4096;

	bp->hdr.cmd_line_ptr = (uintptr_t) cmdline;

	len = snprintf(cmdline, 4096, "%s %s", cmdline_default, cmdline_extra);

	cmdlinesz = 4096 - len;
	cmdlinep = cmdline + len;

	for (int i = 0; i < VIRTIO_MMIO_MAX_NUM_DEV; i++) {
		if (vm->virtio_mmio_devices[i] == NULL)
			continue;

		/* Append all the virtio mmio base addresses. */

		/* Since the lower number irqs are no longer being used, the
		 * irqs can now be assigned starting from 0.  */
		vm->virtio_mmio_devices[i]->irq = i;
		len = snprintf(cmdlinep, cmdlinesz,
		               "\n virtio_mmio.device=1K@0x%llx:%lld",
		               vm->virtio_mmio_devices[i]->addr,
		               vm->virtio_mmio_devices[i]->irq);
		if (len >= cmdlinesz) {
			fprintf(stderr, "Too many arguments to the linux command line.");
			exit(1);
		}
		cmdlinesz -= len;
		cmdlinep += len;
	}

	/* Set maxcpus to the number of cores we're giving the guest. */
	len = snprintf(cmdlinep, cmdlinesz,
	               "\n maxcpus=%lld\n possible_cpus=%lld", vm->nr_gpcs,
	               vm->nr_gpcs);
	if (len >= cmdlinesz) {
		fprintf(stderr,
			"Too many arguments to the linux command line.");
		exit(1);
	}
	cmdlinesz -= len;
	cmdlinep += len;

	ret = vmm_init(vm, gpcis, vmmflags);
	assert(!ret);
	free(gpcis);

	init_timer_alarms();

	setup_paging(vm);

	vm_tf = gpcid_to_vmtf(vm, 0);
	vm_tf->tf_cr3 = (uint64_t) vm->root;
	vm_tf->tf_rip = entry;
	vm_tf->tf_rsp = 0xe0000;
	vm_tf->tf_rsi = (uint64_t) bp;
	vm_tf->tf_rflags = FL_RSVD_1;
	vm->up_gpcs = 1;
	fprintf(stderr, "Start guest: cr3 %p rip %p\n", vm_tf->tf_cr3, entry);
	start_guest_thread(gpcid_to_gth(vm, 0));

	uthread_sleep_forever();
	return 0;
}