korg/linux
0
0
Fork 0
mirror of https://mirrors.bfsu.edu.cn/git/linux.git synced 2024-11-24 20:54:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

KVM: arm/arm64: Decouple kvm timer functions from virtual timer

Browse Source 
Now that we have a separate structure for timer context, make functions
generic so that they can work with any timer context, not just the
virtual timer context.  This does not change the virtual timer
functionality.

Signed-off-by: Jintack Lim <jintack@cs.columbia.edu>
Acked-by: Marc Zyngier <marc.zyngier@arm.com>
Acked-by: Christoffer Dall <christoffer.dall@linaro.org>
Signed-off-by: Marc Zyngier <marc.zyngier@arm.com>
This commit is contained in:
Jintack Lim 2017-02-03 10:20:01 -05:00 committed by Marc Zyngier
parent 90de943a43
commit 9171fa2e09
3 changed files with 27 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
arch/arm/kvm/arm.c
View File

@ -300,7 +300,7 @@ void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu)
int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu) int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
{ {
return kvm_timer_should_fire(vcpu); return kvm_timer_should_fire(vcpu_vtimer(vcpu));
} }
void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu) void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)

2
include/kvm/arm_arch_timer.h
View File

@ -66,7 +66,7 @@ void kvm_timer_vcpu_terminate(struct kvm_vcpu *vcpu);
u64 kvm_arm_timer_get_reg(struct kvm_vcpu *, u64 regid); u64 kvm_arm_timer_get_reg(struct kvm_vcpu *, u64 regid);
int kvm_arm_timer_set_reg(struct kvm_vcpu *, u64 regid, u64 value); int kvm_arm_timer_set_reg(struct kvm_vcpu *, u64 regid, u64 value);
bool kvm_timer_should_fire(struct kvm_vcpu *vcpu); bool kvm_timer_should_fire(struct arch_timer_context *timer_ctx);
void kvm_timer_schedule(struct kvm_vcpu *vcpu); void kvm_timer_schedule(struct kvm_vcpu *vcpu);
void kvm_timer_unschedule(struct kvm_vcpu *vcpu); void kvm_timer_unschedule(struct kvm_vcpu *vcpu);

54
virt/kvm/arm/arch_timer.c
View File

