meson: target
[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 #include "qemu/error-report.h"
17
18 #define KVM_ARM_VGIC_V2 (1 << 0)
19 #define KVM_ARM_VGIC_V3 (1 << 1)
20
21 /**
22 * kvm_arm_vcpu_init:
23 * @cs: CPUState
24 *
25 * Initialize (or reinitialize) the VCPU by invoking the
26 * KVM_ARM_VCPU_INIT ioctl with the CPU type and feature
27 * bitmask specified in the CPUState.
28 *
29 * Returns: 0 if success else < 0 error code
30 */
31 int kvm_arm_vcpu_init(CPUState *cs);
32
33 /**
34 * kvm_arm_vcpu_finalize:
35 * @cs: CPUState
36 * @feature: feature to finalize
37 *
38 * Finalizes the configuration of the specified VCPU feature by
39 * invoking the KVM_ARM_VCPU_FINALIZE ioctl. Features requiring
40 * this are documented in the "KVM_ARM_VCPU_FINALIZE" section of
41 * KVM's API documentation.
42 *
43 * Returns: 0 if success else < 0 error code
44 */
45 int kvm_arm_vcpu_finalize(CPUState *cs, int feature);
46
47 /**
48 * kvm_arm_register_device:
49 * @mr: memory region for this device
50 * @devid: the KVM device ID
51 * @group: device control API group for setting addresses
52 * @attr: device control API address type
53 * @dev_fd: device control device file descriptor (or -1 if not supported)
54 * @addr_ormask: value to be OR'ed with resolved address
55 *
56 * Remember the memory region @mr, and when it is mapped by the
57 * machine model, tell the kernel that base address using the
58 * KVM_ARM_SET_DEVICE_ADDRESS ioctl or the newer device control API. @devid
59 * should be the ID of the device as defined by KVM_ARM_SET_DEVICE_ADDRESS or
60 * the arm-vgic device in the device control API.
61 * The machine model may map
62 * and unmap the device multiple times; the kernel will only be told the final
63 * address at the point where machine init is complete.
64 */
65 void kvm_arm_register_device(MemoryRegion *mr, uint64_t devid, uint64_t group,
66 uint64_t attr, int dev_fd, uint64_t addr_ormask);
67
68 /**
69 * kvm_arm_init_cpreg_list:
70 * @cpu: ARMCPU
71 *
72 * Initialize the ARMCPU cpreg list according to the kernel's
73 * definition of what CPU registers it knows about (and throw away
74 * the previous TCG-created cpreg list).
75 *
76 * Returns: 0 if success, else < 0 error code
77 */
78 int kvm_arm_init_cpreg_list(ARMCPU *cpu);
79
80 /**
81 * kvm_arm_reg_syncs_via_cpreg_list:
82 * @regidx: KVM register index
83 *
84 * Return true if this KVM register should be synchronized via the
85 * cpreg list of arbitrary system registers, false if it is synchronized
86 * by hand using code in kvm_arch_get/put_registers().
87 */
88 bool kvm_arm_reg_syncs_via_cpreg_list(uint64_t regidx);
89
90 /**
91 * kvm_arm_cpreg_level:
92 * @regidx: KVM register index
93 *
94 * Return the level of this coprocessor/system register. Return value is
95 * either KVM_PUT_RUNTIME_STATE, KVM_PUT_RESET_STATE, or KVM_PUT_FULL_STATE.
96 */
97 int kvm_arm_cpreg_level(uint64_t regidx);
98
99 /**
100 * write_list_to_kvmstate:
101 * @cpu: ARMCPU
102 * @level: the state level to sync
103 *
104 * For each register listed in the ARMCPU cpreg_indexes list, write
105 * its value from the cpreg_values list into the kernel (via ioctl).
106 * This updates KVM's working data structures from TCG data or
107 * from incoming migration state.
108 *
109 * Returns: true if all register values were updated correctly,
110 * false if some register was unknown to the kernel or could not
111 * be written (eg constant register with the wrong value).
112 * Note that we do not stop early on failure -- we will attempt
113 * writing all registers in the list.
114 */
115 bool write_list_to_kvmstate(ARMCPU *cpu, int level);
116
117 /**
118 * write_kvmstate_to_list:
119 * @cpu: ARMCPU
120 *
121 * For each register listed in the ARMCPU cpreg_indexes list, write
122 * its value from the kernel into the cpreg_values list. This is used to
123 * copy info from KVM's working data structures into TCG or
124 * for outbound migration.
125 *
126 * Returns: true if all register values were read correctly,
127 * false if some register was unknown or could not be read.
128 * Note that we do not stop early on failure -- we will attempt
129 * reading all registers in the list.
130 */
131 bool write_kvmstate_to_list(ARMCPU *cpu);
132
133 /**
134 * kvm_arm_cpu_pre_save:
135 * @cpu: ARMCPU
136 *
137 * Called after write_kvmstate_to_list() from cpu_pre_save() to update
138 * the cpreg list with KVM CPU state.
139 */
140 void kvm_arm_cpu_pre_save(ARMCPU *cpu);
141
142 /**
143 * kvm_arm_cpu_post_load:
144 * @cpu: ARMCPU
145 *
146 * Called from cpu_post_load() to update KVM CPU state from the cpreg list.
147 */
148 void kvm_arm_cpu_post_load(ARMCPU *cpu);
149
150 /**
151 * kvm_arm_reset_vcpu:
152 * @cpu: ARMCPU
153 *
154 * Called at reset time to kernel registers to their initial values.
155 */
156 void kvm_arm_reset_vcpu(ARMCPU *cpu);
157
158 /**
159 * kvm_arm_init_serror_injection:
160 * @cs: CPUState
161 *
162 * Check whether KVM can set guest SError syndrome.
163 */
164 void kvm_arm_init_serror_injection(CPUState *cs);
165
166 /**
167 * kvm_get_vcpu_events:
168 * @cpu: ARMCPU
169 *
170 * Get VCPU related state from kvm.
171 *
172 * Returns: 0 if success else < 0 error code
173 */
174 int kvm_get_vcpu_events(ARMCPU *cpu);
175
176 /**
177 * kvm_put_vcpu_events:
178 * @cpu: ARMCPU
179 *
180 * Put VCPU related state to kvm.
181 *
182 * Returns: 0 if success else < 0 error code
183 */
184 int kvm_put_vcpu_events(ARMCPU *cpu);
185
186 #ifdef CONFIG_KVM
187 /**
188 * kvm_arm_create_scratch_host_vcpu:
189 * @cpus_to_try: array of QEMU_KVM_ARM_TARGET_* values (terminated with
190 * QEMU_KVM_ARM_TARGET_NONE) to try as fallback if the kernel does not
191 * know the PREFERRED_TARGET ioctl. Passing NULL is the same as passing
192 * an empty array.
193 * @fdarray: filled in with kvmfd, vmfd, cpufd file descriptors in that order
194 * @init: filled in with the necessary values for creating a host
195 * vcpu. If NULL is provided, will not init the vCPU (though the cpufd
196 * will still be set up).
197 *
198 * Create a scratch vcpu in its own VM of the type preferred by the host
199 * kernel (as would be used for '-cpu host'), for purposes of probing it
200 * for capabilities.
201 *
202 * Returns: true on success (and fdarray and init are filled in),
203 * false on failure (and fdarray and init are not valid).
204 */
205 bool kvm_arm_create_scratch_host_vcpu(const uint32_t *cpus_to_try,
206 int *fdarray,
207 struct kvm_vcpu_init *init);
208
209 /**
210 * kvm_arm_destroy_scratch_host_vcpu:
211 * @fdarray: array of fds as set up by kvm_arm_create_scratch_host_vcpu
212 *
213 * Tear down the scratch vcpu created by kvm_arm_create_scratch_host_vcpu.
214 */
215 void kvm_arm_destroy_scratch_host_vcpu(int *fdarray);
216
217 #define TYPE_ARM_HOST_CPU "host-" TYPE_ARM_CPU
218
219 /**
220 * ARMHostCPUFeatures: information about the host CPU (identified
221 * by asking the host kernel)
222 */
223 typedef struct ARMHostCPUFeatures {
224 ARMISARegisters isar;
225 uint64_t features;
226 uint32_t target;
227 const char *dtb_compatible;
228 } ARMHostCPUFeatures;
229
230 /**
231 * kvm_arm_get_host_cpu_features:
232 * @ahcf: ARMHostCPUClass to fill in
233 *
234 * Probe the capabilities of the host kernel's preferred CPU and fill
235 * in the ARMHostCPUClass struct accordingly.
236 *
237 * Returns true on success and false otherwise.
238 */
239 bool kvm_arm_get_host_cpu_features(ARMHostCPUFeatures *ahcf);
240
241 /**
242 * kvm_arm_sve_get_vls:
243 * @cs: CPUState
244 * @map: bitmap to fill in
245 *
246 * Get all the SVE vector lengths supported by the KVM host, setting
247 * the bits corresponding to their length in quadwords minus one
248 * (vq - 1) in @map up to ARM_MAX_VQ.
249 */
250 void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map);
251
252 /**
253 * kvm_arm_set_cpu_features_from_host:
254 * @cpu: ARMCPU to set the features for
255 *
256 * Set up the ARMCPU struct fields up to match the information probed
257 * from the host CPU.
258 */
259 void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu);
260
261 /**
262 * kvm_arm_add_vcpu_properties:
263 * @obj: The CPU object to add the properties to
264 *
265 * Add all KVM specific CPU properties to the CPU object. These
266 * are the CPU properties with "kvm-" prefixed names.
267 */
268 void kvm_arm_add_vcpu_properties(Object *obj);
269
270 /**
271 * kvm_arm_aarch32_supported:
272 *
273 * Returns: true if KVM can enable AArch32 mode
274 * and false otherwise.
275 */
276 bool kvm_arm_aarch32_supported(void);
277
278 /**
279 * kvm_arm_pmu_supported:
280 *
281 * Returns: true if KVM can enable the PMU
282 * and false otherwise.
283 */
284 bool kvm_arm_pmu_supported(void);
285
286 /**
287 * kvm_arm_sve_supported:
288 *
289 * Returns true if KVM can enable SVE and false otherwise.
290 */
291 bool kvm_arm_sve_supported(void);
292
293 /**
294 * kvm_arm_get_max_vm_ipa_size:
295 * @ms: Machine state handle
296 *
297 * Returns the number of bits in the IPA address space supported by KVM
298 */
299 int kvm_arm_get_max_vm_ipa_size(MachineState *ms);
300
301 /**
302 * kvm_arm_sync_mpstate_to_kvm:
303 * @cpu: ARMCPU
304 *
305 * If supported set the KVM MP_STATE based on QEMU's model.
306 *
307 * Returns 0 on success and -1 on failure.
308 */
309 int kvm_arm_sync_mpstate_to_kvm(ARMCPU *cpu);
310
311 /**
312 * kvm_arm_sync_mpstate_to_qemu:
313 * @cpu: ARMCPU
314 *
315 * If supported get the MP_STATE from KVM and store in QEMU's model.
316 *
317 * Returns 0 on success and aborts on failure.
318 */
319 int kvm_arm_sync_mpstate_to_qemu(ARMCPU *cpu);
320
321 /**
322 * kvm_arm_get_virtual_time:
323 * @cs: CPUState
324 *
325 * Gets the VCPU's virtual counter and stores it in the KVM CPU state.
326 */
327 void kvm_arm_get_virtual_time(CPUState *cs);
328
329 /**
330 * kvm_arm_put_virtual_time:
331 * @cs: CPUState
332 *
333 * Sets the VCPU's virtual counter to the value stored in the KVM CPU state.
334 */
335 void kvm_arm_put_virtual_time(CPUState *cs);
336
337 void kvm_arm_vm_state_change(void *opaque, int running, RunState state);
338
339 int kvm_arm_vgic_probe(void);
340
341 void kvm_arm_pmu_set_irq(CPUState *cs, int irq);
342 void kvm_arm_pmu_init(CPUState *cs);
343 int kvm_arm_set_irq(int cpu, int irqtype, int irq, int level);
344
345 #else
346
347 static inline void kvm_arm_set_cpu_features_from_host(ARMCPU *cpu)
348 {
349 /*
350 * This should never actually be called in the "not KVM" case,
351 * but set up the fields to indicate an error anyway.
352 */
353 cpu->kvm_target = QEMU_KVM_ARM_TARGET_NONE;
354 cpu->host_cpu_probe_failed = true;
355 }
356
357 static inline void kvm_arm_add_vcpu_properties(Object *obj) {}
358
359 static inline bool kvm_arm_aarch32_supported(void)
360 {
361 return false;
362 }
363
364 static inline bool kvm_arm_pmu_supported(void)
365 {
366 return false;
367 }
368
369 static inline bool kvm_arm_sve_supported(void)
370 {
371 return false;
372 }
373
374 static inline int kvm_arm_get_max_vm_ipa_size(MachineState *ms)
375 {
376 return -ENOENT;
377 }
378
379 static inline int kvm_arm_vgic_probe(void)
380 {
381 return 0;
382 }
383
384 static inline void kvm_arm_pmu_set_irq(CPUState *cs, int irq) {}
385 static inline void kvm_arm_pmu_init(CPUState *cs) {}
386
387 static inline void kvm_arm_sve_get_vls(CPUState *cs, unsigned long *map) {}
388
389 static inline void kvm_arm_get_virtual_time(CPUState *cs) {}
390 static inline void kvm_arm_put_virtual_time(CPUState *cs) {}
391 #endif
392
393 static inline const char *gic_class_name(void)
394 {
395 return kvm_irqchip_in_kernel() ? "kvm-arm-gic" : "arm_gic";
396 }
397
398 /**
399 * gicv3_class_name
400 *
401 * Return name of GICv3 class to use depending on whether KVM acceleration is
402 * in use. May throw an error if the chosen implementation is not available.
403 *
404 * Returns: class name to use
405 */
406 static inline const char *gicv3_class_name(void)
407 {
408 if (kvm_irqchip_in_kernel()) {
409 #ifdef TARGET_AARCH64
410 return "kvm-arm-gicv3";
411 #else
412 error_report("KVM GICv3 acceleration is not supported on this "
413 "platform");
414 exit(1);
415 #endif
416 } else {
417 if (kvm_enabled()) {
418 error_report("Userspace GICv3 is not supported with KVM");
419 exit(1);
420 }
421 return "arm-gicv3";
422 }
423 }
424
425 /**
426 * kvm_arm_handle_debug:
427 * @cs: CPUState
428 * @debug_exit: debug part of the KVM exit structure
429 *
430 * Returns: TRUE if the debug exception was handled.
431 */
432 bool kvm_arm_handle_debug(CPUState *cs, struct kvm_debug_exit_arch *debug_exit);
433
434 /**
435 * kvm_arm_hw_debug_active:
436 * @cs: CPU State
437 *
438 * Return: TRUE if any hardware breakpoints in use.
439 */
440 bool kvm_arm_hw_debug_active(CPUState *cs);
441
442 /**
443 * kvm_arm_copy_hw_debug_data:
444 * @ptr: kvm_guest_debug_arch structure
445 *
446 * Copy the architecture specific debug registers into the
447 * kvm_guest_debug ioctl structure.
448 */
449 struct kvm_guest_debug_arch;
450 void kvm_arm_copy_hw_debug_data(struct kvm_guest_debug_arch *ptr);
451
452 /**
453 * kvm_arm_verify_ext_dabt_pending:
454 * @cs: CPUState
455 *
456 * Verify the fault status code wrt the Ext DABT injection
457 *
458 * Returns: true if the fault status code is as expected, false otherwise
459 */
460 bool kvm_arm_verify_ext_dabt_pending(CPUState *cs);
461
462 /**
463 * its_class_name:
464 *
465 * Return the ITS class name to use depending on whether KVM acceleration
466 * and KVM CAP_SIGNAL_MSI are supported
467 *
468 * Returns: class name to use or NULL
469 */
470 static inline const char *its_class_name(void)
471 {
472 if (kvm_irqchip_in_kernel()) {
473 /* KVM implementation requires this capability */
474 return kvm_direct_msi_enabled() ? "arm-its-kvm" : NULL;
475 } else {
476 /* Software emulation is not implemented yet */
477 return NULL;
478 }
479 }
480
481 #endif