xref: /kvmtool/include/kvm/kvm.h (revision 96f0c86ce221e4a7b3a350068ea93b478493ee8c)

#ifndef KVM__KVM_H
#define KVM__KVM_H

#include "kvm/mutex.h"
#include "kvm/kvm-arch.h"
#include "kvm/kvm-config.h"
#include "kvm/util-init.h"
#include "kvm/kvm.h"

#include <stdbool.h>
#include <linux/types.h>
#include <linux/compiler.h>
#include <time.h>
#include <signal.h>
#include <sys/prctl.h>
#include <limits.h>

#define SIGKVMEXIT		(SIGRTMIN + 0)
#define SIGKVMPAUSE		(SIGRTMIN + 1)
#define SIGKVMTASK		(SIGRTMIN + 2)

#define KVM_PID_FILE_PATH	"/.lkvm/"
#define HOME_DIR		getenv("HOME")
#define KVM_BINARY_NAME		"lkvm"

#ifndef PAGE_SIZE
#define PAGE_SIZE (sysconf(_SC_PAGE_SIZE))
#endif

/*
 * We are reusing the existing DEVICE_BUS_MMIO and DEVICE_BUS_IOPORT constants
 * from kvm/devices.h to differentiate between registering an I/O port and an
 * MMIO region.
 * To avoid collisions with future additions of more bus types, we reserve
 * a generous 4 bits for the bus mask here.
 */
#define IOTRAP_BUS_MASK		0xf
#define IOTRAP_COALESCE		(1U << 4)

#define DEFINE_KVM_EXT(ext)		\
	.name = #ext,			\
	.code = ext

struct kvm_cpu;
typedef void (*mmio_handler_fn)(struct kvm_cpu *vcpu, u64 addr, u8 *data,
				u32 len, u8 is_write, void *ptr);
typedef void (*fdt_irq_fn)(void *fdt, u8 irq, enum irq_type irq_type);

enum {
	KVM_VMSTATE_RUNNING,
	KVM_VMSTATE_PAUSED,
};

enum kvm_mem_type {
	KVM_MEM_TYPE_RAM	= 1 << 0,
	KVM_MEM_TYPE_DEVICE	= 1 << 1,
	KVM_MEM_TYPE_RESERVED	= 1 << 2,
	KVM_MEM_TYPE_READONLY	= 1 << 3,

	KVM_MEM_TYPE_ALL	= KVM_MEM_TYPE_RAM
				| KVM_MEM_TYPE_DEVICE
				| KVM_MEM_TYPE_RESERVED
				| KVM_MEM_TYPE_READONLY
};

struct kvm_ext {
	const char *name;
	int code;
};

struct kvm_mem_bank {
	struct list_head	list;
	u64			guest_phys_addr;
	void			*host_addr;
	u64			size;
	enum kvm_mem_type	type;
	u32			slot;
};

struct kvm {
	struct kvm_arch		arch;
	struct kvm_config	cfg;
	int			sys_fd;		/* For system ioctls(), i.e. /dev/kvm */
	int			vm_fd;		/* For VM ioctls() */
	timer_t			timerid;	/* Posix timer for interrupts */

	int			nrcpus;		/* Number of cpus to run */
	struct kvm_cpu		**cpus;

	u32			mem_slots;	/* for KVM_SET_USER_MEMORY_REGION */
	u64			ram_size;
	void			*ram_start;
	u64			ram_pagesize;
	struct mutex		mem_banks_lock;
	struct list_head	mem_banks;

	bool			nmi_disabled;
	bool			msix_needs_devid;

	const char		*vmlinux;
	struct disk_image       **disks;
	int                     nr_disks;

	int			vm_state;

#ifdef KVM_BRLOCK_DEBUG
	pthread_rwlock_t	brlock_sem;
#endif
};

void kvm__set_dir(const char *fmt, ...);
const char *kvm__get_dir(void);

int kvm__init(struct kvm *kvm);
struct kvm *kvm__new(void);
int kvm__recommended_cpus(struct kvm *kvm);
int kvm__max_cpus(struct kvm *kvm);
void kvm__init_ram(struct kvm *kvm);
int kvm__exit(struct kvm *kvm);
bool kvm__load_firmware(struct kvm *kvm, const char *firmware_filename);
bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename,
			const char *initrd_filename, const char *kernel_cmdline);
int kvm_timer__init(struct kvm *kvm);
int kvm_timer__exit(struct kvm *kvm);
void kvm__irq_line(struct kvm *kvm, int irq, int level);
void kvm__irq_trigger(struct kvm *kvm, int irq);
bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction, int size, u32 count);
bool kvm__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write);
bool kvm__emulate_pio(struct kvm_cpu *vcpu, u16 port, void *data,
		      int direction, int size, u32 count);
