On Thu, Sep 03, 2015 at 03:43:19PM +0100, Marc Zyngier wrote:
> On 30/08/15 14:54, Christoffer Dall wrote:
> > We currently schedule a soft timer every time we exit the guest if the
> > timer did not expire while running the guest. This is really not
> > necessary, because the only work we do in the timer work function is to
> > kick the vcpu.
> >
> > Kicking the vcpu does two things:
> > (1) If the vpcu thread is on a waitqueue, make it runnable and remove it
> > from the waitqueue.
> > (2) If the vcpu is running on a different physical CPU from the one
> > doing the kick, it sends a reschedule IPI.
> >
> > The second case cannot happen, because the soft timer is only ever
> > scheduled when the vcpu is not running. The first case is only relevant
> > when the vcpu thread is on a waitqueue, which is only the case when the
> > vcpu thread has called kvm_vcpu_block().
> >
> > Therefore, we only need to make sure a timer is scheduled for
> > kvm_vcpu_block(), which we do by encapsulating all calls to
> > kvm_vcpu_block() with kvm_timer_{un}schedule calls.
> >
> > Additionally, we only schedule a soft timer if the timer is enabled and
> > unmasked, since it is useless otherwise.
> >
> > Note that theoretically userspace can use the SET_ONE_REG interface to
> > change registers that should cause the timer to fire, even if the vcpu
> > is blocked without a scheduled timer, but this case was not supported
> > before this patch and we leave it for future work for now.
> >
> > Signed-off-by: Christoffer Dall <[email protected]>
> > ---
> > arch/arm/include/asm/kvm_host.h | 3 --
> > arch/arm/kvm/arm.c | 10 +++++
> > arch/arm64/include/asm/kvm_host.h | 3 --
> > include/kvm/arm_arch_timer.h | 2 +
> > virt/kvm/arm/arch_timer.c | 89
> > +++++++++++++++++++++++++--------------
> > 5 files changed, 70 insertions(+), 37 deletions(-)
> >
> > diff --git a/arch/arm/include/asm/kvm_host.h
> > b/arch/arm/include/asm/kvm_host.h
> > index 86fcf6e..dcba0fa 100644
> > --- a/arch/arm/include/asm/kvm_host.h
> > +++ b/arch/arm/include/asm/kvm_host.h
> > @@ -236,7 +236,4 @@ static inline void kvm_arm_setup_debug(struct kvm_vcpu
> > *vcpu) {}
> > static inline void kvm_arm_clear_debug(struct kvm_vcpu *vcpu) {}
> > static inline void kvm_arm_reset_debug_ptr(struct kvm_vcpu *vcpu) {}
> >
> > -static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu) {}
> > -static inline void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu) {}
> > -
> > #endif /* __ARM_KVM_HOST_H__ */
> > diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c
> > index ce404a5..bdf8871 100644
> > --- a/arch/arm/kvm/arm.c
> > +++ b/arch/arm/kvm/arm.c
> > @@ -271,6 +271,16 @@ int kvm_cpu_has_pending_timer(struct kvm_vcpu *vcpu)
> > return kvm_timer_should_fire(vcpu);
> > }
> >
> > +void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu)
> > +{
> > + kvm_timer_schedule(vcpu);
> > +}
> > +
> > +void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu)
> > +{
> > + kvm_timer_unschedule(vcpu);
> > +}
> > +
> > int kvm_arch_vcpu_init(struct kvm_vcpu *vcpu)
> > {
> > /* Force users to call KVM_ARM_VCPU_INIT */
> > diff --git a/arch/arm64/include/asm/kvm_host.h
> > b/arch/arm64/include/asm/kvm_host.h
> > index dd143f5..415938d 100644
> > --- a/arch/arm64/include/asm/kvm_host.h
> > +++ b/arch/arm64/include/asm/kvm_host.h
> > @@ -257,7 +257,4 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu);
> > void kvm_arm_clear_debug(struct kvm_vcpu *vcpu);
> > void kvm_arm_reset_debug_ptr(struct kvm_vcpu *vcpu);
> >
> > -static inline void kvm_arch_vcpu_blocking(struct kvm_vcpu *vcpu) {}
> > -static inline void kvm_arch_vcpu_unblocking(struct kvm_vcpu *vcpu) {}
> > -
> > #endif /* __ARM64_KVM_HOST_H__ */
> > diff --git a/include/kvm/arm_arch_timer.h b/include/kvm/arm_arch_timer.h
> > index e1e4d7c..ef14cc1 100644
> > --- a/include/kvm/arm_arch_timer.h
> > +++ b/include/kvm/arm_arch_timer.h
> > @@ -71,5 +71,7 @@ u64 kvm_arm_timer_get_reg(struct kvm_vcpu *, u64 regid);
> > int kvm_arm_timer_set_reg(struct kvm_vcpu *, u64 regid, u64 value);
> >
> > bool kvm_timer_should_fire(struct kvm_vcpu *vcpu);
> > +void kvm_timer_schedule(struct kvm_vcpu *vcpu);
> > +void kvm_timer_unschedule(struct kvm_vcpu *vcpu);
> >
> > #endif
> > diff --git a/virt/kvm/arm/arch_timer.c b/virt/kvm/arm/arch_timer.c
> > index 76e38d2..018f3d6 100644
> > --- a/virt/kvm/arm/arch_timer.c
> > +++ b/virt/kvm/arm/arch_timer.c
> > @@ -111,14 +111,21 @@ static enum hrtimer_restart kvm_timer_expire(struct
> > hrtimer *hrt)
> > return HRTIMER_NORESTART;
> > }
> >
> > +static bool kvm_timer_irq_enabled(struct kvm_vcpu *vcpu)
> > +{
> > + struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
> > +
> > + return !(timer->cntv_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
> > + (timer->cntv_ctl & ARCH_TIMER_CTRL_ENABLE) &&
> > + !kvm_vgic_get_phys_irq_active(timer->map);
> > +}
>
> Nit: To me, this is not a predicate for "IRQ enabled", but "IRQ can
> fire" instead, which seems to complement the kvm_timer_should_fire just
> below.
>
so you're suggesting kvm_timer_irq_can_fire (or
kvm_timer_irq_could_file) or something else?
> > +
> > bool kvm_timer_should_fire(struct kvm_vcpu *vcpu)
> > {
> > struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
> > cycle_t cval, now;
> >
> > - if ((timer->cntv_ctl & ARCH_TIMER_CTRL_IT_MASK) ||
> > - !(timer->cntv_ctl & ARCH_TIMER_CTRL_ENABLE) ||
> > - kvm_vgic_get_phys_irq_active(timer->map))
> > + if (!kvm_timer_irq_enabled(vcpu))
> > return false;
> >
> > cval = timer->cntv_cval;
> > @@ -127,24 +134,59 @@ bool kvm_timer_should_fire(struct kvm_vcpu *vcpu)
> > return cval <= now;
> > }
> >
> > -/**
> > - * kvm_timer_flush_hwstate - prepare to move the virt timer to the cpu
> > - * @vcpu: The vcpu pointer
> > - *
> > - * Disarm any pending soft timers, since the world-switch code will write
> > the
> > - * virtual timer state back to the physical CPU.
> > +/*
> > + * Schedule the background timer before calling kvm_vcpu_block, so that
> > this
> > + * thread is removed from its waitqueue and made runnable when there's a
> > timer
> > + * interrupt to handle.
> > */
> > -void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
> > +void kvm_timer_schedule(struct kvm_vcpu *vcpu)
> > {
> > struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
> > + u64 ns;
> > + cycle_t cval, now;
> > +
> > + /*
> > + * No need to schedule a background timer if the guest timer has
> > + * already expired, because kvm_vcpu_block will return before putting
> > + * the thread to sleep.
> > + */
> > + if (kvm_timer_should_fire(vcpu))
> > + return;
> >
> > /*
> > - * We're about to run this vcpu again, so there is no need to
> > - * keep the background timer running, as we're about to
> > - * populate the CPU timer again.
> > + * If the timer is either not capable of raising interrupts (disabled
> > + * or masked) or if we already have a background timer, then there's
> > + * no more work for us to do.
> > */
> > + if (!kvm_timer_irq_enabled(vcpu) || timer_is_armed(timer))
> > + return;
>
> Do we need to retest kvm_timer_irq_enabled here? It is already implied
> by kvm_timer_should_fire...
>
yes we do, when we reach this if statement there are two cases:
(1) kvm_timer_irq_enabled == true but cval > now
(2) kvm_timer_irq_enabled == false
We hould only schedule a timer in in case (1), which happens exactly
when kvm_timer_irq_enabled == true, hence the return on the opposite.
Does that make sense?
> > +
> > + /* The timer has not yet expired, schedule a background timer */
> > + cval = timer->cntv_cval;
> > + now = kvm_phys_timer_read() - vcpu->kvm->arch.timer.cntvoff;
> > +
> > + ns = cyclecounter_cyc2ns(timecounter->cc,
> > + cval - now,
> > + timecounter->mask,
> > + &timecounter->frac);
> > + timer_arm(timer, ns);
> > +}
> > +
> > +void kvm_timer_unschedule(struct kvm_vcpu *vcpu)
> > +{
> > + struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
> > timer_disarm(timer);
> > +}
> >
> > +/**
> > + * kvm_timer_flush_hwstate - prepare to move the virt timer to the cpu
> > + * @vcpu: The vcpu pointer
> > + *
> > + * Check if the virtual timer has expired while we were running in the
> > host,
> > + * and inject an interrupt if that was the case.
> > + */
> > +void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
> > +{
> > /*
> > * If the timer expired while we were not scheduled, now is the time
> > * to inject it.
> > @@ -157,32 +199,17 @@ void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
> > * kvm_timer_sync_hwstate - sync timer state from cpu
> > * @vcpu: The vcpu pointer
> > *
> > - * Check if the virtual timer was armed and either schedule a corresponding
> > - * soft timer or inject directly if already expired.
> > + * Check if the virtual timer has expired while we werer running in the
> > guest,
>
> s/werer/were/
>
> > + * and inject an interrupt if that was the case.
> > */
> > void kvm_timer_sync_hwstate(struct kvm_vcpu *vcpu)
> > {
> > struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
> > - cycle_t cval, now;
> > - u64 ns;
> >
> > BUG_ON(timer_is_armed(timer));
> >
> > - if (kvm_timer_should_fire(vcpu)) {
> > - /*
> > - * Timer has already expired while we were not
> > - * looking. Inject the interrupt and carry on.
> > - */
> > + if (kvm_timer_should_fire(vcpu))
> > kvm_timer_inject_irq(vcpu);
> > - return;
> > - }
> > -
> > - cval = timer->cntv_cval;
> > - now = kvm_phys_timer_read() - vcpu->kvm->arch.timer.cntvoff;
> > -
> > - ns = cyclecounter_cyc2ns(timecounter->cc, cval - now, timecounter->mask,
> > - &timecounter->frac);
> > - timer_arm(timer, ns);
> > }
> >
> > int kvm_timer_vcpu_reset(struct kvm_vcpu *vcpu,
> >
>
> Apart from the few comments above, looks pretty good.
>
> M.
> --
> Jazz is not dead. It just smells funny...
--
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
