2 * PowerPC implementation of KVM hooks
4 * Copyright IBM Corp. 2007
7 * Jerone Young <jyoung5@us.ibm.com>
8 * Christian Ehrhardt <ehrhardt@linux.vnet.ibm.com>
9 * Hollis Blanchard <hollisb@us.ibm.com>
11 * This work is licensed under the terms of the GNU GPL, version 2 or later.
12 * See the COPYING file in the top-level directory.
16 #include <sys/types.h>
17 #include <sys/ioctl.h>
20 #include <linux/kvm.h>
22 #include "qemu-common.h"
23 #include "qemu-timer.h"
28 #include "device_tree.h"
33 #define dprintf(fmt, ...) \
34 do { fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
36 #define dprintf(fmt, ...) \
40 const KVMCapabilityInfo kvm_arch_required_capabilities
[] = {
44 static int cap_interrupt_unset
= false;
45 static int cap_interrupt_level
= false;
47 /* XXX We have a race condition where we actually have a level triggered
48 * interrupt, but the infrastructure can't expose that yet, so the guest
49 * takes but ignores it, goes to sleep and never gets notified that there's
50 * still an interrupt pending.
52 * As a quick workaround, let's just wake up again 20 ms after we injected
53 * an interrupt. That way we can assure that we're always reinjecting
54 * interrupts in case the guest swallowed them.
56 static QEMUTimer
*idle_timer
;
58 static void kvm_kick_env(void *env
)
63 int kvm_arch_init(KVMState
*s
)
65 #ifdef KVM_CAP_PPC_UNSET_IRQ
66 cap_interrupt_unset
= kvm_check_extension(s
, KVM_CAP_PPC_UNSET_IRQ
);
68 #ifdef KVM_CAP_PPC_IRQ_LEVEL
69 cap_interrupt_level
= kvm_check_extension(s
, KVM_CAP_PPC_IRQ_LEVEL
);
72 if (!cap_interrupt_level
) {
73 fprintf(stderr
, "KVM: Couldn't find level irq capability. Expect the "
74 "VM to stall at times!\n");
80 static int kvm_arch_sync_sregs(CPUState
*cenv
)
82 struct kvm_sregs sregs
;
85 if (cenv
->excp_model
== POWERPC_EXCP_BOOKE
) {
88 #ifdef KVM_CAP_PPC_SEGSTATE
89 if (!kvm_check_extension(cenv
->kvm_state
, KVM_CAP_PPC_SEGSTATE
)) {
97 ret
= kvm_vcpu_ioctl(cenv
, KVM_GET_SREGS
, &sregs
);
102 sregs
.pvr
= cenv
->spr
[SPR_PVR
];
103 return kvm_vcpu_ioctl(cenv
, KVM_SET_SREGS
, &sregs
);
106 int kvm_arch_init_vcpu(CPUState
*cenv
)
110 ret
= kvm_arch_sync_sregs(cenv
);
115 idle_timer
= qemu_new_timer_ns(vm_clock
, kvm_kick_env
, cenv
);
120 void kvm_arch_reset_vcpu(CPUState
*env
)
124 int kvm_arch_put_registers(CPUState
*env
, int level
)
126 struct kvm_regs regs
;
130 ret
= kvm_vcpu_ioctl(env
, KVM_GET_REGS
, ®s
);
140 regs
.srr0
= env
->spr
[SPR_SRR0
];
141 regs
.srr1
= env
->spr
[SPR_SRR1
];
143 regs
.sprg0
= env
->spr
[SPR_SPRG0
];
144 regs
.sprg1
= env
->spr
[SPR_SPRG1
];
145 regs
.sprg2
= env
->spr
[SPR_SPRG2
];
146 regs
.sprg3
= env
->spr
[SPR_SPRG3
];
147 regs
.sprg4
= env
->spr
[SPR_SPRG4
];
148 regs
.sprg5
= env
->spr
[SPR_SPRG5
];
149 regs
.sprg6
= env
->spr
[SPR_SPRG6
];
150 regs
.sprg7
= env
->spr
[SPR_SPRG7
];
152 for (i
= 0;i
< 32; i
++)
153 regs
.gpr
[i
] = env
->gpr
[i
];
155 ret
= kvm_vcpu_ioctl(env
, KVM_SET_REGS
, ®s
);
162 int kvm_arch_get_registers(CPUState
*env
)
164 struct kvm_regs regs
;
165 struct kvm_sregs sregs
;
168 ret
= kvm_vcpu_ioctl(env
, KVM_GET_REGS
, ®s
);
172 ret
= kvm_vcpu_ioctl(env
, KVM_GET_SREGS
, &sregs
);
182 env
->spr
[SPR_SRR0
] = regs
.srr0
;
183 env
->spr
[SPR_SRR1
] = regs
.srr1
;
185 env
->spr
[SPR_SPRG0
] = regs
.sprg0
;
186 env
->spr
[SPR_SPRG1
] = regs
.sprg1
;
187 env
->spr
[SPR_SPRG2
] = regs
.sprg2
;
188 env
->spr
[SPR_SPRG3
] = regs
.sprg3
;
189 env
->spr
[SPR_SPRG4
] = regs
.sprg4
;
190 env
->spr
[SPR_SPRG5
] = regs
.sprg5
;
191 env
->spr
[SPR_SPRG6
] = regs
.sprg6
;
192 env
->spr
[SPR_SPRG7
] = regs
.sprg7
;
194 for (i
= 0;i
< 32; i
++)
195 env
->gpr
[i
] = regs
.gpr
[i
];
197 #ifdef KVM_CAP_PPC_SEGSTATE
198 if (kvm_check_extension(env
->kvm_state
, KVM_CAP_PPC_SEGSTATE
)) {
199 ppc_store_sdr1(env
, sregs
.u
.s
.sdr1
);
203 for (i
= 0; i
< 64; i
++) {
204 ppc_store_slb(env
, sregs
.u
.s
.ppc64
.slb
[i
].slbe
,
205 sregs
.u
.s
.ppc64
.slb
[i
].slbv
);
210 for (i
= 0; i
< 16; i
++) {
211 env
->sr
[i
] = sregs
.u
.s
.ppc32
.sr
[i
];
215 for (i
= 0; i
< 8; i
++) {
216 env
->DBAT
[0][i
] = sregs
.u
.s
.ppc32
.dbat
[i
] & 0xffffffff;
217 env
->DBAT
[1][i
] = sregs
.u
.s
.ppc32
.dbat
[i
] >> 32;
218 env
->IBAT
[0][i
] = sregs
.u
.s
.ppc32
.ibat
[i
] & 0xffffffff;
219 env
->IBAT
[1][i
] = sregs
.u
.s
.ppc32
.ibat
[i
] >> 32;
227 int kvmppc_set_interrupt(CPUState
*env
, int irq
, int level
)
229 unsigned virq
= level
? KVM_INTERRUPT_SET_LEVEL
: KVM_INTERRUPT_UNSET
;
231 if (irq
!= PPC_INTERRUPT_EXT
) {
235 if (!kvm_enabled() || !cap_interrupt_unset
|| !cap_interrupt_level
) {
239 kvm_vcpu_ioctl(env
, KVM_INTERRUPT
, &virq
);
244 #if defined(TARGET_PPCEMB)
245 #define PPC_INPUT_INT PPC40x_INPUT_INT
246 #elif defined(TARGET_PPC64)
247 #define PPC_INPUT_INT PPC970_INPUT_INT
249 #define PPC_INPUT_INT PPC6xx_INPUT_INT
252 void kvm_arch_pre_run(CPUState
*env
, struct kvm_run
*run
)
257 /* PowerPC Qemu tracks the various core input pins (interrupt, critical
258 * interrupt, reset, etc) in PPC-specific env->irq_input_state. */
259 if (!cap_interrupt_level
&&
260 run
->ready_for_interrupt_injection
&&
261 (env
->interrupt_request
& CPU_INTERRUPT_HARD
) &&
262 (env
->irq_input_state
& (1<<PPC_INPUT_INT
)))
264 /* For now KVM disregards the 'irq' argument. However, in the
265 * future KVM could cache it in-kernel to avoid a heavyweight exit
266 * when reading the UIC.
268 irq
= KVM_INTERRUPT_SET
;
270 dprintf("injected interrupt %d\n", irq
);
271 r
= kvm_vcpu_ioctl(env
, KVM_INTERRUPT
, &irq
);
273 printf("cpu %d fail inject %x\n", env
->cpu_index
, irq
);
275 /* Always wake up soon in case the interrupt was level based */
276 qemu_mod_timer(idle_timer
, qemu_get_clock_ns(vm_clock
) +
277 (get_ticks_per_sec() / 50));
280 /* We don't know if there are more interrupts pending after this. However,
281 * the guest will return to userspace in the course of handling this one
282 * anyways, so we will get a chance to deliver the rest. */
285 void kvm_arch_post_run(CPUState
*env
, struct kvm_run
*run
)
289 int kvm_arch_process_async_events(CPUState
*env
)
294 static int kvmppc_handle_halt(CPUState
*env
)
296 if (!(env
->interrupt_request
& CPU_INTERRUPT_HARD
) && (msr_ee
)) {
298 env
->exception_index
= EXCP_HLT
;
304 /* map dcr access to existing qemu dcr emulation */
305 static int kvmppc_handle_dcr_read(CPUState
*env
, uint32_t dcrn
, uint32_t *data
)
307 if (ppc_dcr_read(env
->dcr_env
, dcrn
, data
) < 0)
308 fprintf(stderr
, "Read to unhandled DCR (0x%x)\n", dcrn
);
313 static int kvmppc_handle_dcr_write(CPUState
*env
, uint32_t dcrn
, uint32_t data
)
315 if (ppc_dcr_write(env
->dcr_env
, dcrn
, data
) < 0)
316 fprintf(stderr
, "Write to unhandled DCR (0x%x)\n", dcrn
);
321 int kvm_arch_handle_exit(CPUState
*env
, struct kvm_run
*run
)
325 switch (run
->exit_reason
) {
327 if (run
->dcr
.is_write
) {
328 dprintf("handle dcr write\n");
329 ret
= kvmppc_handle_dcr_write(env
, run
->dcr
.dcrn
, run
->dcr
.data
);
331 dprintf("handle dcr read\n");
332 ret
= kvmppc_handle_dcr_read(env
, run
->dcr
.dcrn
, &run
->dcr
.data
);
336 dprintf("handle halt\n");
337 ret
= kvmppc_handle_halt(env
);
340 fprintf(stderr
, "KVM: unknown exit reason %d\n", run
->exit_reason
);
348 static int read_cpuinfo(const char *field
, char *value
, int len
)
352 int field_len
= strlen(field
);
355 f
= fopen("/proc/cpuinfo", "r");
361 if(!fgets(line
, sizeof(line
), f
)) {
364 if (!strncmp(line
, field
, field_len
)) {
365 strncpy(value
, line
, len
);
376 uint32_t kvmppc_get_tbfreq(void)
380 uint32_t retval
= get_ticks_per_sec();
382 if (read_cpuinfo("timebase", line
, sizeof(line
))) {
386 if (!(ns
= strchr(line
, ':'))) {
396 int kvmppc_get_hypercall(CPUState
*env
, uint8_t *buf
, int buf_len
)
398 uint32_t *hc
= (uint32_t*)buf
;
400 #ifdef KVM_CAP_PPC_GET_PVINFO
401 struct kvm_ppc_pvinfo pvinfo
;
403 if (kvm_check_extension(env
->kvm_state
, KVM_CAP_PPC_GET_PVINFO
) &&
404 !kvm_vm_ioctl(env
->kvm_state
, KVM_PPC_GET_PVINFO
, &pvinfo
)) {
405 memcpy(buf
, pvinfo
.hcall
, buf_len
);
412 * Fallback to always fail hypercalls:
428 bool kvm_arch_stop_on_emulation_error(CPUState
*env
)
433 int kvm_arch_on_sigbus_vcpu(CPUState
*env
, int code
, void *addr
)
438 int kvm_arch_on_sigbus(int code
, void *addr
)