hw/arm/virt: Add PMU node for virt machine
[qemu.git] / target-arm / kvm_arm.h
1 /*
2 * QEMU KVM support -- ARM specific functions.
3 *
4 * Copyright (c) 2012 Linaro Limited
5 *
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
8 *
9 */
10
11 #ifndef QEMU_KVM_ARM_H
12 #define QEMU_KVM_ARM_H
13
14 #include "sysemu/kvm.h"
15 #include "exec/memory.h"
16
17 /**
18 * kvm_arm_vcpu_init:
19 * @cs: CPUState
20 *
21 * Initialize (or reinitialize) the VCPU by invoking the
22 * KVM_ARM_VCPU_INIT ioctl with the CPU type and feature
23 * bitmask specified in the CPUState.
24 *
25 * Returns: 0 if success else < 0 error code
26 */
27 int kvm_arm_vcpu_init(CPUState *cs);
28
29 /**
30 * kvm_arm_register_device:
31 * @mr: memory region for this device
32 * @devid: the KVM device ID
33 * @group: device control API group for setting addresses
34 * @attr: device control API address type
35 * @dev_fd: device control device file descriptor (or -1 if not supported)
36 *
37 * Remember the memory region @mr, and when it is mapped by the
38 * machine model, tell the kernel that base address using the
39 * KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid
40 * should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or
41 * the arm-vgic device in the device control API.
42 * The machine model may map
43 * and unmap the device multiple times; the kernel will only be told the final
44 * address at the point where machine init is complete.
45 */
46 void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group,
47 uint64_t attr, int dev_fd);
48
49 /**
50 * kvm_arm_init_cpreg_list:
51 * @cs: CPUState
52 *
53 * Initialize the CPUState's cpreg list according to the kernel's
54 * definition of what CPU registers it knows about (and throw away
55 * the previous TCG-created cpreg list).
56 *
57 * Returns: 0 if success, else < 0 error code
58 */
59 int kvm_arm_init_cpreg_list(ARMCPU *cpu);
60
61 /**
62 * kvm_arm_reg_syncs_via_cpreg_list
63 * regidx: KVM register index
64 *
65 * Return true if this KVM register should be synchronized via the
66 * cpreg list of arbitrary system registers, false if it is synchronized
67 * by hand using code in kvm_arch_get/put_registers().
68 */
69 bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx);
70
71 /**
72 * kvm_arm_cpreg_level
73 * regidx: KVM register index
74 *
75 * Return the level of this coprocessor/system register. Return value is
76 * either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE.
77 */
78 int kvm_arm_cpreg_level(uint64_t regidx);
79
80 /**
81 * write_list_to_kvmstate:
82 * @cpu: ARMCPU
83 * @level: the state level to sync
84 *
85 * For each register listed in the ARMCPU cpreg_indexes list, write
86 * its value from the cpreg_values list into the kernel (via ioctl).
87 * This updates KVM's working data structures from TCG data or
88 * from incoming migration state.
89 *
90 * Returns: true if all register values were updated correctly,
91 * false if some register was unknown to the kernel or could not
92 * be written (eg constant register with the wrong value).
93 * Note that we do not stop early on failure -- we will attempt
94 * writing all registers in the list.
95 */
96 bool write_list_to_kvmstate(ARMCPU *cpu, int level);
97
98 /**
99 * write_kvmstate_to_list:
100 * @cpu: ARMCPU
101 *
102 * For each register listed in the ARMCPU cpreg_indexes list, write
103 * its value from the kernel into the cpreg_values list. This is used to
104 * copy info from KVM's working data structures into TCG or
105 * for outbound migration.
106 *
107 * Returns: true if all register values were read correctly,
108 * false if some register was unknown or could not be read.
109 * Note that we do not stop early on failure -- we will attempt
110 * reading all registers in the list.
111 */
112 bool write_kvmstate_to_list(ARMCPU *cpu);
113
114 /**
115 * kvm_arm_reset_vcpu:
116 * @cpu: ARMCPU
117 *
118 * Called at reset time to kernel registers to their initial values.
119 */
120 void kvm_arm_reset_vcpu(ARMCPU *cpu);
121
122 #ifdef CONFIG_KVM
123 /**
124 * kvm_arm_create_scratch_host_vcpu:
125 * @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with
126 * QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not
127 * know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing
128 * an empty array.
129 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order
130 * @init: filled in with the necessary values for creating a host
131 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd
132 * will still be set up).
133 *
134 * Create a scratch vcpu in its own VM of the type preferred by the host
135 * kernel (as would be used for '-cpu host'), for purposes of probing it
136 * for capabilities.
137 *
138 * Returns: true on success (and fdarray and init are filled in),
139 * false on failure (and fdarray and init are not valid).
140 */
141 bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try,
142 int *fdarray,
143 struct kvm_vcpu_init *init);
144
145 /**
146 * kvm_arm_destroy_scratch_host_vcpu:
147 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu
148 *
149 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu.
150 */
151 void kvm_arm_destroy_scratch_host_vcpu(int *fdarray);
152
153 #define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU
154 #define ARM_HOST_CPU_CLASS(klass) \
155 OBJECT_CLASS_CHECK(ARMHostCPUClass, (klass), TYPE_ARM_HOST_CPU)
156 #define ARM_HOST_CPU_GET_CLASS(obj) \
157 OBJECT_GET_CLASS(ARMHostCPUClass, (obj), TYPE_ARM_HOST_CPU)
158
159 typedef struct ARMHostCPUClass {
160 /*< private >*/
161 ARMCPUClass parent_class;
162 /*< public >*/
163
164 uint64_t features;
165 uint32_t target;
166 const char *dtb_compatible;
167 } ARMHostCPUClass;
168
169 /**
170 * kvm_arm_get_host_cpu_features:
171 * @ahcc: ARMHostCPUClass to fill in
172 *
173 * Probe the capabilities of the host kernel's preferred CPU and fill
174 * in the ARMHostCPUClass struct accordingly.
175 */
176 bool kvm_arm_get_host_cpu_features(ARMHostCPUClass *ahcc);
177
178
179 /**
180 * kvm_arm_sync_mpstate_to_kvm
181 * @cpu: ARMCPU
182 *
183 * If supported set the KVM MP_STATE based on QEMU's model.
184 */
185 int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu);
186
187 /**
188 * kvm_arm_sync_mpstate_to_qemu
189 * @cpu: ARMCPU
190 *
191 * If supported get the MP_STATE from KVM and store in QEMU's model.
192 */
193 int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu);
194
195 int kvm_arm_vgic_probe(void);
196
197 int kvm_arm_pmu_create(CPUState *cs, int irq);
198
199 #else
200
201 static inline int kvm_arm_vgic_probe(void)
202 {
203 return 0;
204 }
205
206 static inline int kvm_arm_pmu_create(CPUState *cs, int irq)
207 {
208 return 0;
209 }
210
211 #endif
212
213 static inline const char *gic_class_name(void)
214 {
215 return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic";
216 }
217
218 /**
219 * gicv3_class_name
220 *
221 * Return name of GICv3 class to use depending on whether KVM acceleration is
222 * in use. May throw an error if the chosen implementation is not available.
223 *
224 * Returns: class name to use
225 */
226 const char *gicv3_class_name(void);
227
228 /**
229 * kvm_arm_handle_debug:
230 * @cs: CPUState
231 * @debug_exit: debug part of the KVM exit structure
232 *
233 * Returns: TRUE if the debug exception was handled.
234 */
235 bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit);
236
237 /**
238 * kvm_arm_hw_debug_active:
239 * @cs: CPU State
240 *
241 * Return: TRUE if any hardware breakpoints in use.
242 */
243
244 bool kvm_arm_hw_debug_active(CPUState *cs);
245
246 /**
247 * kvm_arm_copy_hw_debug_data:
248 *
249 * @ptr: kvm_guest_debug_arch structure
250 *
251 * Copy the architecture specific debug registers into the
252 * kvm_guest_debug ioctl structure.
253 */
254 struct kvm_guest_debug_arch;
255
256 void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr);
257
258 #endif