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