@ -98,13 +98,12 @@ static void kvm_timer_inject_irq_work(struct work_struct *work)
kvm_vcpu_kick(vcpu); kvm_vcpu_kick(vcpu);
} }
static u64 kvm_timer_compute_delta(struct kvm_vcpu *vcpu) static u64 kvm_timer_compute_delta(struct arch_timer_context *timer_ctx)
{ {
u64 cval, now; u64 cval, now;
struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
cval = vtimer->cnt_cval; cval = timer_ctx->cnt_cval;
now = kvm_phys_timer_read() - vtimer->cntvoff; now = kvm_phys_timer_read() - timer_ctx->cntvoff;
if (now < cval) { if (now < cval) {
u64 ns; u64 ns;
@ -133,7 +132,7 @@ static enum hrtimer_restart kvm_timer_expire(struct hrtimer *hrt)
* PoV (NTP on the host may have forced it to expire * PoV (NTP on the host may have forced it to expire
* early). If we should have slept longer, restart it. * early). If we should have slept longer, restart it.
*/ */
ns = kvm_timer_compute_delta(vcpu); ns = kvm_timer_compute_delta(vcpu_vtimer(vcpu));
if (unlikely(ns)) { if (unlikely(ns)) {
hrtimer_forward_now(hrt, ns_to_ktime(ns)); hrtimer_forward_now(hrt, ns_to_ktime(ns));
return HRTIMER_RESTART; return HRTIMER_RESTART;
@ -143,43 +142,39 @@ static enum hrtimer_restart kvm_timer_expire(struct hrtimer *hrt)
return HRTIMER_NORESTART; return HRTIMER_NORESTART;
} }
static bool kvm_timer_irq_can_fire(struct kvm_vcpu *vcpu) static bool kvm_timer_irq_can_fire(struct arch_timer_context *timer_ctx)
{ {
struct arch_timer_context *vtimer = vcpu_vtimer(vcpu); return !(timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
(timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_ENABLE);
return !(vtimer->cnt_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
(vtimer->cnt_ctl & ARCH_TIMER_CTRL_ENABLE);
} }
bool kvm_timer_should_fire(struct kvm_vcpu *vcpu) bool kvm_timer_should_fire(struct arch_timer_context *timer_ctx)
{ {
struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
u64 cval, now; u64 cval, now;
if (!kvm_timer_irq_can_fire(vcpu)) if (!kvm_timer_irq_can_fire(timer_ctx))
return false; return false;
cval = vtimer->cnt_cval; cval = timer_ctx->cnt_cval;
now = kvm_phys_timer_read() - vtimer->cntvoff; now = kvm_phys_timer_read() - timer_ctx->cntvoff;
return cval <= now; return cval <= now;
} }
static void kvm_timer_update_irq(struct kvm_vcpu *vcpu, bool new_level) static void kvm_timer_update_irq(struct kvm_vcpu *vcpu, bool new_level,
struct arch_timer_context *timer_ctx)
{ {
int ret; int ret;
struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
BUG_ON(!vgic_initialized(vcpu->kvm)); BUG_ON(!vgic_initialized(vcpu->kvm));
vtimer->active_cleared_last = false; timer_ctx->active_cleared_last = false;
vtimer->irq.level = new_level; timer_ctx->irq.level = new_level;
trace_kvm_timer_update_irq(vcpu->vcpu_id, vtimer->irq.irq, trace_kvm_timer_update_irq(vcpu->vcpu_id, timer_ctx->irq.irq,
vtimer->irq.level); timer_ctx->irq.level);
ret = kvm_vgic_inject_irq(vcpu->kvm, vcpu->vcpu_id, ret = kvm_vgic_inject_irq(vcpu->kvm, vcpu->vcpu_id, timer_ctx->irq.irq,
vtimer->irq.irq, timer_ctx->irq.level);
vtimer->irq.level);
WARN_ON(ret); WARN_ON(ret);
} }
@ -201,8 +196,8 @@ static int kvm_timer_update_state(struct kvm_vcpu *vcpu)
if (!vgic_initialized(vcpu->kvm) || !timer->enabled) if (!vgic_initialized(vcpu->kvm) || !timer->enabled)
return -ENODEV; return -ENODEV;
if (kvm_timer_should_fire(vcpu) != vtimer->irq.level) if (kvm_timer_should_fire(vtimer) != vtimer->irq.level)
kvm_timer_update_irq(vcpu, !vtimer->irq.level); kvm_timer_update_irq(vcpu, !vtimer->irq.level, vtimer);
return 0; return 0;
} }
@ -215,6 +210,7 @@ static int kvm_timer_update_state(struct kvm_vcpu *vcpu)
void kvm_timer_schedule(struct kvm_vcpu *vcpu) void kvm_timer_schedule(struct kvm_vcpu *vcpu)
{ {
struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu; struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
BUG_ON(timer_is_armed(timer)); BUG_ON(timer_is_armed(timer));
@ -223,18 +219,18 @@ void kvm_timer_schedule(struct kvm_vcpu *vcpu)
* already expired, because kvm_vcpu_block will return before putting * already expired, because kvm_vcpu_block will return before putting
* the thread to sleep. * the thread to sleep.
*/ */
if (kvm_timer_should_fire(vcpu)) if (kvm_timer_should_fire(vtimer))
return; return;
/* /*
* If the timer is not capable of raising interrupts (disabled or * If the timer is not capable of raising interrupts (disabled or
* masked), then there's no more work for us to do. * masked), then there's no more work for us to do.
*/ */
if (!kvm_timer_irq_can_fire(vcpu)) if (!kvm_timer_irq_can_fire(vtimer))
return; return;
/* The timer has not yet expired, schedule a background timer */ /* The timer has not yet expired, schedule a background timer */
timer_arm(timer, kvm_timer_compute_delta(vcpu)); timer_arm(timer, kvm_timer_compute_delta(vtimer));
} }
void kvm_timer_unschedule(struct kvm_vcpu *vcpu) void kvm_timer_unschedule(struct kvm_vcpu *vcpu)