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