Add missing files to KVM commit. (05330448) · Commits · SUMMER2020 / students / proj-2021291

kvm-all.c

0 → 100644

+374 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU KVM support
		*
		* Copyright IBM, Corp. 2008
		*
		* Authors:
		* Anthony Liguori <aliguori@us.ibm.com>
		*
		* This work is licensed under the terms of the GNU GPL, version 2 or later.
		* See the COPYING file in the top-level directory.
		*
		*/

		#include <sys/types.h>
		#include <sys/ioctl.h>
		#include <sys/mman.h>

		#include <linux/kvm.h>

		#include "qemu-common.h"
		#include "sysemu.h"
		#include "kvm.h"

		//#define DEBUG_KVM

		#ifdef DEBUG_KVM
		#define dprintf(fmt, ...) \
		do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
		#else
		#define dprintf(fmt, ...) \
		do { } while (0)
		#endif

		typedef struct kvm_userspace_memory_region KVMSlot;

		int kvm_allowed = 0;

		struct KVMState
		{
		KVMSlot slots[32];
		int fd;
		int vmfd;
		};

		static KVMState *kvm_state;

		static KVMSlot kvm_alloc_slot(KVMState s)
		{
		int i;

		for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
		if (s->slots[i].memory_size == 0)
		return &s->slots[i];
		}

		return NULL;
		}

		static KVMSlot kvm_lookup_slot(KVMState s, target_phys_addr_t start_addr)
		{
		int i;

		for (i = 0; i < ARRAY_SIZE(s->slots); i++) {
		KVMSlot *mem = &s->slots[i];

		if (start_addr >= mem->guest_phys_addr &&
		start_addr < (mem->guest_phys_addr + mem->memory_size))
		return mem;
		}

		return NULL;
		}

		int kvm_init_vcpu(CPUState *env)
		{
		KVMState *s = kvm_state;
		long mmap_size;
		int ret;

		dprintf("kvm_init_vcpu\n");

		ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU,
		(void *)(unsigned long)env->cpu_index);
		if (ret < 0) {
		dprintf("kvm_create_vcpu failed\n");
		goto err;
		}

		env->kvm_fd = ret;
		env->kvm_state = s;

		mmap_size = kvm_ioctl(s, KVM_GET_VCPU_MMAP_SIZE, 0);
		if (mmap_size < 0) {
		dprintf("KVM_GET_VCPU_MMAP_SIZE failed\n");
		goto err;
		}

		env->kvm_run = mmap(NULL, mmap_size, PROT_READ \| PROT_WRITE, MAP_SHARED,
		env->kvm_fd, 0);
		if (env->kvm_run == MAP_FAILED) {
		ret = -errno;
		dprintf("mmap'ing vcpu state failed\n");
		goto err;
		}

		ret = kvm_arch_init_vcpu(env);

		err:
		return ret;
		}

		int kvm_init(int smp_cpus)
		{
		KVMState *s;
		int ret;
		int i;

		if (smp_cpus > 1)
		return -EINVAL;

		s = qemu_mallocz(sizeof(KVMState));
		if (s == NULL)
		return -ENOMEM;

		for (i = 0; i < ARRAY_SIZE(s->slots); i++)
		s->slots[i].slot = i;

		s->vmfd = -1;
		s->fd = open("/dev/kvm", O_RDWR);
		if (s->fd == -1) {
		fprintf(stderr, "Could not access KVM kernel module: %m\n");
		ret = -errno;
		goto err;
		}

		ret = kvm_ioctl(s, KVM_GET_API_VERSION, 0);
		if (ret < KVM_API_VERSION) {
		if (ret > 0)
		ret = -EINVAL;
		fprintf(stderr, "kvm version too old\n");
		goto err;
		}

		if (ret > KVM_API_VERSION) {
		ret = -EINVAL;
		fprintf(stderr, "kvm version not supported\n");
		goto err;
		}

		s->vmfd = kvm_ioctl(s, KVM_CREATE_VM, 0);
		if (s->vmfd < 0)
		goto err;

		/* initially, KVM allocated its own memory and we had to jump through
		* hooks to make phys_ram_base point to this. Modern versions of KVM
		* just use a user allocated buffer so we can use phys_ram_base
		* unmodified. Make sure we have a sufficiently modern version of KVM.
		*/
		ret = kvm_ioctl(s, KVM_CHECK_EXTENSION, (void *)KVM_CAP_USER_MEMORY);
		if (ret <= 0) {
		if (ret == 0)
		ret = -EINVAL;
		fprintf(stderr, "kvm does not support KVM_CAP_USER_MEMORY\n");
		goto err;
		}

		ret = kvm_arch_init(s, smp_cpus);
		if (ret < 0)
		goto err;

		kvm_state = s;

		return 0;

		err:
		if (s) {
		if (s->vmfd != -1)
		close(s->vmfd);
		if (s->fd != -1)
		close(s->fd);
		}
		qemu_free(s);

		return ret;
		}

		static int kvm_handle_io(CPUState env, uint16_t port, void data,
		int direction, int size, uint32_t count)
		{
		int i;
		uint8_t *ptr = data;

		for (i = 0; i < count; i++) {
		if (direction == KVM_EXIT_IO_IN) {
		switch (size) {
		case 1:
		stb_p(ptr, cpu_inb(env, port));
		break;
		case 2:
		stw_p(ptr, cpu_inw(env, port));
		break;
		case 4:
		stl_p(ptr, cpu_inl(env, port));
		break;
		}
		} else {
		switch (size) {
		case 1:
		cpu_outb(env, port, ldub_p(ptr));
		break;
		case 2:
		cpu_outw(env, port, lduw_p(ptr));
		break;
		case 4:
		cpu_outl(env, port, ldl_p(ptr));
		break;
		}
		}

		ptr += size;
		}

		return 1;
		}

		int kvm_cpu_exec(CPUState *env)
		{
		struct kvm_run *run = env->kvm_run;
		int ret;

		dprintf("kvm_cpu_exec()\n");

		do {
		kvm_arch_pre_run(env, run);

		if ((env->interrupt_request & CPU_INTERRUPT_EXIT)) {
		dprintf("interrupt exit requested\n");
		ret = 0;
		break;
		}

		ret = kvm_vcpu_ioctl(env, KVM_RUN, 0);
		kvm_arch_post_run(env, run);

		if (ret == -EINTR \|\| ret == -EAGAIN) {
		dprintf("io window exit\n");
		ret = 0;
		break;
		}

		if (ret < 0) {
		dprintf("kvm run failed %s\n", strerror(-ret));
		abort();
		}

		ret = 0; /* exit loop */
		switch (run->exit_reason) {
		case KVM_EXIT_IO:
		dprintf("handle_io\n");
		ret = kvm_handle_io(env, run->io.port,
		(uint8_t *)run + run->io.data_offset,
		run->io.direction,
		run->io.size,
		run->io.count);
		break;
		case KVM_EXIT_MMIO:
		dprintf("handle_mmio\n");
		cpu_physical_memory_rw(run->mmio.phys_addr,
		run->mmio.data,
		run->mmio.len,
		run->mmio.is_write);
		ret = 1;
		break;
		case KVM_EXIT_IRQ_WINDOW_OPEN:
		dprintf("irq_window_open\n");
		break;
		case KVM_EXIT_SHUTDOWN:
		dprintf("shutdown\n");
		qemu_system_reset_request();
		ret = 1;
		break;
		case KVM_EXIT_UNKNOWN:
		dprintf("kvm_exit_unknown\n");
		break;
		case KVM_EXIT_FAIL_ENTRY:
		dprintf("kvm_exit_fail_entry\n");
		break;
		case KVM_EXIT_EXCEPTION:
		dprintf("kvm_exit_exception\n");
		break;
		case KVM_EXIT_DEBUG:
		dprintf("kvm_exit_debug\n");
		break;
		default:
		dprintf("kvm_arch_handle_exit\n");
		ret = kvm_arch_handle_exit(env, run);
		break;
		}
		} while (ret > 0);

		return ret;
		}

		void kvm_set_phys_mem(target_phys_addr_t start_addr,
		ram_addr_t size,
		ram_addr_t phys_offset)
		{
		KVMState *s = kvm_state;
		ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
		KVMSlot *mem;

		/* KVM does not support read-only slots */
		phys_offset &= ~IO_MEM_ROM;

		mem = kvm_lookup_slot(s, start_addr);
		if (mem) {
		if (flags == IO_MEM_UNASSIGNED) {
		mem->memory_size = 0;
		mem->guest_phys_addr = start_addr;
		mem->userspace_addr = 0;
		mem->flags = 0;

		kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, mem);
		} else if (start_addr >= mem->guest_phys_addr &&
		(start_addr + size) <= (mem->guest_phys_addr + mem->memory_size))
		return;
		}

		/* KVM does not need to know about this memory */
		if (flags >= IO_MEM_UNASSIGNED)
		return;

		mem = kvm_alloc_slot(s);
		mem->memory_size = size;
		mem->guest_phys_addr = start_addr;
		mem->userspace_addr = (unsigned long)(phys_ram_base + phys_offset);
		mem->flags = 0;

		kvm_vm_ioctl(s, KVM_SET_USER_MEMORY_REGION, mem);
		/* FIXME deal with errors */
		}

		int kvm_ioctl(KVMState s, int type, void data)
		{
		int ret;

		ret = ioctl(s->fd, type, data);
		if (ret == -1)
		ret = -errno;

		return ret;
		}

		int kvm_vm_ioctl(KVMState s, int type, void data)
		{
		int ret;

		ret = ioctl(s->vmfd, type, data);
		if (ret == -1)
		ret = -errno;

		return ret;
		}

		int kvm_vcpu_ioctl(CPUState env, int type, void data)
		{
		int ret;

		ret = ioctl(env->kvm_fd, type, data);
		if (ret == -1)
		ret = -errno;

		return ret;
		}

