LoongArch: KVM: Fix timer emulation with oneshot mode

When timer is fired in oneshot mode, CSR TVAL will be -1 rather than 0.
There needs special handing for this situation. There are two scenarios
when oneshot timer is fired. One scenario is that time is fired after
exiting to host, CSR TVAL is set with 0 in order to inject hw interrupt,
and -1 will assigned to CSR TVAL soon.

The other situation is that timer is fired in VM and guest kernel is
hanlding timer IRQ, IRQ is acked and is ready to set next expired timer
value, then vm exits to host. Timer interrupt should not be inject at
this point, else there will be spurious timer interrupt.

Here hw timer irq status in CSR ESTAT is used to judge these two
scenarios. If CSR TVAL is -1, the oneshot timer is fired; and if timer
hw irq is on in CSR ESTAT register, it happens after exiting to host;
else if timer hw irq is off, we think that it happens in vm and timer
IRQ handler has already acked IRQ.

With this patch, runltp with version ltp20230516 passes to run in vm.

Signed-off-by: Bibo Mao <maobibo@loongson.cn>
Signed-off-by: Huacai Chen <chenhuacai@loongson.cn>

diff --git a/arch/loongarch/kvm/timer.c b/arch/loongarch/kvm/timer.c
index d362d87a54aa173798973f588846465b1de3afa9..111328f6087285a01ccf4077672cf4cc85266866 100644 (file)
--- a/arch/loongarch/kvm/timer.c
+++ b/arch/loongarch/kvm/timer.c
@@ -69,14 +69,19 @@ void kvm_init_timer(struct kvm_vcpu *vcpu, unsigned long timer_hz)
  */
 void kvm_restore_timer(struct kvm_vcpu *vcpu)
 {
-       unsigned long cfg, delta, period;
+       unsigned long cfg, estat;
+       unsigned long ticks, delta, period;
        ktime_t expire, now;
        struct loongarch_csrs *csr = vcpu->arch.csr;
 
        /*
         * Set guest stable timer cfg csr
+        * Disable timer before restore estat CSR register, avoid to
+        * get invalid timer interrupt for old timer cfg
         */
        cfg = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_TCFG);
+
+       write_gcsr_timercfg(0);
        kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_ESTAT);
        kvm_restore_hw_gcsr(csr, LOONGARCH_CSR_TCFG);
        if (!(cfg & CSR_TCFG_EN)) {
@@ -90,20 +95,47 @@ void kvm_restore_timer(struct kvm_vcpu *vcpu)
         */
        hrtimer_cancel(&vcpu->arch.swtimer);
 
+       /*
+        * From LoongArch Reference Manual Volume 1 Chapter 7.6.2
+        * If oneshot timer is fired, CSR TVAL will be -1, there are two
+        * conditions:
+        *  1) timer is fired during exiting to host
+        *  2) timer is fired and vm is doing timer irq, and then exiting to
+        *     host. Host should not inject timer irq to avoid spurious
+        *     timer interrupt again
+        */
+       ticks = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_TVAL);
+       estat = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_ESTAT);
+       if (!(cfg & CSR_TCFG_PERIOD) && (ticks > cfg)) {
+               /*
+                * Writing 0 to LOONGARCH_CSR_TVAL will inject timer irq
+                * and set CSR TVAL with -1
+                */
+               write_gcsr_timertick(0);
+
+               /*
+                * Writing CSR_TINTCLR_TI to LOONGARCH_CSR_TINTCLR will clear
+                * timer interrupt, and CSR TVAL keeps unchanged with -1, it
+                * avoids spurious timer interrupt
+                */
+               if (!(estat & CPU_TIMER))
+                       gcsr_write(CSR_TINTCLR_TI, LOONGARCH_CSR_TINTCLR);
+               return;
+       }
+
        /*
         * Set remainder tick value if not expired
         */
+       delta = 0;
        now = ktime_get();
        expire = vcpu->arch.expire;
        if (ktime_before(now, expire))
                delta = ktime_to_tick(vcpu, ktime_sub(expire, now));
-       else {
-               if (cfg & CSR_TCFG_PERIOD) {
-                       period = cfg & CSR_TCFG_VAL;
-                       delta = ktime_to_tick(vcpu, ktime_sub(now, expire));
-                       delta = period - (delta % period);
-               } else
-                       delta = 0;
+       else if (cfg & CSR_TCFG_PERIOD) {
+               period = cfg & CSR_TCFG_VAL;
+               delta = ktime_to_tick(vcpu, ktime_sub(now, expire));
+               delta = period - (delta % period);
+
                /*
                 * Inject timer here though sw timer should inject timer
                 * interrupt async already, since sw timer may be cancelled
@@ -122,15 +154,25 @@ void kvm_restore_timer(struct kvm_vcpu *vcpu)
  */
 static void _kvm_save_timer(struct kvm_vcpu *vcpu)
 {
-       unsigned long ticks, delta;
+       unsigned long ticks, delta, cfg;
        ktime_t expire;
        struct loongarch_csrs *csr = vcpu->arch.csr;
 
+       cfg = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_TCFG);
        ticks = kvm_read_sw_gcsr(csr, LOONGARCH_CSR_TVAL);
-       delta = tick_to_ns(vcpu, ticks);
-       expire = ktime_add_ns(ktime_get(), delta);
-       vcpu->arch.expire = expire;
-       if (ticks) {
+
+       /*
+        * From LoongArch Reference Manual Volume 1 Chapter 7.6.2
+        * If period timer is fired, CSR TVAL will be reloaded from CSR TCFG
+        * If oneshot timer is fired, CSR TVAL will be -1
+        * Here judge one-shot timer fired by checking whether TVAL is larger
+        * than TCFG
+        */
+       if (ticks < cfg) {
+               delta = tick_to_ns(vcpu, ticks);
+               expire = ktime_add_ns(ktime_get(), delta);
+               vcpu->arch.expire = expire;
+
                /*
                 * HRTIMER_MODE_PINNED is suggested since vcpu may run in
                 * the same physical cpu in next time