xref: /kvmtool/kvm.c (revision 895c2fef34e94f5acdb6b2260702a12dce1af3b1)

#include "kvm/cpu.h"

#include <linux/kvm.h>
#include <stdbool.h>
#include <stdlib.h>
#include <fcntl.h>

struct kvm {
	int			fd;		/* /dev/kvm */
	int			vmfd;
	int			vcpu_fd;
};

static void die(const char *s)
{
	perror(s);
	exit(1);
}

static void cpu__reset(struct cpu *self)
{
	self->regs.eip		= 0x000fff0UL;
	self->regs.eflags	= 0x0000002UL;
}

static struct cpu *cpu__new(void)
{
	return calloc(1, sizeof(struct cpu));
}

static inline bool kvm__supports_extension(struct kvm *self, unsigned int extension)
{
	int ret;

	ret = ioctl(self->fd, KVM_CHECK_EXTENSION, extension);
	if (ret < 0)
		return false;

	return ret;
}

static struct kvm *kvm__new(void)
{
	struct kvm *self = calloc(1, sizeof *self);

	if (!self)
		die("out of memory");

	return self;
}

static struct kvm *kvm__init(void)
{
	struct kvm_userspace_memory_region mem;
	struct kvm *self;
	int ret;

	self = kvm__new();

	self->fd = open("/dev/kvm", O_RDWR);
	if (self->fd < 0)
		die("open");

	ret = ioctl(self->fd, KVM_GET_API_VERSION, 0);
	if (ret != KVM_API_VERSION)
		die("ioctl");

	self->vmfd = ioctl(self->fd, KVM_CREATE_VM, 0);
	if (self->vmfd < 0)
		die("open");

	if (!kvm__supports_extension(self, KVM_CAP_USER_MEMORY))
		die("KVM_CAP_USER_MEMORY");

	mem = (struct kvm_userspace_memory_region) {
		.slot			= 0,
		.guest_phys_addr	= 0x0UL,
		.memory_size		= 64UL * 1024UL * 1024UL,
	};

	ret = ioctl(self->vmfd, KVM_SET_USER_MEMORY_REGION, &mem, 1);
	if (ret < 0)
		die("ioctl(KVM_SET_USER_MEMORY_REGION)");

	if (!kvm__supports_extension(self, KVM_CAP_SET_TSS_ADDR))
		die("KVM_CAP_SET_TSS_ADDR");

	ret = ioctl(self->vmfd, KVM_SET_TSS_ADDR, 0xfffbd000);
	if (ret < 0)
		die("ioctl(KVM_SET_TSS_ADDR)");

	self->vcpu_fd = ioctl(self->vmfd, KVM_CREATE_VCPU, 0);
	if (self->vcpu_fd < 0)
		die("ioctl(KVM_CREATE_VCPU)");

	return self;
}

static void kvm__run(struct kvm *self)
{
	int ret;

	ret = ioctl(self->vcpu_fd, KVM_RUN, 0);
	if (ret < 0)
		die("KVM_RUN");
}

int main(int argc, char *argv[])
{
	struct cpu *cpu;
	struct kvm *kvm;
	int ret;

	kvm = kvm__init();

	cpu = cpu__new();

	cpu__reset(cpu);

	kvm__run(kvm);

	return 0;
}