1/*
2 * QEMU KVM support
3 *
4 * Copyright IBM, Corp. 2008
5 *
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 *
12 */
13
14#ifndef QEMU_KVM_H
15#define QEMU_KVM_H
16
17#include "qemu/queue.h"
18#include "hw/core/cpu.h"
19#include "exec/memattrs.h"
20
21#ifdef NEED_CPU_H
22# ifdef CONFIG_KVM
23# include <linux/kvm.h>
24# define CONFIG_KVM_IS_POSSIBLE
25# endif
26#else
27# define CONFIG_KVM_IS_POSSIBLE
28#endif
29
30#ifdef CONFIG_KVM_IS_POSSIBLE
31
32extern bool kvm_allowed;
33extern bool kvm_kernel_irqchip;
34extern bool kvm_split_irqchip;
35extern bool kvm_async_interrupts_allowed;
36extern bool kvm_halt_in_kernel_allowed;
37extern bool kvm_eventfds_allowed;
38extern bool kvm_irqfds_allowed;
39extern bool kvm_resamplefds_allowed;
40extern bool kvm_msi_via_irqfd_allowed;
41extern bool kvm_gsi_routing_allowed;
42extern bool kvm_gsi_direct_mapping;
43extern bool kvm_readonly_mem_allowed;
44extern bool kvm_direct_msi_allowed;
45extern bool kvm_ioeventfd_any_length_allowed;
46extern bool kvm_msi_use_devid;
47
48#define kvm_enabled() (kvm_allowed)
49/**
50 * kvm_irqchip_in_kernel:
51 *
52 * Returns: true if the user asked us to create an in-kernel
53 * irqchip via the "kernel_irqchip=on" machine option.
54 * What this actually means is architecture and machine model
55 * specific: on PC, for instance, it means that the LAPIC,
56 * IOAPIC and PIT are all in kernel. This function should never
57 * be used from generic target-independent code: use one of the
58 * following functions or some other specific check instead.
59 */
60#define kvm_irqchip_in_kernel() (kvm_kernel_irqchip)
61
62/**
63 * kvm_irqchip_is_split:
64 *
65 * Returns: true if the user asked us to split the irqchip
66 * implementation between user and kernel space. The details are
67 * architecture and machine specific. On PC, it means that the PIC,
68 * IOAPIC, and PIT are in user space while the LAPIC is in the kernel.
69 */
70#define kvm_irqchip_is_split() (kvm_split_irqchip)
71
72/**
73 * kvm_async_interrupts_enabled:
74 *
75 * Returns: true if we can deliver interrupts to KVM
76 * asynchronously (ie by ioctl from any thread at any time)
77 * rather than having to do interrupt delivery synchronously
78 * (where the vcpu must be stopped at a suitable point first).
79 */
80#define kvm_async_interrupts_enabled() (kvm_async_interrupts_allowed)
81
82/**
83 * kvm_halt_in_kernel
84 *
85 * Returns: true if halted cpus should still get a KVM_RUN ioctl to run
86 * inside of kernel space. This only works if MP state is implemented.
87 */
88#define kvm_halt_in_kernel() (kvm_halt_in_kernel_allowed)
89
90/**
91 * kvm_eventfds_enabled:
92 *
93 * Returns: true if we can use eventfds to receive notifications
94 * from a KVM CPU (ie the kernel supports eventds and we are running
95 * with a configuration where it is meaningful to use them).
96 */
97#define kvm_eventfds_enabled() (kvm_eventfds_allowed)
98
99/**
100 * kvm_irqfds_enabled:
101 *
102 * Returns: true if we can use irqfds to inject interrupts into
103 * a KVM CPU (ie the kernel supports irqfds and we are running
104 * with a configuration where it is meaningful to use them).
105 */
106#define kvm_irqfds_enabled() (kvm_irqfds_allowed)
107
108/**
109 * kvm_resamplefds_enabled:
110 *
111 * Returns: true if we can use resamplefds to inject interrupts into
112 * a KVM CPU (ie the kernel supports resamplefds and we are running
113 * with a configuration where it is meaningful to use them).
114 */
115#define kvm_resamplefds_enabled() (kvm_resamplefds_allowed)
116
117/**
118 * kvm_msi_via_irqfd_enabled:
119 *
120 * Returns: true if we can route a PCI MSI (Message Signaled Interrupt)
121 * to a KVM CPU via an irqfd. This requires that the kernel supports
122 * this and that we're running in a configuration that permits it.
123 */
124#define kvm_msi_via_irqfd_enabled() (kvm_msi_via_irqfd_allowed)
125
126/**
127 * kvm_gsi_routing_enabled:
128 *
129 * Returns: true if GSI routing is enabled (ie the kernel supports
130 * it and we're running in a configuration that permits it).
131 */
132#define kvm_gsi_routing_enabled() (kvm_gsi_routing_allowed)
133
134/**
135 * kvm_gsi_direct_mapping:
136 *
137 * Returns: true if GSI direct mapping is enabled.
138 */
139#define kvm_gsi_direct_mapping() (kvm_gsi_direct_mapping)
140
141/**
142 * kvm_readonly_mem_enabled:
143 *
144 * Returns: true if KVM readonly memory is enabled (ie the kernel
145 * supports it and we're running in a configuration that permits it).
146 */
147#define kvm_readonly_mem_enabled() (kvm_readonly_mem_allowed)
148
149/**
150 * kvm_direct_msi_enabled:
151 *
152 * Returns: true if KVM allows direct MSI injection.
153 */
154#define kvm_direct_msi_enabled() (kvm_direct_msi_allowed)
155
156/**
157 * kvm_ioeventfd_any_length_enabled:
158 * Returns: true if KVM allows any length io eventfd.
159 */
160#define kvm_ioeventfd_any_length_enabled() (kvm_ioeventfd_any_length_allowed)
161
162/**
163 * kvm_msi_devid_required:
164 * Returns: true if KVM requires a device id to be provided while
165 * defining an MSI routing entry.
166 */
167#define kvm_msi_devid_required() (kvm_msi_use_devid)
168
169#else
170
171#define kvm_enabled() (0)
172#define kvm_irqchip_in_kernel() (false)
173#define kvm_irqchip_is_split() (false)
174#define kvm_async_interrupts_enabled() (false)
175#define kvm_halt_in_kernel() (false)
176#define kvm_eventfds_enabled() (false)
177#define kvm_irqfds_enabled() (false)
178#define kvm_resamplefds_enabled() (false)
179#define kvm_msi_via_irqfd_enabled() (false)
180#define kvm_gsi_routing_allowed() (false)
181#define kvm_gsi_direct_mapping() (false)
182#define kvm_readonly_mem_enabled() (false)
183#define kvm_direct_msi_enabled() (false)
184#define kvm_ioeventfd_any_length_enabled() (false)
185#define kvm_msi_devid_required() (false)
186
187#endif /* CONFIG_KVM_IS_POSSIBLE */
188
189struct kvm_run;
190struct kvm_lapic_state;
191struct kvm_irq_routing_entry;
192
193typedef struct KVMCapabilityInfo {
194 const char *name;
195 int value;
196} KVMCapabilityInfo;
197
198#define KVM_CAP_INFO(CAP) { "KVM_CAP_" stringify(CAP), KVM_CAP_##CAP }
199#define KVM_CAP_LAST_INFO { NULL, 0 }
200
201struct KVMState;
202typedef struct KVMState KVMState;
203extern KVMState *kvm_state;
204
205/* external API */
206
207bool kvm_has_free_slot(MachineState *ms);
208bool kvm_has_sync_mmu(void);
209int kvm_has_vcpu_events(void);
210int kvm_has_robust_singlestep(void);
211int kvm_has_debugregs(void);
212int kvm_max_nested_state_length(void);
213int kvm_has_pit_state2(void);
214int kvm_has_many_ioeventfds(void);
215int kvm_has_gsi_routing(void);
216int kvm_has_intx_set_mask(void);
217
218int kvm_init_vcpu(CPUState *cpu);
219int kvm_cpu_exec(CPUState *cpu);
220int kvm_destroy_vcpu(CPUState *cpu);
221
222/**
223 * kvm_arm_supports_user_irq
224 *
225 * Not all KVM implementations support notifications for kernel generated
226 * interrupt events to user space. This function indicates whether the current
227 * KVM implementation does support them.
228 *
229 * Returns: true if KVM supports using kernel generated IRQs from user space
230 */
231bool kvm_arm_supports_user_irq(void);
232
233/**
234 * kvm_memcrypt_enabled - return boolean indicating whether memory encryption
235 * is enabled
236 * Returns: 1 memory encryption is enabled
237 * 0 memory encryption is disabled
238 */
239bool kvm_memcrypt_enabled(void);
240
241/**
242 * kvm_memcrypt_encrypt_data: encrypt the memory range
243 *
244 * Return: 1 failed to encrypt the range
245 * 0 succesfully encrypted memory region
246 */
247int kvm_memcrypt_encrypt_data(uint8_t *ptr, uint64_t len);
248
249
250#ifdef NEED_CPU_H
251#include "cpu.h"
252
253void kvm_flush_coalesced_mmio_buffer(void);
254
255int kvm_insert_breakpoint(CPUState *cpu, target_ulong addr,
256 target_ulong len, int type);
257int kvm_remove_breakpoint(CPUState *cpu, target_ulong addr,
258 target_ulong len, int type);
259void kvm_remove_all_breakpoints(CPUState *cpu);
260int kvm_update_guest_debug(CPUState *cpu, unsigned long reinject_trap);
261
262int kvm_on_sigbus_vcpu(CPUState *cpu, int code, void *addr);
263int kvm_on_sigbus(int code, void *addr);
264
265/* interface with exec.c */
266
267void phys_mem_set_alloc(void *(*alloc)(size_t, uint64_t *align, bool shared));
268
269/* internal API */
270
271int kvm_ioctl(KVMState *s, int type, ...);
272
273int kvm_vm_ioctl(KVMState *s, int type, ...);
274
275int kvm_vcpu_ioctl(CPUState *cpu, int type, ...);
276
277/**
278 * kvm_device_ioctl - call an ioctl on a kvm device
279 * @fd: The KVM device file descriptor as returned from KVM_CREATE_DEVICE
280 * @type: The device-ctrl ioctl number
281 *
282 * Returns: -errno on error, nonnegative on success
283 */
284int kvm_device_ioctl(int fd, int type, ...);
285
286/**
287 * kvm_vm_check_attr - check for existence of a specific vm attribute
288 * @s: The KVMState pointer
289 * @group: the group
290 * @attr: the attribute of that group to query for
291 *
292 * Returns: 1 if the attribute exists
293 * 0 if the attribute either does not exist or if the vm device
294 * interface is unavailable
295 */
296int kvm_vm_check_attr(KVMState *s, uint32_t group, uint64_t attr);
297
298/**
299 * kvm_device_check_attr - check for existence of a specific device attribute
300 * @fd: The device file descriptor
301 * @group: the group
302 * @attr: the attribute of that group to query for
303 *
304 * Returns: 1 if the attribute exists
305 * 0 if the attribute either does not exist or if the vm device
306 * interface is unavailable
307 */
308int kvm_device_check_attr(int fd, uint32_t group, uint64_t attr);
309
310/**
311 * kvm_device_access - set or get value of a specific vm attribute
312 * @fd: The device file descriptor
313 * @group: the group
314 * @attr: the attribute of that group to set or get
315 * @val: pointer to a storage area for the value
316 * @write: true for set and false for get operation
317 * @errp: error object handle
318 *
319 * Returns: 0 on success
320 * < 0 on error
321 * Use kvm_device_check_attr() in order to check for the availability
322 * of optional attributes.
323 */
324int kvm_device_access(int fd, int group, uint64_t attr,
325 void *val, bool write, Error **errp);
326
327/**
328 * kvm_create_device - create a KVM device for the device control API
329 * @KVMState: The KVMState pointer
330 * @type: The KVM device type (see Documentation/virtual/kvm/devices in the
331 * kernel source)
332 * @test: If true, only test if device can be created, but don't actually
333 * create the device.
334 *
335 * Returns: -errno on error, nonnegative on success: @test ? 0 : device fd;
336 */
337int kvm_create_device(KVMState *s, uint64_t type, bool test);
338
339/**
340 * kvm_device_supported - probe whether KVM supports specific device
341 *
342 * @vmfd: The fd handler for VM
343 * @type: type of device
344 *
345 * @return: true if supported, otherwise false.
346 */
347bool kvm_device_supported(int vmfd, uint64_t type);
348
349/* Arch specific hooks */
350
351extern const KVMCapabilityInfo kvm_arch_required_capabilities[];
352
353void kvm_arch_pre_run(CPUState *cpu, struct kvm_run *run);
354MemTxAttrs kvm_arch_post_run(CPUState *cpu, struct kvm_run *run);
355
356int kvm_arch_handle_exit(CPUState *cpu, struct kvm_run *run);
357
358int kvm_arch_process_async_events(CPUState *cpu);
359
360int kvm_arch_get_registers(CPUState *cpu);
361
362/* state subset only touched by the VCPU itself during runtime */
363#define KVM_PUT_RUNTIME_STATE 1
364/* state subset modified during VCPU reset */
365#define KVM_PUT_RESET_STATE 2
366/* full state set, modified during initialization or on vmload */
367#define KVM_PUT_FULL_STATE 3
368
369int kvm_arch_put_registers(CPUState *cpu, int level);
370
371int kvm_arch_init(MachineState *ms, KVMState *s);
372
373int kvm_arch_init_vcpu(CPUState *cpu);
374int kvm_arch_destroy_vcpu(CPUState *cpu);
375
376bool kvm_vcpu_id_is_valid(int vcpu_id);
377
378/* Returns VCPU ID to be used on KVM_CREATE_VCPU ioctl() */
379unsigned long kvm_arch_vcpu_id(CPUState *cpu);
380
381#ifdef TARGET_I386
382#define KVM_HAVE_MCE_INJECTION 1
383void kvm_arch_on_sigbus_vcpu(CPUState *cpu, int code, void *addr);
384#endif
385
386void kvm_arch_init_irq_routing(KVMState *s);
387
388int kvm_arch_fixup_msi_route(struct kvm_irq_routing_entry *route,
389 uint64_t address, uint32_t data, PCIDevice *dev);
390
391/* Notify arch about newly added MSI routes */
392int kvm_arch_add_msi_route_post(struct kvm_irq_routing_entry *route,
393 int vector, PCIDevice *dev);
394/* Notify arch about released MSI routes */
395int kvm_arch_release_virq_post(int virq);
396
397int kvm_arch_msi_data_to_gsi(uint32_t data);
398
399int kvm_set_irq(KVMState *s, int irq, int level);
400int kvm_irqchip_send_msi(KVMState *s, MSIMessage msg);
401
402void kvm_irqchip_add_irq_route(KVMState *s, int gsi, int irqchip, int pin);
403
404void kvm_get_apic_state(DeviceState *d, struct kvm_lapic_state *kapic);
405
406struct kvm_guest_debug;
407struct kvm_debug_exit_arch;
408
409struct kvm_sw_breakpoint {
410 target_ulong pc;
411 target_ulong saved_insn;
412 int use_count;
413 QTAILQ_ENTRY(kvm_sw_breakpoint) entry;
414};
415
416struct kvm_sw_breakpoint *kvm_find_sw_breakpoint(CPUState *cpu,
417 target_ulong pc);
418
419int kvm_sw_breakpoints_active(CPUState *cpu);
420
421int kvm_arch_insert_sw_breakpoint(CPUState *cpu,
422 struct kvm_sw_breakpoint *bp);
423int kvm_arch_remove_sw_breakpoint(CPUState *cpu,
424 struct kvm_sw_breakpoint *bp);
425int kvm_arch_insert_hw_breakpoint(target_ulong addr,
426 target_ulong len, int type);
427int kvm_arch_remove_hw_breakpoint(target_ulong addr,
428 target_ulong len, int type);
429void kvm_arch_remove_all_hw_breakpoints(void);
430
431void kvm_arch_update_guest_debug(CPUState *cpu, struct kvm_guest_debug *dbg);
432
433bool kvm_arch_stop_on_emulation_error(CPUState *cpu);
434
435int kvm_check_extension(KVMState *s, unsigned int extension);
436
437int kvm_vm_check_extension(KVMState *s, unsigned int extension);
438
439#define kvm_vm_enable_cap(s, capability, cap_flags, ...) \
440 ({ \
441 struct kvm_enable_cap cap = { \
442 .cap = capability, \
443 .flags = cap_flags, \
444 }; \
445 uint64_t args_tmp[] = { __VA_ARGS__ }; \
446 size_t n = MIN(ARRAY_SIZE(args_tmp), ARRAY_SIZE(cap.args)); \
447 memcpy(cap.args, args_tmp, n * sizeof(cap.args[0])); \
448 kvm_vm_ioctl(s, KVM_ENABLE_CAP, &cap); \
449 })
450
451#define kvm_vcpu_enable_cap(cpu, capability, cap_flags, ...) \
452 ({ \
453 struct kvm_enable_cap cap = { \
454 .cap = capability, \
455 .flags = cap_flags, \
456 }; \
457 uint64_t args_tmp[] = { __VA_ARGS__ }; \
458 size_t n = MIN(ARRAY_SIZE(args_tmp), ARRAY_SIZE(cap.args)); \
459 memcpy(cap.args, args_tmp, n * sizeof(cap.args[0])); \
460 kvm_vcpu_ioctl(cpu, KVM_ENABLE_CAP, &cap); \
461 })
462
463uint32_t kvm_arch_get_supported_cpuid(KVMState *env, uint32_t function,
464 uint32_t index, int reg);
465uint32_t kvm_arch_get_supported_msr_feature(KVMState *s, uint32_t index);
466
467
468void kvm_set_sigmask_len(KVMState *s, unsigned int sigmask_len);
469
470#if !defined(CONFIG_USER_ONLY)
471int kvm_physical_memory_addr_from_host(KVMState *s, void *ram_addr,
472 hwaddr *phys_addr);
473#endif
474
475#endif /* NEED_CPU_H */
476
477void kvm_cpu_synchronize_state(CPUState *cpu);
478void kvm_cpu_synchronize_post_reset(CPUState *cpu);
479void kvm_cpu_synchronize_post_init(CPUState *cpu);
480void kvm_cpu_synchronize_pre_loadvm(CPUState *cpu);
481
482void kvm_init_cpu_signals(CPUState *cpu);
483
484/**
485 * kvm_irqchip_add_msi_route - Add MSI route for specific vector
486 * @s: KVM state
487 * @vector: which vector to add. This can be either MSI/MSIX
488 * vector. The function will automatically detect whether
489 * MSI/MSIX is enabled, and fetch corresponding MSI
490 * message.
491 * @dev: Owner PCI device to add the route. If @dev is specified
492 * as @NULL, an empty MSI message will be inited.
493 * @return: virq (>=0) when success, errno (<0) when failed.
494 */
495int kvm_irqchip_add_msi_route(KVMState *s, int vector, PCIDevice *dev);
496int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg,
497 PCIDevice *dev);
498void kvm_irqchip_commit_routes(KVMState *s);
499void kvm_irqchip_release_virq(KVMState *s, int virq);
500
501int kvm_irqchip_add_adapter_route(KVMState *s, AdapterInfo *adapter);
502int kvm_irqchip_add_hv_sint_route(KVMState *s, uint32_t vcpu, uint32_t sint);
503
504int kvm_irqchip_add_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
505 EventNotifier *rn, int virq);
506int kvm_irqchip_remove_irqfd_notifier_gsi(KVMState *s, EventNotifier *n,
507 int virq);
508int kvm_irqchip_add_irqfd_notifier(KVMState *s, EventNotifier *n,
509 EventNotifier *rn, qemu_irq irq);
510int kvm_irqchip_remove_irqfd_notifier(KVMState *s, EventNotifier *n,
511 qemu_irq irq);
512void kvm_irqchip_set_qemuirq_gsi(KVMState *s, qemu_irq irq, int gsi);
513void kvm_pc_gsi_handler(void *opaque, int n, int level);
514void kvm_pc_setup_irq_routing(bool pci_enabled);
515void kvm_init_irq_routing(KVMState *s);
516
517/**
518 * kvm_arch_irqchip_create:
519 * @KVMState: The KVMState pointer
520 * @MachineState: The MachineState pointer
521 *
522 * Allow architectures to create an in-kernel irq chip themselves.
523 *
524 * Returns: < 0: error
525 * 0: irq chip was not created
526 * > 0: irq chip was created
527 */
528int kvm_arch_irqchip_create(MachineState *ms, KVMState *s);
529
530/**
531 * kvm_set_one_reg - set a register value in KVM via KVM_SET_ONE_REG ioctl
532 * @id: The register ID
533 * @source: The pointer to the value to be set. It must point to a variable
534 * of the correct type/size for the register being accessed.
535 *
536 * Returns: 0 on success, or a negative errno on failure.
537 */
538int kvm_set_one_reg(CPUState *cs, uint64_t id, void *source);
539
540/**
541 * kvm_get_one_reg - get a register value from KVM via KVM_GET_ONE_REG ioctl
542 * @id: The register ID
543 * @target: The pointer where the value is to be stored. It must point to a
544 * variable of the correct type/size for the register being accessed.
545 *
546 * Returns: 0 on success, or a negative errno on failure.
547 */
548int kvm_get_one_reg(CPUState *cs, uint64_t id, void *target);
549struct ppc_radix_page_info *kvm_get_radix_page_info(void);
550int kvm_get_max_memslots(void);
551#endif
552