int kvm__destroy_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr);
int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr,
		      enum kvm_mem_type type);
static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
				    void *userspace_addr)
{
	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
				 KVM_MEM_TYPE_RAM);
}

static inline int kvm__register_dev_mem(struct kvm *kvm, u64 guest_phys,
					u64 size, void *userspace_addr)
{
	return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
				 KVM_MEM_TYPE_DEVICE);
}

static inline int kvm__reserve_mem(struct kvm *kvm, u64 guest_phys, u64 size)
{
	return kvm__register_mem(kvm, guest_phys, size, NULL,
				 KVM_MEM_TYPE_RESERVED);
}

int __must_check kvm__register_iotrap(struct kvm *kvm, u64 phys_addr, u64 len,
				      mmio_handler_fn mmio_fn, void *ptr,
				      unsigned int flags);

static inline
int __must_check kvm__register_mmio(struct kvm *kvm, u64 phys_addr,
				    u64 phys_addr_len, bool coalesce,
				    mmio_handler_fn mmio_fn, void *ptr)
{
	return kvm__register_iotrap(kvm, phys_addr, phys_addr_len, mmio_fn, ptr,
			DEVICE_BUS_MMIO | (coalesce ? IOTRAP_COALESCE : 0));
}
static inline
int __must_check kvm__register_pio(struct kvm *kvm, u16 port, u16 len,
				   mmio_handler_fn mmio_fn, void *ptr)
{
	return kvm__register_iotrap(kvm, port, len, mmio_fn, ptr,
				    DEVICE_BUS_IOPORT);
}

bool kvm__deregister_iotrap(struct kvm *kvm, u64 phys_addr, unsigned int flags);
static inline bool kvm__deregister_mmio(struct kvm *kvm, u64 phys_addr)
{
	return kvm__deregister_iotrap(kvm, phys_addr, DEVICE_BUS_MMIO);
}
static inline bool kvm__deregister_pio(struct kvm *kvm, u16 port)
{
	return kvm__deregister_iotrap(kvm, port, DEVICE_BUS_IOPORT);
}

void kvm__reboot(struct kvm *kvm);
void kvm__pause(struct kvm *kvm);
void kvm__continue(struct kvm *kvm);
void kvm__notify_paused(void);
int kvm__get_sock_by_instance(const char *name);
int kvm__enumerate_instances(int (*callback)(const char *name, int pid));
void kvm__remove_socket(const char *name);

void kvm__arch_set_cmdline(char *cmdline, bool video);
void kvm__arch_init(struct kvm *kvm, const char *hugetlbfs_path, u64 ram_size);
void kvm__arch_delete_ram(struct kvm *kvm);
int kvm__arch_setup_firmware(struct kvm *kvm);
int kvm__arch_free_firmware(struct kvm *kvm);
bool kvm__arch_cpu_supports_vm(void);
void kvm__arch_read_term(struct kvm *kvm);

void *guest_flat_to_host(struct kvm *kvm, u64 offset);
u64 host_to_guest_flat(struct kvm *kvm, void *ptr);

bool kvm__arch_load_kernel_image(struct kvm *kvm, int fd_kernel, int fd_initrd,
				 const char *kernel_cmdline);

#define add_read_only(type, str)					\
	(((type) & KVM_MEM_TYPE_READONLY) ? str " (read-only)" : str)
static inline const char *kvm_mem_type_to_string(enum kvm_mem_type type)
{
	switch (type & ~KVM_MEM_TYPE_READONLY) {
	case KVM_MEM_TYPE_ALL:
		return "(all)";
	case KVM_MEM_TYPE_RAM:
		return add_read_only(type, "RAM");
	case KVM_MEM_TYPE_DEVICE:
		return add_read_only(type, "device");
	case KVM_MEM_TYPE_RESERVED:
		return add_read_only(type, "reserved");
	}

	return "???";
}

int kvm__for_each_mem_bank(struct kvm *kvm, enum kvm_mem_type type,
			   int (*fun)(struct kvm *kvm, struct kvm_mem_bank *bank, void *data),
			   void *data);

/*
 * Debugging
 */
void kvm__dump_mem(struct kvm *kvm, unsigned long addr, unsigned long size, int debug_fd);

extern const char *kvm_exit_reasons[];

static inline bool host_ptr_in_ram(struct kvm *kvm, void *p)
{
	return kvm->ram_start <= p && p < (kvm->ram_start + kvm->ram_size);
}

bool kvm__supports_extension(struct kvm *kvm, unsigned int extension);
bool kvm__supports_vm_extension(struct kvm *kvm, unsigned int extension);

static inline void kvm__set_thread_name(const char *name)
{
	prctl(PR_SET_NAME, name);
}

#endif /* KVM__KVM_H */