kvm.h

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		/*
		* QEMU KVM support
		*
		* Copyright IBM, Corp. 2008
		*
		* Authors:
		* Anthony Liguori <aliguori@us.ibm.com>
		*
		* This work is licensed under the terms of the GNU GPL, version 2 or later.
		* See the COPYING file in the top-level directory.
		*
		*/

		#ifndef QEMU_KVM_H
		#define QEMU_KVM_H

		#include "config.h"

		#ifdef CONFIG_KVM
		extern int kvm_allowed;

		#define kvm_enabled() (kvm_allowed)
		#else
		#define kvm_enabled() (0)
		#endif

		struct kvm_run;

		/* external API */

		int kvm_init(int smp_cpus);

		int kvm_init_vcpu(CPUState *env);

		int kvm_cpu_exec(CPUState *env);

		void kvm_set_phys_mem(target_phys_addr_t start_addr,
		ram_addr_t size,
		ram_addr_t phys_offset);

		/* internal API */

		struct KVMState;
		typedef struct KVMState KVMState;

		int kvm_ioctl(KVMState s, int type, void data);

		int kvm_vm_ioctl(KVMState s, int type, void data);

		int kvm_vcpu_ioctl(CPUState env, int type, void data);

		/* Arch specific hooks */

		int kvm_arch_post_run(CPUState env, struct kvm_run run);

		int kvm_arch_handle_exit(CPUState env, struct kvm_run run);

		int kvm_arch_pre_run(CPUState env, struct kvm_run run);

		int kvm_arch_get_registers(CPUState *env);

		int kvm_arch_put_registers(CPUState *env);

		int kvm_arch_init(KVMState *s, int smp_cpus);

		int kvm_arch_init_vcpu(CPUState *env);

		#endif

target-i386/kvm.c

0 → 100644

+638 −0

File added.

Preview size limit exceeded, changes collapsed.