1 #ifndef KVM__KVM_H
2 #define KVM__KVM_H
3
4 #include "kvm/mutex.h"
5 #include "kvm/kvm-arch.h"
6 #include "kvm/kvm-config.h"
7 #include "kvm/util-init.h"
8 #include "kvm/kvm.h"
9
10 #include <stdbool.h>
11 #include <linux/types.h>
12 #include <linux/compiler.h>
13 #include <time.h>
14 #include <signal.h>
15 #include <sys/prctl.h>
16 #include <limits.h>
17
18 #define SIGKVMEXIT (SIGRTMIN + 0)
19 #define SIGKVMPAUSE (SIGRTMIN + 1)
20 #define SIGKVMTASK (SIGRTMIN + 2)
21
22 #define KVM_PID_FILE_PATH "/.lkvm/"
23 #define HOME_DIR getenv("HOME")
24 #define KVM_BINARY_NAME "lkvm"
25
26 #ifndef PAGE_SIZE
27 #define PAGE_SIZE (sysconf(_SC_PAGE_SIZE))
28 #endif
29
30 /*
31 * We are reusing the existing DEVICE_BUS_MMIO and DEVICE_BUS_IOPORT constants
32 * from kvm/devices.h to differentiate between registering an I/O port and an
33 * MMIO region.
34 * To avoid collisions with future additions of more bus types, we reserve
35 * a generous 4 bits for the bus mask here.
36 */
37 #define IOTRAP_BUS_MASK 0xf
38 #define IOTRAP_COALESCE (1U << 4)
39
40 #define DEFINE_KVM_EXT(ext) \
41 .name = #ext, \
42 .code = ext
43
44 struct kvm_cpu;
45 typedef void (*mmio_handler_fn)(struct kvm_cpu *vcpu, u64 addr, u8 *data,
46 u32 len, u8 is_write, void *ptr);
47
48 enum {
49 KVM_VMSTATE_RUNNING,
50 KVM_VMSTATE_PAUSED,
51 };
52
53 enum kvm_mem_type {
54 KVM_MEM_TYPE_RAM = 1 << 0,
55 KVM_MEM_TYPE_DEVICE = 1 << 1,
56 KVM_MEM_TYPE_RESERVED = 1 << 2,
57 KVM_MEM_TYPE_READONLY = 1 << 3,
58
59 KVM_MEM_TYPE_ALL = KVM_MEM_TYPE_RAM
60 | KVM_MEM_TYPE_DEVICE
61 | KVM_MEM_TYPE_RESERVED
62 | KVM_MEM_TYPE_READONLY
63 };
64
65 struct kvm_ext {
66 const char *name;
67 int code;
68 };
69
70 struct kvm_mem_bank {
71 struct list_head list;
72 u64 guest_phys_addr;
73 void *host_addr;
74 u64 size;
75 enum kvm_mem_type type;
76 u32 slot;
77 };
78
79 struct kvm {
80 struct kvm_arch arch;
81 struct kvm_config cfg;
82 int sys_fd; /* For system ioctls(), i.e. /dev/kvm */
83 int vm_fd; /* For VM ioctls() */
84 timer_t timerid; /* Posix timer for interrupts */
85
86 int nrcpus; /* Number of cpus to run */
87 struct kvm_cpu **cpus;
88
89 u32 mem_slots; /* for KVM_SET_USER_MEMORY_REGION */
90 u64 ram_size; /* Guest memory size, in bytes */
91 void *ram_start;
92 u64 ram_pagesize;
93 struct mutex mem_banks_lock;
94 struct list_head mem_banks;
95
96 bool nmi_disabled;
97 bool msix_needs_devid;
98
99 const char *vmlinux;
100 struct disk_image **disks;
101 int nr_disks;
102
103 int vm_state;
104
105 #ifdef KVM_BRLOCK_DEBUG
106 pthread_rwlock_t brlock_sem;
107 #endif
108 };
109
110 void kvm__set_dir(const char *fmt, ...);
111 const char *kvm__get_dir(void);
112
113 int kvm__init(struct kvm *kvm);
114 struct kvm *kvm__new(void);
115 int kvm__recommended_cpus(struct kvm *kvm);
116 int kvm__max_cpus(struct kvm *kvm);
117 int kvm__get_vm_type(struct kvm *kvm);
118 void kvm__init_ram(struct kvm *kvm);
119 int kvm__exit(struct kvm *kvm);
120 bool kvm__load_firmware(struct kvm *kvm, const char *firmware_filename);
121 bool kvm__load_kernel(struct kvm *kvm, const char *kernel_filename,
122 const char *initrd_filename, const char *kernel_cmdline);
123 int kvm_timer__init(struct kvm *kvm);
124 int kvm_timer__exit(struct kvm *kvm);
125 void kvm__irq_line(struct kvm *kvm, int irq, int level);
126 void kvm__irq_trigger(struct kvm *kvm, int irq);
127 bool kvm__emulate_io(struct kvm_cpu *vcpu, u16 port, void *data, int direction, int size, u32 count);
128 bool kvm__emulate_mmio(struct kvm_cpu *vcpu, u64 phys_addr, u8 *data, u32 len, u8 is_write);
129 int kvm__destroy_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr);
130 int kvm__register_mem(struct kvm *kvm, u64 guest_phys, u64 size, void *userspace_addr,
131 enum kvm_mem_type type);
kvm__register_ram(struct kvm * kvm,u64 guest_phys,u64 size,void * userspace_addr)132 static inline int kvm__register_ram(struct kvm *kvm, u64 guest_phys, u64 size,
133 void *userspace_addr)
134 {
135 return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
136 KVM_MEM_TYPE_RAM);
137 }
138
kvm__register_dev_mem(struct kvm * kvm,u64 guest_phys,u64 size,void * userspace_addr)139 static inline int kvm__register_dev_mem(struct kvm *kvm, u64 guest_phys,
140 u64 size, void *userspace_addr)
141 {
142 return kvm__register_mem(kvm, guest_phys, size, userspace_addr,
143 KVM_MEM_TYPE_DEVICE);
144 }
145
kvm__reserve_mem(struct kvm * kvm,u64 guest_phys,u64 size)146 static inline int kvm__reserve_mem(struct kvm *kvm, u64 guest_phys, u64 size)
147 {
148 return kvm__register_mem(kvm, guest_phys, size, NULL,
149 KVM_MEM_TYPE_RESERVED);
150 }
151
152 int __must_check kvm__register_iotrap(struct kvm *kvm, u64 phys_addr, u64 len,
153 mmio_handler_fn mmio_fn, void *ptr,
154 unsigned int flags);
155
156 static inline
kvm__register_mmio(struct kvm * kvm,u64 phys_addr,u64 phys_addr_len,bool coalesce,mmio_handler_fn mmio_fn,void * ptr)157 int __must_check kvm__register_mmio(struct kvm *kvm, u64 phys_addr,
158 u64 phys_addr_len, bool coalesce,
159 mmio_handler_fn mmio_fn, void *ptr)
160 {
161 return kvm__register_iotrap(kvm, phys_addr, phys_addr_len, mmio_fn, ptr,
162 DEVICE_BUS_MMIO | (coalesce ? IOTRAP_COALESCE : 0));
163 }
164 static inline
kvm__register_pio(struct kvm * kvm,u16 port,u16 len,mmio_handler_fn mmio_fn,void * ptr)165 int __must_check kvm__register_pio(struct kvm *kvm, u16 port, u16 len,
166 mmio_handler_fn mmio_fn, void *ptr)
167 {
168 return kvm__register_iotrap(kvm, port, len, mmio_fn, ptr,
169 DEVICE_BUS_IOPORT);
170 }
171
172 bool kvm__deregister_iotrap(struct kvm *kvm, u64 phys_addr, unsigned int flags);
kvm__deregister_mmio(struct kvm * kvm,u64 phys_addr)173 static inline bool kvm__deregister_mmio(struct kvm *kvm, u64 phys_addr)
174 {
175 return kvm__deregister_iotrap(kvm, phys_addr, DEVICE_BUS_MMIO);
176 }
kvm__deregister_pio(struct kvm * kvm,u16 port)177 static inline bool kvm__deregister_pio(struct kvm *kvm, u16 port)
178 {
179 return kvm__deregister_iotrap(kvm, port, DEVICE_BUS_IOPORT);
180 }
181
182 void kvm__reboot(struct kvm *kvm);
183 void kvm__pause(struct kvm *kvm);
184 void kvm__continue(struct kvm *kvm);
185 void kvm__notify_paused(void);
186 int kvm__get_sock_by_instance(const char *name);
187 int kvm__enumerate_instances(int (*callback)(const char *name, int pid));
188 void kvm__remove_socket(const char *name);
189
190 void kvm__arch_validate_cfg(struct kvm *kvm);
191 void kvm__arch_set_cmdline(char *cmdline, bool video);
192 void kvm__arch_init(struct kvm *kvm);
193 u64 kvm__arch_default_ram_address(void);
194 void kvm__arch_delete_ram(struct kvm *kvm);
195 int kvm__arch_setup_firmware(struct kvm *kvm);
196 int kvm__arch_free_firmware(struct kvm *kvm);
197 bool kvm__arch_cpu_supports_vm(void);
198 void kvm__arch_read_term(struct kvm *kvm);
199
200 #ifdef ARCH_HAS_CFG_RAM_ADDRESS
kvm__arch_has_cfg_ram_address(void)201 static inline bool kvm__arch_has_cfg_ram_address(void)
202 {
203 return true;
204 }
205 #else
kvm__arch_has_cfg_ram_address(void)206 static inline bool kvm__arch_has_cfg_ram_address(void)
207 {
208 return false;
209 }
210 #endif
211
212 void *guest_flat_to_host(struct kvm *kvm, u64 offset);
213 u64 host_to_guest_flat(struct kvm *kvm, void *ptr);
214
215 bool kvm__arch_load_kernel_image(struct kvm *kvm, int fd_kernel, int fd_initrd,
216 const char *kernel_cmdline);
217
218 #define add_read_only(type, str) \
219 (((type) & KVM_MEM_TYPE_READONLY) ? str " (read-only)" : str)
kvm_mem_type_to_string(enum kvm_mem_type type)220 static inline const char *kvm_mem_type_to_string(enum kvm_mem_type type)
221 {
222 switch (type & ~KVM_MEM_TYPE_READONLY) {
223 case KVM_MEM_TYPE_ALL:
224 return "(all)";
225 case KVM_MEM_TYPE_RAM:
226 return add_read_only(type, "RAM");
227 case KVM_MEM_TYPE_DEVICE:
228 return add_read_only(type, "device");
229 case KVM_MEM_TYPE_RESERVED:
230 return add_read_only(type, "reserved");
231 }
232
233 return "???";
234 }
235
236 int kvm__for_each_mem_bank(struct kvm *kvm, enum kvm_mem_type type,
237 int (*fun)(struct kvm *kvm, struct kvm_mem_bank *bank, void *data),
238 void *data);
239
240 /*
241 * Debugging
242 */
243 void kvm__dump_mem(struct kvm *kvm, unsigned long addr, unsigned long size, int debug_fd);
244
245 extern const char *kvm_exit_reasons[];
246
host_ptr_in_ram(struct kvm * kvm,void * p)247 static inline bool host_ptr_in_ram(struct kvm *kvm, void *p)
248 {
249 return kvm->ram_start <= p && p < (kvm->ram_start + kvm->ram_size);
250 }
251
252 bool kvm__supports_extension(struct kvm *kvm, unsigned int extension);
253 bool kvm__supports_vm_extension(struct kvm *kvm, unsigned int extension);
254
kvm__set_thread_name(const char * name)255 static inline void kvm__set_thread_name(const char *name)
256 {
257 prctl(PR_SET_NAME, name);
258 }
259
260 #endif /* KVM__KVM_H */
261