3 files changed, 278 insertions, 145 deletions

diff --git a/include/kvm/arm_arch_timer.h b/include/kvm/arm_arch_timer.h
index 6d4a33a9c45a..05a18dd265b5 100644
--- a/include/kvm/arm_arch_timer.h
+++ b/include/kvm/arm_arch_timer.h
@@ -51,11 +51,24 @@ struct arch_timer_context {
         /* Emulated Timer (may be unused) */
         struct hrtimer                  hrtimer;
 
+        /*
+         * We have multiple paths which can save/restore the timer state onto
+         * the hardware, so we need some way of keeping track of where the
+         * latest state is.
+         */
+        bool                            loaded;
+
         /* Duplicated state from arch_timer.c for convenience */
         u32                             host_timer_irq;
         u32                             host_timer_irq_flags;
 };
 
+struct timer_map {
+        struct arch_timer_context *direct_vtimer;
+        struct arch_timer_context *direct_ptimer;
+        struct arch_timer_context *emul_ptimer;
+};
+
 struct arch_timer_cpu {
         struct arch_timer_context timers[NR_KVM_TIMERS];
 
@@ -64,16 +77,6 @@ struct arch_timer_cpu {
 
         /* Is the timer enabled */
         bool                    enabled;
-
-        /*
-         * We have multiple paths which can save/restore the timer state
-         * onto the hardware, so we need some way of keeping track of
-         * where the latest state is.
-         *
-         * loaded == true:  State is loaded on the hardware registers.
-         * loaded == false: State is stored in memory.
-         */
-        bool                    loaded;
 };
 
 int kvm_timer_hyp_init(bool);
diff --git a/virt/kvm/arm/arch_timer.c b/virt/kvm/arm/arch_timer.c
index 10c15151c87e..17f9de73cc8a 100644
--- a/virt/kvm/arm/arch_timer.c
+++ b/virt/kvm/arm/arch_timer.c
@@ -68,6 +68,21 @@ u64 kvm_phys_timer_read(void)
         return timecounter->cc->read(timecounter->cc);
 }
 
