mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

PPC/KVM: make iothread work

Browse Source 
When running with --enable-io-thread the timer we have doesn't help,
because it doesn't wake up the CPU thread. So instead we need to
actually kick it.

While at it I refined the logic a bit to not dumbly trigger a timer
every 500ms, but rather do it more often after an interrupt got injected.
If there's no level based interrupt to be expected, we don't need the
timer anyways.

This makes qemu-system-ppc with --enable-io-thread work when using KVM.

Signed-off-by: Alexander Graf <agraf@suse.de>
Signed-off-by: Aurelien Jarno <aurelien@aurel32.net>
This commit is contained in:
Alexander Graf 2010-04-18 23:10:17 +02:00 committed by Aurelien Jarno
parent a5829fd9e6
commit c821c2bd4f
1 changed files with 15 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
target-ppc/kvm.c
View File

@ -37,20 +37,20 @@
do { } while (0) do { } while (0)
#endif #endif
/* XXX For some odd reason we sometimes hang inside KVM forever. I'd guess it's /* XXX We have a race condition where we actually have a level triggered
* a race condition where we actually have a level triggered interrupt, but * interrupt, but the infrastructure can't expose that yet, so the guest
* the infrastructure can't expose that yet, so the guest ACKs it, goes to * takes but ignores it, goes to sleep and never gets notified that there's
* sleep and never gets notified that there's still an interrupt pending. * still an interrupt pending.
* *
* As a quick workaround, let's just wake up every 500 ms. That way we can * As a quick workaround, let's just wake up again 20 ms after we injected
* assure that we're always reinjecting interrupts in time. * an interrupt. That way we can assure that we're always reinjecting
* interrupts in case the guest swallowed them.
*/ */
static QEMUTimer *idle_timer; static QEMUTimer *idle_timer;
static void do_nothing(void *opaque) static void kvm_kick_env(void *env)
{ {
qemu_mod_timer(idle_timer, qemu_get_clock(vm_clock) + qemu_cpu_kick(env);
(get_ticks_per_sec() / 2));
} }
int kvm_arch_init(KVMState *s, int smp_cpus) int kvm_arch_init(KVMState *s, int smp_cpus)
@ -66,6 +66,8 @@ int kvm_arch_init_vcpu(CPUState *cenv)
sregs.pvr = cenv->spr[SPR_PVR]; sregs.pvr = cenv->spr[SPR_PVR];
ret = kvm_vcpu_ioctl(cenv, KVM_SET_SREGS, &sregs); ret = kvm_vcpu_ioctl(cenv, KVM_SET_SREGS, &sregs);
idle_timer = qemu_new_timer(vm_clock, kvm_kick_env, cenv);
return ret; return ret;
} }
@ -189,12 +191,6 @@ int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
int r; int r;
unsigned irq; unsigned irq;
if (!idle_timer) {
idle_timer = qemu_new_timer(vm_clock, do_nothing, NULL);
qemu_mod_timer(idle_timer, qemu_get_clock(vm_clock) +
(get_ticks_per_sec() / 2));
}
/* PowerPC Qemu tracks the various core input pins (interrupt, critical /* PowerPC Qemu tracks the various core input pins (interrupt, critical
* interrupt, reset, etc) in PPC-specific env->irq_input_state. */ * interrupt, reset, etc) in PPC-specific env->irq_input_state. */
if (run->ready_for_interrupt_injection && if (run->ready_for_interrupt_injection &&
@ -211,6 +207,10 @@ int kvm_arch_pre_run(CPUState *env, struct kvm_run *run)
r = kvm_vcpu_ioctl(env, KVM_INTERRUPT, &irq); r = kvm_vcpu_ioctl(env, KVM_INTERRUPT, &irq);
if (r < 0) if (r < 0)
printf("cpu %d fail inject %x\n", env->cpu_index, irq); printf("cpu %d fail inject %x\n", env->cpu_index, irq);
/* Always wake up soon in case the interrupt was level based */
qemu_mod_timer(idle_timer, qemu_get_clock(vm_clock) +
(get_ticks_per_sec() / 50));
} }
/* We don't know if there are more interrupts pending after this. However, /* We don't know if there are more interrupts pending after this. However,