Replace hrtimer based timer emulation with host timebase (ktime_t) comparisons on guest entry.
This avoids host load when guests are scheduled out, removes a spinlock acquision on entry (i8254.c's inject_lock), and makes future improvements easier. Signed-off-by: Marcelo Tosatti <[email protected]> Index: kvm-new/arch/x86/kvm/x86.c =================================================================== --- kvm-new.orig/arch/x86/kvm/x86.c +++ kvm-new/arch/x86/kvm/x86.c @@ -3461,8 +3461,6 @@ static int vcpu_enter_guest(struct kvm_v goto out; if (vcpu->requests) { - if (test_and_clear_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests)) - __kvm_migrate_timers(vcpu); if (test_and_clear_bit(KVM_REQ_KVMCLOCK_UPDATE, &vcpu->requests)) kvm_write_guest_time(vcpu); if (test_and_clear_bit(KVM_REQ_MMU_SYNC, &vcpu->requests)) @@ -3482,6 +3480,9 @@ static int vcpu_enter_guest(struct kvm_v } } + + kvm_inject_pending_timer_irqs(vcpu); + preempt_disable(); kvm_x86_ops->prepare_guest_switch(vcpu); @@ -3499,6 +3500,8 @@ static int vcpu_enter_guest(struct kvm_v goto out; } + kvm_vcpu_arm_exit(vcpu); + if (vcpu->arch.exception.pending) __queue_exception(vcpu); else @@ -3564,6 +3567,8 @@ static int vcpu_enter_guest(struct kvm_v preempt_enable(); + kvm_vcpu_cleanup_timer(vcpu); + down_read(&vcpu->kvm->slots_lock); /* @@ -3627,10 +3632,6 @@ static int __vcpu_run(struct kvm_vcpu *v if (r <= 0) break; - clear_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests); - if (kvm_cpu_has_pending_timer(vcpu)) - kvm_inject_pending_timer_irqs(vcpu); - if (dm_request_for_irq_injection(vcpu, kvm_run)) { r = -EINTR; kvm_run->exit_reason = KVM_EXIT_INTR; @@ -4579,6 +4580,8 @@ int kvm_arch_vcpu_setup(struct kvm_vcpu if (r < 0) goto free_vcpu; + kvm_vcpu_init_armed_exit(vcpu); + if (kvm->arch.vpit && kvm_vcpu_is_bsp(vcpu)) kvm_timer_vcpu_bind(&kvm->arch.vpit->pit_state.pit_timer, vcpu); Index: kvm-new/virt/kvm/kvm_main.c =================================================================== --- kvm-new.orig/virt/kvm/kvm_main.c +++ kvm-new/virt/kvm/kvm_main.c @@ -1656,11 +1656,19 @@ void mark_page_dirty(struct kvm *kvm, gf } } +#ifndef KVM_ARCH_HAVE_TIMER_EVENT +ktime_t kvm_vcpu_next_timer_event(struct kvm_vcpu *vcpu) +{ + return (ktime_t) { .tv64 = KTIME_MAX }; +} +#endif + /* * The vCPU has executed a HLT instruction with in-kernel mode enabled. */ void kvm_vcpu_block(struct kvm_vcpu *vcpu) { + ktime_t expires; DEFINE_WAIT(wait); for (;;) { @@ -1677,8 +1685,9 @@ void kvm_vcpu_block(struct kvm_vcpu *vcp if (signal_pending(current)) break; + expires = kvm_vcpu_next_timer_event(vcpu); vcpu_put(vcpu); - schedule(); + schedule_hrtimeout(&expires, HRTIMER_MODE_ABS); vcpu_load(vcpu); } Index: kvm-new/arch/x86/kvm/i8254.c =================================================================== --- kvm-new.orig/arch/x86/kvm/i8254.c +++ kvm-new/arch/x86/kvm/i8254.c @@ -224,15 +224,6 @@ static void pit_latch_status(struct kvm } } -int pit_has_pending_timer(struct kvm_vcpu *vcpu) -{ - struct kvm_pit *pit = vcpu->kvm->arch.vpit; - - if (pit && kvm_vcpu_is_bsp(vcpu) && pit->pit_state.irq_ack) - return kvm_timer_has_pending(&pit->pit_state.pit_timer); - return 0; -} - static void kvm_pit_ack_irq(struct kvm_irq_ack_notifier *kian) { struct kvm_kpit_state *ps = container_of(kian, struct kvm_kpit_state, @@ -548,6 +539,36 @@ static const struct kvm_io_device_ops sp .write = speaker_ioport_write, }; +static void pit_inject(struct kvm_timer *ktimer) +{ + int i; + struct kvm_vcpu *vcpu; + struct kvm *kvm = ktimer->kvm; + + mutex_lock(&kvm->irq_lock); + kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 1); + kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 0); + mutex_unlock(&kvm->irq_lock); + + /* + * Provides NMI watchdog support via Virtual Wire mode. + * The route is: PIT -> PIC -> LVT0 in NMI mode. + * + * Note: Our Virtual Wire implementation is simplified, only + * propagating PIT interrupts to all VCPUs when they have set + * LVT0 to NMI delivery. Other PIC interrupts are just sent to + * VCPU0, and only if its LVT0 is in EXTINT mode. + */ + if (kvm->arch.vapics_in_nmi_mode > 0) + kvm_for_each_vcpu(i, vcpu, kvm) + kvm_apic_nmi_wd_deliver(vcpu); +} + +struct kvm_timer_ops kpit_ops = { + .inject = pit_inject, + .name = "pit", +}; + /* Caller must have writers lock on slots_lock */ struct kvm_pit *kvm_create_pit(struct kvm *kvm, u32 flags) { @@ -573,7 +594,7 @@ struct kvm_pit *kvm_create_pit(struct kv pit_state = &pit->pit_state; pit_state->pit = pit; - kvm_timer_init(kvm, &pit_state->pit_timer); + kvm_timer_init(kvm, &pit_state->pit_timer, &kpit_ops); pit_state->irq_ack_notifier.gsi = 0; pit_state->irq_ack_notifier.irq_acked = kvm_pit_ack_irq; @@ -610,50 +631,3 @@ void kvm_free_pit(struct kvm *kvm) } } -static void __inject_pit_timer_intr(struct kvm *kvm) -{ - struct kvm_vcpu *vcpu; - int i; - - mutex_lock(&kvm->irq_lock); - kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 1); - kvm_set_irq(kvm, kvm->arch.vpit->irq_source_id, 0, 0); - mutex_unlock(&kvm->irq_lock); - - /* - * Provides NMI watchdog support via Virtual Wire mode. - * The route is: PIT -> PIC -> LVT0 in NMI mode. - * - * Note: Our Virtual Wire implementation is simplified, only - * propagating PIT interrupts to all VCPUs when they have set - * LVT0 to NMI delivery. Other PIC interrupts are just sent to - * VCPU0, and only if its LVT0 is in EXTINT mode. - */ - if (kvm->arch.vapics_in_nmi_mode > 0) - kvm_for_each_vcpu(i, vcpu, kvm) - kvm_apic_nmi_wd_deliver(vcpu); -} - -void kvm_inject_pit_timer_irqs(struct kvm_vcpu *vcpu) -{ - struct kvm_pit *pit = vcpu->kvm->arch.vpit; - struct kvm *kvm = vcpu->kvm; - struct kvm_kpit_state *ps; - - if (vcpu && pit) { - int inject = 0; - ps = &pit->pit_state; - - /* Try to inject pending interrupts when - * last one has been acked. - */ - spin_lock(&ps->inject_lock); - if (kvm_timer_has_pending(&ps->pit_timer) && ps->irq_ack) { - ps->irq_ack = 0; - inject = 1; - } - spin_unlock(&ps->inject_lock); - if (inject) - __inject_pit_timer_intr(kvm); - } -} Index: kvm-new/arch/x86/kvm/lapic.c =================================================================== --- kvm-new.orig/arch/x86/kvm/lapic.c +++ kvm-new/arch/x86/kvm/lapic.c @@ -875,16 +875,6 @@ int kvm_lapic_enabled(struct kvm_vcpu *v *---------------------------------------------------------------------- */ -int apic_has_pending_timer(struct kvm_vcpu *vcpu) -{ - struct kvm_lapic *lapic = vcpu->arch.apic; - - if (lapic && apic_enabled(lapic) && apic_lvt_enabled(lapic, APIC_LVTT)) - return kvm_timer_has_pending(&lapic->lapic_timer); - - return 0; -} - static int kvm_apic_local_deliver(struct kvm_lapic *apic, int lvt_type) { u32 reg = apic_get_reg(apic, lvt_type); @@ -912,6 +902,20 @@ static const struct kvm_io_device_ops ap .write = apic_mmio_write, }; +void inject_lapic_timer(struct kvm_timer *ktimer) +{ + struct kvm_vcpu *vcpu = ktimer->vcpu; + struct kvm_lapic *apic = vcpu->arch.apic; + + if (apic) + kvm_apic_local_deliver(apic, APIC_LVTT); +} + +struct kvm_timer_ops lapic_timer_ops = { + .inject = inject_lapic_timer, + .name = "lapic", +}; + int kvm_create_lapic(struct kvm_vcpu *vcpu) { struct kvm_lapic *apic; @@ -935,7 +939,7 @@ int kvm_create_lapic(struct kvm_vcpu *vc memset(apic->regs, 0, PAGE_SIZE); apic->vcpu = vcpu; - kvm_timer_init(vcpu->kvm, &apic->lapic_timer); + kvm_timer_init(vcpu->kvm, &apic->lapic_timer, &lapic_timer_ops); kvm_timer_vcpu_bind(&apic->lapic_timer, vcpu); apic->base_address = APIC_DEFAULT_PHYS_BASE; @@ -982,14 +986,6 @@ int kvm_apic_accept_pic_intr(struct kvm_ return r; } -void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu) -{ - struct kvm_lapic *apic = vcpu->arch.apic; - - if (apic && kvm_timer_has_pending(&apic->lapic_timer)) - kvm_apic_local_deliver(apic, APIC_LVTT); -} - int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu) { int vector = kvm_apic_has_interrupt(vcpu); Index: kvm-new/arch/x86/include/asm/kvm_host.h =================================================================== --- kvm-new.orig/arch/x86/include/asm/kvm_host.h +++ kvm-new/arch/x86/include/asm/kvm_host.h @@ -377,6 +377,7 @@ struct kvm_vcpu_arch { u64 *mce_banks; struct list_head timers; + struct hrtimer exit_timer; }; struct kvm_mem_alias { @@ -800,4 +801,7 @@ int kvm_unmap_hva(struct kvm *kvm, unsig int kvm_age_hva(struct kvm *kvm, unsigned long hva); int cpuid_maxphyaddr(struct kvm_vcpu *vcpu); +#define KVM_ARCH_HAVE_TIMER_EVENT +ktime_t kvm_vcpu_next_timer_event(struct kvm_vcpu *vcpu); + #endif /* _ASM_X86_KVM_HOST_H */ Index: kvm-new/arch/x86/kvm/irq.c =================================================================== --- kvm-new.orig/arch/x86/kvm/irq.c +++ kvm-new/arch/x86/kvm/irq.c @@ -26,18 +26,19 @@ #include "i8254.h" #include "x86.h" -/* - * check if there are pending timer events - * to be processed. - */ int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) { - int ret; + ktime_t now, expires; - ret = pit_has_pending_timer(vcpu); - ret |= apic_has_pending_timer(vcpu); + expires = kvm_vcpu_next_timer_event(vcpu); + now = ktime_get(); + if (expires.tv64 <= now.tv64) { + if (kvm_arch_interrupt_allowed(vcpu)) + set_bit(KVM_REQ_UNHALT, &vcpu->requests); + return 1; + } - return ret; + return 0; } EXPORT_SYMBOL(kvm_cpu_has_pending_timer); @@ -86,36 +87,3 @@ int kvm_cpu_get_interrupt(struct kvm_vcp } EXPORT_SYMBOL_GPL(kvm_cpu_get_interrupt); -void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu) -{ - kvm_inject_apic_timer_irqs(vcpu); - kvm_inject_pit_timer_irqs(vcpu); - /* TODO: PIT, RTC etc. */ -} -EXPORT_SYMBOL_GPL(kvm_inject_pending_timer_irqs); - -static void __kvm_migrate_apic_timer(struct kvm_vcpu *vcpu) -{ - struct kvm_lapic *apic = vcpu->arch.apic; - - if (!apic) - return; - - kvm_migrate_timer(&apic->lapic_timer); -} - -static void __kvm_migrate_pit_timer(struct kvm_vcpu *vcpu) -{ - struct kvm_pit *pit = vcpu->kvm->arch.vpit; - - if (!kvm_vcpu_is_bsp(vcpu) || !pit) - return; - - kvm_migrate_timer(&pit->pit_state.pit_timer); -} - -void __kvm_migrate_timers(struct kvm_vcpu *vcpu) -{ - __kvm_migrate_apic_timer(vcpu); - __kvm_migrate_pit_timer(vcpu); -} Index: kvm-new/arch/x86/kvm/svm.c =================================================================== --- kvm-new.orig/arch/x86/kvm/svm.c +++ kvm-new/arch/x86/kvm/svm.c @@ -738,7 +738,6 @@ static void svm_vcpu_load(struct kvm_vcp delta = vcpu->arch.host_tsc - tsc_this; svm->vmcb->control.tsc_offset += delta; vcpu->cpu = cpu; - kvm_migrate_timers(vcpu); } for (i = 0; i < NR_HOST_SAVE_USER_MSRS; i++) Index: kvm-new/arch/x86/kvm/vmx.c =================================================================== --- kvm-new.orig/arch/x86/kvm/vmx.c +++ kvm-new/arch/x86/kvm/vmx.c @@ -703,7 +703,6 @@ static void vmx_vcpu_load(struct kvm_vcp if (vcpu->cpu != cpu) { vcpu_clear(vmx); - kvm_migrate_timers(vcpu); vpid_sync_vcpu_all(vmx); local_irq_disable(); list_add(&vmx->local_vcpus_link, Index: kvm-new/arch/x86/kvm/kvm_timer.h =================================================================== --- kvm-new.orig/arch/x86/kvm/kvm_timer.h +++ kvm-new/arch/x86/kvm/kvm_timer.h @@ -1,26 +1,41 @@ +struct kvm_timer_ops; struct kvm_timer { - struct hrtimer timer; - s64 period; /* unit: ns */ - atomic_t pending; /* accumulated triggered timers */ + ktime_t count_load_time; + ktime_t inject_time; + u64 period; /* unit: ns */ + u64 acked_events; + + bool can_inject; bool reinject; bool periodic; + struct kvm *kvm; struct kvm_vcpu *vcpu; struct list_head vcpu_timer; + struct kvm_timer_ops *ops; }; -void kvm_timer_init(struct kvm *kvm, struct kvm_timer *ktimer); +struct kvm_timer_ops { + void (*inject)(struct kvm_timer *); + char *name; +}; + +void kvm_timer_init(struct kvm *kvm, struct kvm_timer *ktimer, + struct kvm_timer_ops *ops); +void kvm_timer_vcpu_bind(struct kvm_timer *ktimer, struct kvm_vcpu *vcpu); void kvm_timer_start(struct kvm_timer *ktimer, u64 interval, bool periodic); void kvm_timer_cancel(struct kvm_timer *ktimer); -void kvm_timer_vcpu_bind(struct kvm_timer *ktimer, struct kvm_vcpu *vcpu); - int kvm_timer_has_pending(struct kvm_timer *ktimer); void kvm_timer_ack(struct kvm_timer *ktimer); void kvm_timer_reset(struct kvm_timer *ktimer); void kvm_migrate_timer(struct kvm_timer *ktimer); +void kvm_vcpu_init_armed_exit(struct kvm_vcpu *vcpu); -ktime_t kvm_timer_remaining(struct kvm_timer *ktimer); +void kvm_vcpu_arm_exit(struct kvm_vcpu *vcpu); +void kvm_vcpu_cleanup_timer(struct kvm_vcpu *vcpu); +ktime_t kvm_timer_next_event(struct kvm_timer *ktimer); +ktime_t kvm_timer_remaining(struct kvm_timer *ktimer); Index: kvm-new/arch/x86/kvm/timer.c =================================================================== --- kvm-new.orig/arch/x86/kvm/timer.c +++ kvm-new/arch/x86/kvm/timer.c @@ -1,107 +1,176 @@ +/* + * + * Copyright (C) 2009 Red Hat, Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ + #include <linux/kvm_host.h> #include <linux/kvm.h> #include <linux/hrtimer.h> #include <asm/atomic.h> #include "kvm_timer.h" -static int __kvm_timer_fn(struct kvm_vcpu *vcpu, struct kvm_timer *ktimer) -{ - int restart_timer = 0; - wait_queue_head_t *q = &vcpu->wq; - - /* - * There is a race window between reading and incrementing, but we do - * not care about potentially loosing timer events in the !reinject - * case anyway. - */ - if (ktimer->reinject || !atomic_read(&ktimer->pending)) { - atomic_inc(&ktimer->pending); - /* FIXME: this code should not know anything about vcpus */ - set_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests); - } - - if (waitqueue_active(q)) - wake_up_interruptible(q); - - if (ktimer->periodic) { - hrtimer_add_expires_ns(&ktimer->timer, ktimer->period); - restart_timer = 1; - } - - return restart_timer; -} - -static enum hrtimer_restart kvm_timer_fn(struct hrtimer *data) -{ - int restart_timer; - struct kvm_vcpu *vcpu; - struct kvm_timer *ktimer = container_of(data, struct kvm_timer, timer); - - vcpu = ktimer->vcpu; - if (!vcpu) - return HRTIMER_NORESTART; - - restart_timer = __kvm_timer_fn(vcpu, ktimer); - if (restart_timer) - return HRTIMER_RESTART; - else - return HRTIMER_NORESTART; -} -void kvm_timer_init(struct kvm *kvm, struct kvm_timer *ktimer) +void kvm_timer_init(struct kvm *kvm, struct kvm_timer *ktimer, + struct kvm_timer_ops *ops) { ktimer->kvm = kvm; - hrtimer_init(&ktimer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); - ktimer->timer.function = kvm_timer_fn; INIT_LIST_HEAD(&ktimer->vcpu_timer); + ktimer->ops = ops; + ktimer->can_inject = false; } void kvm_timer_vcpu_bind(struct kvm_timer *ktimer, struct kvm_vcpu *vcpu) { ktimer->vcpu = vcpu; - list_add(&ktimer->vcpu_timer, &vcpu->arch.timers); } void kvm_timer_start(struct kvm_timer *ktimer, u64 interval, bool periodic) { - hrtimer_cancel(&ktimer->timer); - atomic_set(&ktimer->pending, 0); ktimer->periodic = periodic; ktimer->period = interval; - hrtimer_start(&ktimer->timer, ktime_add_ns(ktime_get(), interval), - HRTIMER_MODE_ABS); + ktimer->count_load_time = ktime_get(); + ktimer->acked_events = 0; + ktimer->can_inject = true; + + WARN_ON(interval == 0); + + list_add(&ktimer->vcpu_timer, &ktimer->vcpu->arch.timers); } void kvm_timer_cancel(struct kvm_timer *ktimer) { - hrtimer_cancel(&ktimer->timer); - atomic_set(&ktimer->pending, 0); + if (!list_empty(&ktimer->vcpu_timer)) + list_del_init(&ktimer->vcpu_timer); } -int kvm_timer_has_pending(struct kvm_timer *ktimer) +void kvm_timer_reset(struct kvm_timer *ktimer) { - return atomic_read(&ktimer->pending); + ktimer->can_inject = true; } void kvm_timer_ack(struct kvm_timer *ktimer) { - if (atomic_dec_return(&ktimer->pending) < 0) - atomic_inc(&ktimer->pending); + ktimer->acked_events++; + ktimer->can_inject = true; } -void kvm_timer_reset(struct kvm_timer *ktimer) +static ktime_t periodic_timer_next_event(struct kvm_timer *ktimer) { - atomic_set(&ktimer->pending, 0); + ktime_t last_acked_event; + + last_acked_event = ktime_add_ns(ktimer->count_load_time, + ktimer->acked_events * ktimer->period); + + return ktime_add_ns(last_acked_event, ktimer->period); } -void kvm_migrate_timer(struct kvm_timer *ktimer) +ktime_t kvm_timer_next_event(struct kvm_timer *ktimer) { - if (hrtimer_cancel(&ktimer->timer)) - hrtimer_start_expires(&ktimer->timer, HRTIMER_MODE_ABS); + if (!ktimer->periodic) + return ktime_add_ns(ktimer->count_load_time, ktimer->period); + else + return periodic_timer_next_event(ktimer); } ktime_t kvm_timer_remaining(struct kvm_timer *ktimer) { - return hrtimer_expires_remaining(&ktimer->timer); + ktime_t now = ktime_get(); + + return ktime_sub(kvm_timer_next_event(ktimer), now); } +struct kvm_timer *kvm_vcpu_injectable_timer_event(struct kvm_vcpu *vcpu) +{ + struct kvm_timer *ktimer, *ktimer_expire = NULL; + ktime_t expires = { .tv64 = KTIME_MAX }; + + list_for_each_entry(ktimer, &vcpu->arch.timers, vcpu_timer) { + ktime_t this_expires = { .tv64 = KTIME_MAX }; + + if (ktimer->can_inject) + this_expires = kvm_timer_next_event(ktimer); + + if (this_expires.tv64 < expires.tv64) { + expires = this_expires; + ktimer_expire = ktimer; + } + } + + return ktimer_expire; +} + +/* + * when the next vcpu timer expires, in host timebase. + */ +ktime_t kvm_vcpu_next_timer_event(struct kvm_vcpu *vcpu) +{ + ktime_t expires = { .tv64 = KTIME_MAX }; + struct kvm_timer *ktimer = kvm_vcpu_injectable_timer_event(vcpu); + + if (!ktimer) + return expires; + + return kvm_timer_next_event(ktimer); +} + +void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu) +{ + struct kvm_timer *ktimer, *n; + ktime_t now = ktime_get(); + + list_for_each_entry_safe(ktimer, n, &vcpu->arch.timers, vcpu_timer) { + ktime_t expire; + + if (!ktimer->can_inject) + continue; + + expire = kvm_timer_next_event(ktimer); + if (ktime_to_ns(now) < ktime_to_ns(expire)) + continue; + + ktimer->can_inject = false; + ktimer->ops->inject(ktimer); + if (!ktimer->periodic) + list_del_init(&ktimer->vcpu_timer); + } +} + +/* arm/disarm exit */ + +static enum hrtimer_restart kvm_timer_fn(struct hrtimer *data) +{ + return HRTIMER_NORESTART; +} + +void kvm_vcpu_init_armed_exit(struct kvm_vcpu *vcpu) +{ + hrtimer_init(&vcpu->arch.exit_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS); + vcpu->arch.exit_timer.function = kvm_timer_fn; +} + +void kvm_vcpu_arm_exit(struct kvm_vcpu *vcpu) +{ + ktime_t expire; + ktime_t now; + struct kvm_timer *ktimer = kvm_vcpu_injectable_timer_event(vcpu); + + if (!ktimer) + return; + + now = ktime_get(); + expire = kvm_timer_next_event(ktimer); + + if (expire.tv64 != KTIME_MAX) + hrtimer_start(&vcpu->arch.exit_timer, expire, HRTIMER_MODE_ABS); +} + +void kvm_vcpu_cleanup_timer(struct kvm_vcpu *vcpu) +{ + hrtimer_cancel(&vcpu->arch.exit_timer); +} + + Index: kvm-new/arch/x86/kvm/irq.h =================================================================== --- kvm-new.orig/arch/x86/kvm/irq.h +++ kvm-new/arch/x86/kvm/irq.h @@ -94,9 +94,5 @@ void kvm_pic_reset(struct kvm_kpic_state void kvm_inject_pending_timer_irqs(struct kvm_vcpu *vcpu); void kvm_inject_apic_timer_irqs(struct kvm_vcpu *vcpu); void kvm_apic_nmi_wd_deliver(struct kvm_vcpu *vcpu); -void __kvm_migrate_timers(struct kvm_vcpu *vcpu); - -int pit_has_pending_timer(struct kvm_vcpu *vcpu); -int apic_has_pending_timer(struct kvm_vcpu *vcpu); #endif Index: kvm-new/include/linux/kvm_host.h =================================================================== --- kvm-new.orig/include/linux/kvm_host.h +++ kvm-new/include/linux/kvm_host.h @@ -30,15 +30,14 @@ * vcpu->requests bit members */ #define KVM_REQ_TLB_FLUSH 0 -#define KVM_REQ_MIGRATE_TIMER 1 -#define KVM_REQ_REPORT_TPR_ACCESS 2 -#define KVM_REQ_MMU_RELOAD 3 -#define KVM_REQ_TRIPLE_FAULT 4 -#define KVM_REQ_PENDING_TIMER 5 -#define KVM_REQ_UNHALT 6 -#define KVM_REQ_MMU_SYNC 7 -#define KVM_REQ_KVMCLOCK_UPDATE 8 -#define KVM_REQ_KICK 9 +#define KVM_REQ_REPORT_TPR_ACCESS 1 +#define KVM_REQ_MMU_RELOAD 2 +#define KVM_REQ_TRIPLE_FAULT 3 +#define KVM_REQ_PENDING_TIMER 4 +#define KVM_REQ_UNHALT 5 +#define KVM_REQ_MMU_SYNC 6 +#define KVM_REQ_KVMCLOCK_UPDATE 7 +#define KVM_REQ_KICK 8 #define KVM_USERSPACE_IRQ_SOURCE_ID 0 @@ -469,11 +468,6 @@ static inline hpa_t pfn_to_hpa(pfn_t pfn return (hpa_t)pfn << PAGE_SHIFT; } -static inline void kvm_migrate_timers(struct kvm_vcpu *vcpu) -{ - set_bit(KVM_REQ_MIGRATE_TIMER, &vcpu->requests); -} - enum kvm_stat_kind { KVM_STAT_VM, KVM_STAT_VCPU, -- -- To unsubscribe from this list: send the line "unsubscribe kvm" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