+static void get_timer_map(struct kvm_vcpu *vcpu, struct timer_map *map)
+{
+        if (has_vhe()) {
+                map->direct_vtimer = vcpu_vtimer(vcpu);
+                map->direct_ptimer = vcpu_ptimer(vcpu);
+                map->emul_ptimer = NULL;
+        } else {
+                map->direct_vtimer = vcpu_vtimer(vcpu);
+                map->direct_ptimer = NULL;
+                map->emul_ptimer = vcpu_ptimer(vcpu);
+        }
+
+        trace_kvm_get_timer_map(vcpu->vcpu_id, map);
+}
+
 static inline bool userspace_irqchip(struct kvm *kvm)
 {
         return static_branch_unlikely(&userspace_irqchip_in_use) &&
@@ -89,6 +104,7 @@ static irqreturn_t kvm_arch_timer_handler(int irq, void *dev_id)
 {
         struct kvm_vcpu *vcpu = *(struct kvm_vcpu **)dev_id;
         struct arch_timer_context *ctx;
+        struct timer_map map;
 
         /*
          * We may see a timer interrupt after vcpu_put() has been called which
@@ -99,10 +115,12 @@ static irqreturn_t kvm_arch_timer_handler(int irq, void *dev_id)
         if (!vcpu)
                 return IRQ_HANDLED;
 
+        get_timer_map(vcpu, &map);
+
         if (irq == host_vtimer_irq)
-                ctx = vcpu_vtimer(vcpu);
+                ctx = map.direct_vtimer;
         else
-                ctx = vcpu_ptimer(vcpu);
+                ctx = map.direct_ptimer;
 
         if (kvm_timer_should_fire(ctx))
                 kvm_timer_update_irq(vcpu, true, ctx);
@@ -136,7 +154,9 @@ static u64 kvm_timer_compute_delta(struct arch_timer_context *timer_ctx)
 
 static bool kvm_timer_irq_can_fire(struct arch_timer_context *timer_ctx)
 {
-        return !(timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
+        WARN_ON(timer_ctx && timer_ctx->loaded);
+        return timer_ctx &&
+               !(timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_IT_MASK) &&
                 (timer_ctx->cnt_ctl & ARCH_TIMER_CTRL_ENABLE);
 }
 
@@ -146,21 +166,22 @@ static bool kvm_timer_irq_can_fire(struct arch_timer_context *timer_ctx)
  */
 static u64 kvm_timer_earliest_exp(struct kvm_vcpu *vcpu)
 {
-        u64 min_virt = ULLONG_MAX, min_phys = ULLONG_MAX;
-        struct arch_timer_context *vtimer = vcpu_vtimer(vcpu);
-        struct arch_timer_context *ptimer = vcpu_ptimer(vcpu);
+        u64 min_delta = ULLONG_MAX;
+        int i;
 
-        if (kvm_timer_irq_can_fire(vtimer))
-                min_virt = kvm_timer_compute_delta(vtimer);
+        for (i = 0; i < NR_KVM_TIMERS; i++) {
+                struct arch_timer_context *ctx = &vcpu->arch.timer_cpu.timers[i];
 
-        if (kvm_timer_irq_can_fire(ptimer))
-                min_phys = kvm_timer_compute_delta(ptimer);
+                WARN(ctx->loaded, "timer %d loaded\n", i);
+                if (kvm_timer_irq_can_fire(ctx))
+                        min_delta = min(min_delta, kvm_timer_compute_delta(ctx));
+        }
 
         /* If none of timers can fire, then return 0 */
-        if ((min_virt == ULLONG_MAX) && (min_phys == ULLONG_MAX))
+        if (min_delta == ULLONG_MAX)
                 return 0;
 
-        return min(min_virt, min_phys);
+        return min_delta;
 }
 
 static enum hrtimer_restart kvm_bg_timer_expire(struct hrtimer *hrt)
@@ -187,37 +208,45 @@ static enum hrtimer_restart kvm_bg_timer_expire(struct hrtimer *hrt)
         return HRTIMER_NORESTART;
 }
 
-static enum hrtimer_restart kvm_phys_timer_expire(struct hrtimer *hrt)
+static enum hrtimer_restart kvm_hrtimer_expire(struct hrtimer *hrt)
 {
-        struct arch_timer_context *ptimer;
+        struct arch_timer_context *ctx;
         struct kvm_vcpu *vcpu;
         u64 ns;
 
-        ptimer = container_of(hrt, struct arch_timer_context, hrtimer);
-        vcpu = ptimer->vcpu;
+        ctx = container_of(hrt, struct arch_timer_context, hrtimer);
+        vcpu = ctx->vcpu;
+
+        trace_kvm_timer_hrtimer_expire(ctx);
 
         /*
          * Check that the timer has really expired from the guest's
          * PoV (NTP on the host may have forced it to expire
          * early). If not ready, schedule for a later time.
          */
-        ns = kvm_timer_compute_delta(ptimer);
+        ns = kvm_timer_compute_delta(ctx);
         if (unlikely(ns)) {
                 hrtimer_forward_now(hrt, ns_to_ktime(ns));
                 return HRTIMER_RESTART;
         }
 
-        kvm_timer_update_irq(vcpu, true, ptimer);
+        kvm_timer_update_irq(vcpu, true, ctx);
         return HRTIMER_NORESTART;
 }
 
 static bool kvm_timer_should_fire(struct arch_timer_context *timer_ctx)
 {
-        struct arch_timer_cpu *timer = vcpu_timer(timer_ctx->vcpu);
-        enum kvm_arch_timers index = arch_timer_ctx_index(timer_ctx);
+        struct arch_timer_cpu *timer;
+        enum kvm_arch_timers index;
         u64 cval, now;