2 * ARM implementation of KVM hooks, 32 bit specific code.
4 * Copyright Christoffer Dall 2009-2010
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.
12 #include <sys/types.h>
13 #include <sys/ioctl.h>
16 #include <linux/kvm.h>
18 #include "qemu-common.h"
19 #include "qemu/timer.h"
20 #include "sysemu/sysemu.h"
21 #include "sysemu/kvm.h"
24 #include "internals.h"
25 #include "hw/arm/arm.h"
27 static inline void set_feature(uint64_t *features
, int feature
)
29 *features
|= 1ULL << feature
;
32 bool kvm_arm_get_host_cpu_features(ARMHostCPUClass
*ahcc
)
34 /* Identify the feature bits corresponding to the host CPU, and
35 * fill out the ARMHostCPUClass fields accordingly. To do this
36 * we have to create a scratch VM, create a single CPU inside it,
37 * and then query that CPU for the relevant ID registers.
39 int i
, ret
, fdarray
[3];
40 uint32_t midr
, id_pfr0
, id_isar0
, mvfr1
;
41 uint64_t features
= 0;
42 /* Old kernels may not know about the PREFERRED_TARGET ioctl: however
43 * we know these will only support creating one kind of guest CPU,
44 * which is its preferred CPU type.
46 static const uint32_t cpus_to_try
[] = {
47 QEMU_KVM_ARM_TARGET_CORTEX_A15
,
48 QEMU_KVM_ARM_TARGET_NONE
50 struct kvm_vcpu_init init
;
51 struct kvm_one_reg idregs
[] = {
53 .id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
54 | ENCODE_CP_REG(15, 0, 0, 0, 0, 0),
55 .addr
= (uintptr_t)&midr
,
58 .id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
59 | ENCODE_CP_REG(15, 0, 0, 1, 0, 0),
60 .addr
= (uintptr_t)&id_pfr0
,
63 .id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
64 | ENCODE_CP_REG(15, 0, 0, 2, 0, 0),
65 .addr
= (uintptr_t)&id_isar0
,
68 .id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
69 | KVM_REG_ARM_VFP
| KVM_REG_ARM_VFP_MVFR1
,
70 .addr
= (uintptr_t)&mvfr1
,
74 if (!kvm_arm_create_scratch_host_vcpu(cpus_to_try
, fdarray
, &init
)) {
78 ahcc
->target
= init
.target
;
80 /* This is not strictly blessed by the device tree binding docs yet,
81 * but in practice the kernel does not care about this string so
82 * there is no point maintaining an KVM_ARM_TARGET_* -> string table.
84 ahcc
->dtb_compatible
= "arm,arm-v7";
86 for (i
= 0; i
< ARRAY_SIZE(idregs
); i
++) {
87 ret
= ioctl(fdarray
[2], KVM_GET_ONE_REG
, &idregs
[i
]);
93 kvm_arm_destroy_scratch_host_vcpu(fdarray
);
99 /* Now we've retrieved all the register information we can
100 * set the feature bits based on the ID register fields.
101 * We can assume any KVM supporting CPU is at least a v7
102 * with VFPv3, LPAE and the generic timers; this in turn implies
103 * most of the other feature bits, but a few must be tested.
105 set_feature(&features
, ARM_FEATURE_V7
);
106 set_feature(&features
, ARM_FEATURE_VFP3
);
107 set_feature(&features
, ARM_FEATURE_LPAE
);
108 set_feature(&features
, ARM_FEATURE_GENERIC_TIMER
);
110 switch (extract32(id_isar0
, 24, 4)) {
112 set_feature(&features
, ARM_FEATURE_THUMB_DIV
);
115 set_feature(&features
, ARM_FEATURE_ARM_DIV
);
116 set_feature(&features
, ARM_FEATURE_THUMB_DIV
);
122 if (extract32(id_pfr0
, 12, 4) == 1) {
123 set_feature(&features
, ARM_FEATURE_THUMB2EE
);
125 if (extract32(mvfr1
, 20, 4) == 1) {
126 set_feature(&features
, ARM_FEATURE_VFP_FP16
);
128 if (extract32(mvfr1
, 12, 4) == 1) {
129 set_feature(&features
, ARM_FEATURE_NEON
);
131 if (extract32(mvfr1
, 28, 4) == 1) {
132 /* FMAC support implies VFPv4 */
133 set_feature(&features
, ARM_FEATURE_VFP4
);
136 ahcc
->features
= features
;
141 static bool reg_syncs_via_tuple_list(uint64_t regidx
)
143 /* Return true if the regidx is a register we should synchronize
144 * via the cpreg_tuples array (ie is not a core reg we sync by
145 * hand in kvm_arch_get/put_registers())
147 switch (regidx
& KVM_REG_ARM_COPROC_MASK
) {
148 case KVM_REG_ARM_CORE
:
149 case KVM_REG_ARM_VFP
:
156 static int compare_u64(const void *a
, const void *b
)
158 if (*(uint64_t *)a
> *(uint64_t *)b
) {
161 if (*(uint64_t *)a
< *(uint64_t *)b
) {
167 int kvm_arch_init_vcpu(CPUState
*cs
)
169 int i
, ret
, arraylen
;
171 struct kvm_one_reg r
;
172 struct kvm_reg_list rl
;
173 struct kvm_reg_list
*rlp
;
174 ARMCPU
*cpu
= ARM_CPU(cs
);
176 if (cpu
->kvm_target
== QEMU_KVM_ARM_TARGET_NONE
) {
177 fprintf(stderr
, "KVM is not supported for this guest CPU type\n");
181 /* Determine init features for this CPU */
182 memset(cpu
->kvm_init_features
, 0, sizeof(cpu
->kvm_init_features
));
183 if (cpu
->start_powered_off
) {
184 cpu
->kvm_init_features
[0] |= 1 << KVM_ARM_VCPU_POWER_OFF
;
187 /* Do KVM_ARM_VCPU_INIT ioctl */
188 ret
= kvm_arm_vcpu_init(cs
);
193 /* Query the kernel to make sure it supports 32 VFP
194 * registers: QEMU's "cortex-a15" CPU is always a
195 * VFP-D32 core. The simplest way to do this is just
196 * to attempt to read register d31.
198 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U64
| KVM_REG_ARM_VFP
| 31;
199 r
.addr
= (uintptr_t)(&v
);
200 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_ONE_REG
, &r
);
201 if (ret
== -ENOENT
) {
205 /* Populate the cpreg list based on the kernel's idea
206 * of what registers exist (and throw away the TCG-created list).
209 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_REG_LIST
, &rl
);
213 rlp
= g_malloc(sizeof(struct kvm_reg_list
) + rl
.n
* sizeof(uint64_t));
215 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_REG_LIST
, rlp
);
219 /* Sort the list we get back from the kernel, since cpreg_tuples
220 * must be in strictly ascending order.
222 qsort(&rlp
->reg
, rlp
->n
, sizeof(rlp
->reg
[0]), compare_u64
);
224 for (i
= 0, arraylen
= 0; i
< rlp
->n
; i
++) {
225 if (!reg_syncs_via_tuple_list(rlp
->reg
[i
])) {
228 switch (rlp
->reg
[i
] & KVM_REG_SIZE_MASK
) {
229 case KVM_REG_SIZE_U32
:
230 case KVM_REG_SIZE_U64
:
233 fprintf(stderr
, "Can't handle size of register in kernel list\n");
241 cpu
->cpreg_indexes
= g_renew(uint64_t, cpu
->cpreg_indexes
, arraylen
);
242 cpu
->cpreg_values
= g_renew(uint64_t, cpu
->cpreg_values
, arraylen
);
243 cpu
->cpreg_vmstate_indexes
= g_renew(uint64_t, cpu
->cpreg_vmstate_indexes
,
245 cpu
->cpreg_vmstate_values
= g_renew(uint64_t, cpu
->cpreg_vmstate_values
,
247 cpu
->cpreg_array_len
= arraylen
;
248 cpu
->cpreg_vmstate_array_len
= arraylen
;
250 for (i
= 0, arraylen
= 0; i
< rlp
->n
; i
++) {
251 uint64_t regidx
= rlp
->reg
[i
];
252 if (!reg_syncs_via_tuple_list(regidx
)) {
255 cpu
->cpreg_indexes
[arraylen
] = regidx
;
258 assert(cpu
->cpreg_array_len
== arraylen
);
260 if (!write_kvmstate_to_list(cpu
)) {
261 /* Shouldn't happen unless kernel is inconsistent about
262 * what registers exist.
264 fprintf(stderr
, "Initial read of kernel register state failed\n");
269 /* Save a copy of the initial register values so that we can
270 * feed it back to the kernel on VCPU reset.
272 cpu
->cpreg_reset_values
= g_memdup(cpu
->cpreg_values
,
273 cpu
->cpreg_array_len
*
274 sizeof(cpu
->cpreg_values
[0]));
286 #define COREREG(KERNELNAME, QEMUFIELD) \
288 KVM_REG_ARM | KVM_REG_SIZE_U32 | \
289 KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(KERNELNAME), \
290 offsetof(CPUARMState, QEMUFIELD) \
293 #define VFPSYSREG(R) \
295 KVM_REG_ARM | KVM_REG_SIZE_U32 | KVM_REG_ARM_VFP | \
296 KVM_REG_ARM_VFP_##R, \
297 offsetof(CPUARMState, vfp.xregs[ARM_VFP_##R]) \
300 /* Like COREREG, but handle fields which are in a uint64_t in CPUARMState. */
301 #define COREREG64(KERNELNAME, QEMUFIELD) \
303 KVM_REG_ARM | KVM_REG_SIZE_U32 | \
304 KVM_REG_ARM_CORE | KVM_REG_ARM_CORE_REG(KERNELNAME), \
305 offsetoflow32(CPUARMState, QEMUFIELD) \
308 static const Reg regs
[] = {
309 /* R0_usr .. R14_usr */
310 COREREG(usr_regs
.uregs
[0], regs
[0]),
311 COREREG(usr_regs
.uregs
[1], regs
[1]),
312 COREREG(usr_regs
.uregs
[2], regs
[2]),
313 COREREG(usr_regs
.uregs
[3], regs
[3]),
314 COREREG(usr_regs
.uregs
[4], regs
[4]),
315 COREREG(usr_regs
.uregs
[5], regs
[5]),
316 COREREG(usr_regs
.uregs
[6], regs
[6]),
317 COREREG(usr_regs
.uregs
[7], regs
[7]),
318 COREREG(usr_regs
.uregs
[8], usr_regs
[0]),
319 COREREG(usr_regs
.uregs
[9], usr_regs
[1]),
320 COREREG(usr_regs
.uregs
[10], usr_regs
[2]),
321 COREREG(usr_regs
.uregs
[11], usr_regs
[3]),
322 COREREG(usr_regs
.uregs
[12], usr_regs
[4]),
323 COREREG(usr_regs
.uregs
[13], banked_r13
[0]),
324 COREREG(usr_regs
.uregs
[14], banked_r14
[0]),
325 /* R13, R14, SPSR for SVC, ABT, UND, IRQ banks */
326 COREREG(svc_regs
[0], banked_r13
[1]),
327 COREREG(svc_regs
[1], banked_r14
[1]),
328 COREREG64(svc_regs
[2], banked_spsr
[1]),
329 COREREG(abt_regs
[0], banked_r13
[2]),
330 COREREG(abt_regs
[1], banked_r14
[2]),
331 COREREG64(abt_regs
[2], banked_spsr
[2]),
332 COREREG(und_regs
[0], banked_r13
[3]),
333 COREREG(und_regs
[1], banked_r14
[3]),
334 COREREG64(und_regs
[2], banked_spsr
[3]),
335 COREREG(irq_regs
[0], banked_r13
[4]),
336 COREREG(irq_regs
[1], banked_r14
[4]),
337 COREREG64(irq_regs
[2], banked_spsr
[4]),
338 /* R8_fiq .. R14_fiq and SPSR_fiq */
339 COREREG(fiq_regs
[0], fiq_regs
[0]),
340 COREREG(fiq_regs
[1], fiq_regs
[1]),
341 COREREG(fiq_regs
[2], fiq_regs
[2]),
342 COREREG(fiq_regs
[3], fiq_regs
[3]),
343 COREREG(fiq_regs
[4], fiq_regs
[4]),
344 COREREG(fiq_regs
[5], banked_r13
[5]),
345 COREREG(fiq_regs
[6], banked_r14
[5]),
346 COREREG64(fiq_regs
[7], banked_spsr
[5]),
348 COREREG(usr_regs
.uregs
[15], regs
[15]),
349 /* VFP system registers */
358 int kvm_arch_put_registers(CPUState
*cs
, int level
)
360 ARMCPU
*cpu
= ARM_CPU(cs
);
361 CPUARMState
*env
= &cpu
->env
;
362 struct kvm_one_reg r
;
365 uint32_t cpsr
, fpscr
;
367 /* Make sure the banked regs are properly set */
368 mode
= env
->uncached_cpsr
& CPSR_M
;
369 bn
= bank_number(mode
);
370 if (mode
== ARM_CPU_MODE_FIQ
) {
371 memcpy(env
->fiq_regs
, env
->regs
+ 8, 5 * sizeof(uint32_t));
373 memcpy(env
->usr_regs
, env
->regs
+ 8, 5 * sizeof(uint32_t));
375 env
->banked_r13
[bn
] = env
->regs
[13];
376 env
->banked_r14
[bn
] = env
->regs
[14];
377 env
->banked_spsr
[bn
] = env
->spsr
;
379 /* Now we can safely copy stuff down to the kernel */
380 for (i
= 0; i
< ARRAY_SIZE(regs
); i
++) {
382 r
.addr
= (uintptr_t)(env
) + regs
[i
].offset
;
383 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_ONE_REG
, &r
);
389 /* Special cases which aren't a single CPUARMState field */
390 cpsr
= cpsr_read(env
);
391 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
|
392 KVM_REG_ARM_CORE
| KVM_REG_ARM_CORE_REG(usr_regs
.ARM_cpsr
);
393 r
.addr
= (uintptr_t)(&cpsr
);
394 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_ONE_REG
, &r
);
400 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U64
| KVM_REG_ARM_VFP
;
401 for (i
= 0; i
< 32; i
++) {
402 r
.addr
= (uintptr_t)(&env
->vfp
.regs
[i
]);
403 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_ONE_REG
, &r
);
410 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
| KVM_REG_ARM_VFP
|
411 KVM_REG_ARM_VFP_FPSCR
;
412 fpscr
= vfp_get_fpscr(env
);
413 r
.addr
= (uintptr_t)&fpscr
;
414 ret
= kvm_vcpu_ioctl(cs
, KVM_SET_ONE_REG
, &r
);
419 /* Note that we do not call write_cpustate_to_list()
420 * here, so we are only writing the tuple list back to
421 * KVM. This is safe because nothing can change the
422 * CPUARMState cp15 fields (in particular gdb accesses cannot)
423 * and so there are no changes to sync. In fact syncing would
424 * be wrong at this point: for a constant register where TCG and
425 * KVM disagree about its value, the preceding write_list_to_cpustate()
426 * would not have had any effect on the CPUARMState value (since the
427 * register is read-only), and a write_cpustate_to_list() here would
428 * then try to write the TCG value back into KVM -- this would either
429 * fail or incorrectly change the value the guest sees.
431 * If we ever want to allow the user to modify cp15 registers via
432 * the gdb stub, we would need to be more clever here (for instance
433 * tracking the set of registers kvm_arch_get_registers() successfully
434 * managed to update the CPUARMState with, and only allowing those
435 * to be written back up into the kernel).
437 if (!write_list_to_kvmstate(cpu
)) {
444 int kvm_arch_get_registers(CPUState
*cs
)
446 ARMCPU
*cpu
= ARM_CPU(cs
);
447 CPUARMState
*env
= &cpu
->env
;
448 struct kvm_one_reg r
;
451 uint32_t cpsr
, fpscr
;
453 for (i
= 0; i
< ARRAY_SIZE(regs
); i
++) {
455 r
.addr
= (uintptr_t)(env
) + regs
[i
].offset
;
456 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_ONE_REG
, &r
);
462 /* Special cases which aren't a single CPUARMState field */
463 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
|
464 KVM_REG_ARM_CORE
| KVM_REG_ARM_CORE_REG(usr_regs
.ARM_cpsr
);
465 r
.addr
= (uintptr_t)(&cpsr
);
466 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_ONE_REG
, &r
);
470 cpsr_write(env
, cpsr
, 0xffffffff);
472 /* Make sure the current mode regs are properly set */
473 mode
= env
->uncached_cpsr
& CPSR_M
;
474 bn
= bank_number(mode
);
475 if (mode
== ARM_CPU_MODE_FIQ
) {
476 memcpy(env
->regs
+ 8, env
->fiq_regs
, 5 * sizeof(uint32_t));
478 memcpy(env
->regs
+ 8, env
->usr_regs
, 5 * sizeof(uint32_t));
480 env
->regs
[13] = env
->banked_r13
[bn
];
481 env
->regs
[14] = env
->banked_r14
[bn
];
482 env
->spsr
= env
->banked_spsr
[bn
];
485 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U64
| KVM_REG_ARM_VFP
;
486 for (i
= 0; i
< 32; i
++) {
487 r
.addr
= (uintptr_t)(&env
->vfp
.regs
[i
]);
488 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_ONE_REG
, &r
);
495 r
.id
= KVM_REG_ARM
| KVM_REG_SIZE_U32
| KVM_REG_ARM_VFP
|
496 KVM_REG_ARM_VFP_FPSCR
;
497 r
.addr
= (uintptr_t)&fpscr
;
498 ret
= kvm_vcpu_ioctl(cs
, KVM_GET_ONE_REG
, &r
);
502 vfp_set_fpscr(env
, fpscr
);
504 if (!write_kvmstate_to_list(cpu
)) {
507 /* Note that it's OK to have registers which aren't in CPUState,
508 * so we can ignore a failure return here.
510 write_list_to_cpustate(cpu
);
515 void kvm_arm_reset_vcpu(ARMCPU
*cpu
)
517 /* Feed the kernel back its initial register state */
518 memmove(cpu
->cpreg_values
, cpu
->cpreg_reset_values
,
519 cpu
->cpreg_array_len
* sizeof(cpu
->cpreg_values
[0]));
521 if (!write_list_to_kvmstate(cpu
)) {