2 * Copyright (C) 2012 ARM Ltd.
3 * Author: Marc Zyngier <marc.zyngier@arm.com>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #include <linux/cpu.h>
20 #include <linux/kvm.h>
21 #include <linux/kvm_host.h>
22 #include <linux/interrupt.h>
23 #include <linux/irq.h>
24 #include <linux/uaccess.h>
26 #include <clocksource/arm_arch_timer.h>
27 #include <asm/arch_timer.h>
28 #include <asm/kvm_hyp.h>
30 #include <kvm/arm_vgic.h>
31 #include <kvm/arm_arch_timer.h>
35 static struct timecounter
*timecounter
;
36 static unsigned int host_vtimer_irq
;
37 static u32 host_vtimer_irq_flags
;
39 static const struct kvm_irq_level default_ptimer_irq
= {
44 static const struct kvm_irq_level default_vtimer_irq
= {
49 static bool kvm_timer_irq_can_fire(struct arch_timer_context
*timer_ctx
);
50 static void kvm_timer_update_irq(struct kvm_vcpu
*vcpu
, bool new_level
,
51 struct arch_timer_context
*timer_ctx
);
52 static bool kvm_timer_should_fire(struct arch_timer_context
*timer_ctx
);
54 u64
kvm_phys_timer_read(void)
56 return timecounter
->cc
->read(timecounter
->cc
);
59 static void soft_timer_start(struct hrtimer
*hrt
, u64 ns
)
61 hrtimer_start(hrt
, ktime_add_ns(ktime_get(), ns
),
65 static void soft_timer_cancel(struct hrtimer
*hrt
, struct work_struct
*work
)
69 cancel_work_sync(work
);
72 static void kvm_vtimer_update_mask_user(struct kvm_vcpu
*vcpu
)
74 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
77 * When using a userspace irqchip with the architected timers, we must
78 * prevent continuously exiting from the guest, and therefore mask the
79 * physical interrupt by disabling it on the host interrupt controller
80 * when the virtual level is high, such that the guest can make
81 * forward progress. Once we detect the output level being
82 * de-asserted, we unmask the interrupt again so that we exit from the
83 * guest when the timer fires.
85 if (vtimer
->irq
.level
)
86 disable_percpu_irq(host_vtimer_irq
);
88 enable_percpu_irq(host_vtimer_irq
, 0);
91 static irqreturn_t
kvm_arch_timer_handler(int irq
, void *dev_id
)
93 struct kvm_vcpu
*vcpu
= *(struct kvm_vcpu
**)dev_id
;
94 struct arch_timer_context
*vtimer
;
97 pr_warn_once("Spurious arch timer IRQ on non-VCPU thread\n");
100 vtimer
= vcpu_vtimer(vcpu
);
102 if (!vtimer
->irq
.level
) {
103 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
104 if (kvm_timer_irq_can_fire(vtimer
))
105 kvm_timer_update_irq(vcpu
, true, vtimer
);
108 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
)))
109 kvm_vtimer_update_mask_user(vcpu
);
115 * Work function for handling the backup timer that we schedule when a vcpu is
116 * no longer running, but had a timer programmed to fire in the future.
118 static void kvm_timer_inject_irq_work(struct work_struct
*work
)
120 struct kvm_vcpu
*vcpu
;
122 vcpu
= container_of(work
, struct kvm_vcpu
, arch
.timer_cpu
.expired
);
125 * If the vcpu is blocked we want to wake it up so that it will see
126 * the timer has expired when entering the guest.
128 kvm_vcpu_wake_up(vcpu
);
131 static u64
kvm_timer_compute_delta(struct arch_timer_context
*timer_ctx
)
135 cval
= timer_ctx
->cnt_cval
;
136 now
= kvm_phys_timer_read() - timer_ctx
->cntvoff
;
141 ns
= cyclecounter_cyc2ns(timecounter
->cc
,
151 static bool kvm_timer_irq_can_fire(struct arch_timer_context
*timer_ctx
)
153 return !(timer_ctx
->cnt_ctl
& ARCH_TIMER_CTRL_IT_MASK
) &&
154 (timer_ctx
->cnt_ctl
& ARCH_TIMER_CTRL_ENABLE
);
158 * Returns the earliest expiration time in ns among guest timers.
159 * Note that it will return 0 if none of timers can fire.
161 static u64
kvm_timer_earliest_exp(struct kvm_vcpu
*vcpu
)
163 u64 min_virt
= ULLONG_MAX
, min_phys
= ULLONG_MAX
;
164 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
165 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
167 if (kvm_timer_irq_can_fire(vtimer
))
168 min_virt
= kvm_timer_compute_delta(vtimer
);
170 if (kvm_timer_irq_can_fire(ptimer
))
171 min_phys
= kvm_timer_compute_delta(ptimer
);
173 /* If none of timers can fire, then return 0 */
174 if ((min_virt
== ULLONG_MAX
) && (min_phys
== ULLONG_MAX
))
177 return min(min_virt
, min_phys
);
180 static enum hrtimer_restart
kvm_bg_timer_expire(struct hrtimer
*hrt
)
182 struct arch_timer_cpu
*timer
;
183 struct kvm_vcpu
*vcpu
;
186 timer
= container_of(hrt
, struct arch_timer_cpu
, bg_timer
);
187 vcpu
= container_of(timer
, struct kvm_vcpu
, arch
.timer_cpu
);
190 * Check that the timer has really expired from the guest's
191 * PoV (NTP on the host may have forced it to expire
192 * early). If we should have slept longer, restart it.
194 ns
= kvm_timer_earliest_exp(vcpu
);
196 hrtimer_forward_now(hrt
, ns_to_ktime(ns
));
197 return HRTIMER_RESTART
;
200 schedule_work(&timer
->expired
);
201 return HRTIMER_NORESTART
;
204 static enum hrtimer_restart
kvm_phys_timer_expire(struct hrtimer
*hrt
)
206 struct arch_timer_context
*ptimer
;
207 struct arch_timer_cpu
*timer
;
208 struct kvm_vcpu
*vcpu
;
211 timer
= container_of(hrt
, struct arch_timer_cpu
, phys_timer
);
212 vcpu
= container_of(timer
, struct kvm_vcpu
, arch
.timer_cpu
);
213 ptimer
= vcpu_ptimer(vcpu
);
216 * Check that the timer has really expired from the guest's
217 * PoV (NTP on the host may have forced it to expire
218 * early). If not ready, schedule for a later time.
220 ns
= kvm_timer_compute_delta(ptimer
);
222 hrtimer_forward_now(hrt
, ns_to_ktime(ns
));
223 return HRTIMER_RESTART
;
226 kvm_timer_update_irq(vcpu
, true, ptimer
);
227 return HRTIMER_NORESTART
;
230 static bool kvm_timer_should_fire(struct arch_timer_context
*timer_ctx
)
234 if (!kvm_timer_irq_can_fire(timer_ctx
))
237 cval
= timer_ctx
->cnt_cval
;
238 now
= kvm_phys_timer_read() - timer_ctx
->cntvoff
;
243 bool kvm_timer_is_pending(struct kvm_vcpu
*vcpu
)
245 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
246 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
248 if (vtimer
->irq
.level
|| ptimer
->irq
.level
)
252 * When this is called from withing the wait loop of kvm_vcpu_block(),
253 * the software view of the timer state is up to date (timer->loaded
254 * is false), and so we can simply check if the timer should fire now.
256 if (!vtimer
->loaded
&& kvm_timer_should_fire(vtimer
))
259 return kvm_timer_should_fire(ptimer
);
263 * Reflect the timer output level into the kvm_run structure
265 void kvm_timer_update_run(struct kvm_vcpu
*vcpu
)
267 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
268 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
269 struct kvm_sync_regs
*regs
= &vcpu
->run
->s
.regs
;
271 /* Populate the device bitmap with the timer states */
272 regs
->device_irq_level
&= ~(KVM_ARM_DEV_EL1_VTIMER
|
273 KVM_ARM_DEV_EL1_PTIMER
);
274 if (vtimer
->irq
.level
)
275 regs
->device_irq_level
|= KVM_ARM_DEV_EL1_VTIMER
;
276 if (ptimer
->irq
.level
)
277 regs
->device_irq_level
|= KVM_ARM_DEV_EL1_PTIMER
;
280 static void kvm_timer_update_irq(struct kvm_vcpu
*vcpu
, bool new_level
,
281 struct arch_timer_context
*timer_ctx
)
285 timer_ctx
->irq
.level
= new_level
;
286 trace_kvm_timer_update_irq(vcpu
->vcpu_id
, timer_ctx
->irq
.irq
,
287 timer_ctx
->irq
.level
);
289 if (likely(irqchip_in_kernel(vcpu
->kvm
))) {
290 ret
= kvm_vgic_inject_irq(vcpu
->kvm
, vcpu
->vcpu_id
,
292 timer_ctx
->irq
.level
,
298 /* Schedule the background timer for the emulated timer. */
299 static void phys_timer_emulate(struct kvm_vcpu
*vcpu
)
301 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
302 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
305 * If the timer can fire now we have just raised the IRQ line and we
306 * don't need to have a soft timer scheduled for the future. If the
307 * timer cannot fire at all, then we also don't need a soft timer.
309 if (kvm_timer_should_fire(ptimer
) || !kvm_timer_irq_can_fire(ptimer
)) {
310 soft_timer_cancel(&timer
->phys_timer
, NULL
);
314 soft_timer_start(&timer
->phys_timer
, kvm_timer_compute_delta(ptimer
));
318 * Check if there was a change in the timer state, so that we should either
319 * raise or lower the line level to the GIC or schedule a background timer to
320 * emulate the physical timer.
322 static void kvm_timer_update_state(struct kvm_vcpu
*vcpu
)
324 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
325 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
326 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
328 if (unlikely(!timer
->enabled
))
331 if (kvm_timer_should_fire(vtimer
) != vtimer
->irq
.level
)
332 kvm_timer_update_irq(vcpu
, !vtimer
->irq
.level
, vtimer
);
334 if (kvm_timer_should_fire(ptimer
) != ptimer
->irq
.level
)
335 kvm_timer_update_irq(vcpu
, !ptimer
->irq
.level
, ptimer
);
337 phys_timer_emulate(vcpu
);
340 static void vtimer_save_state(struct kvm_vcpu
*vcpu
)
342 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
343 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
346 local_irq_save(flags
);
351 if (timer
->enabled
) {
352 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
353 vtimer
->cnt_cval
= read_sysreg_el0(cntv_cval
);
356 /* Disable the virtual timer */
357 write_sysreg_el0(0, cntv_ctl
);
359 vtimer
->loaded
= false;
361 local_irq_restore(flags
);
365 * Schedule the background timer before calling kvm_vcpu_block, so that this
366 * thread is removed from its waitqueue and made runnable when there's a timer
367 * interrupt to handle.
369 void kvm_timer_schedule(struct kvm_vcpu
*vcpu
)
371 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
372 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
373 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
375 vtimer_save_state(vcpu
);
378 * No need to schedule a background timer if any guest timer has
379 * already expired, because kvm_vcpu_block will return before putting
380 * the thread to sleep.
382 if (kvm_timer_should_fire(vtimer
) || kvm_timer_should_fire(ptimer
))
386 * If both timers are not capable of raising interrupts (disabled or
387 * masked), then there's no more work for us to do.
389 if (!kvm_timer_irq_can_fire(vtimer
) && !kvm_timer_irq_can_fire(ptimer
))
393 * The guest timers have not yet expired, schedule a background timer.
394 * Set the earliest expiration time among the guest timers.
396 soft_timer_start(&timer
->bg_timer
, kvm_timer_earliest_exp(vcpu
));
399 static void vtimer_restore_state(struct kvm_vcpu
*vcpu
)
401 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
402 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
405 local_irq_save(flags
);
410 if (timer
->enabled
) {
411 write_sysreg_el0(vtimer
->cnt_cval
, cntv_cval
);
413 write_sysreg_el0(vtimer
->cnt_ctl
, cntv_ctl
);
416 vtimer
->loaded
= true;
418 local_irq_restore(flags
);
421 void kvm_timer_unschedule(struct kvm_vcpu
*vcpu
)
423 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
425 vtimer_restore_state(vcpu
);
427 soft_timer_cancel(&timer
->bg_timer
, &timer
->expired
);
430 static void set_cntvoff(u64 cntvoff
)
432 u32 low
= lower_32_bits(cntvoff
);
433 u32 high
= upper_32_bits(cntvoff
);
436 * Since kvm_call_hyp doesn't fully support the ARM PCS especially on
437 * 32-bit systems, but rather passes register by register shifted one
438 * place (we put the function address in r0/x0), we cannot simply pass
439 * a 64-bit value as an argument, but have to split the value in two
442 kvm_call_hyp(__kvm_timer_set_cntvoff
, low
, high
);
445 static void kvm_timer_vcpu_load_vgic(struct kvm_vcpu
*vcpu
)
447 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
451 phys_active
= vtimer
->irq
.level
||
452 kvm_vgic_map_is_active(vcpu
, vtimer
->irq
.irq
);
454 ret
= irq_set_irqchip_state(host_vtimer_irq
,
455 IRQCHIP_STATE_ACTIVE
,
460 static void kvm_timer_vcpu_load_user(struct kvm_vcpu
*vcpu
)
462 kvm_vtimer_update_mask_user(vcpu
);
465 void kvm_timer_vcpu_load(struct kvm_vcpu
*vcpu
)
467 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
468 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
470 if (unlikely(!timer
->enabled
))
473 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
)))
474 kvm_timer_vcpu_load_user(vcpu
);
476 kvm_timer_vcpu_load_vgic(vcpu
);
478 set_cntvoff(vtimer
->cntvoff
);
480 vtimer_restore_state(vcpu
);
483 disable_el1_phys_timer_access();
485 /* Set the background timer for the physical timer emulation. */
486 phys_timer_emulate(vcpu
);
489 bool kvm_timer_should_notify_user(struct kvm_vcpu
*vcpu
)
491 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
492 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
493 struct kvm_sync_regs
*sregs
= &vcpu
->run
->s
.regs
;
496 if (likely(irqchip_in_kernel(vcpu
->kvm
)))
499 vlevel
= sregs
->device_irq_level
& KVM_ARM_DEV_EL1_VTIMER
;
500 plevel
= sregs
->device_irq_level
& KVM_ARM_DEV_EL1_PTIMER
;
502 return vtimer
->irq
.level
!= vlevel
||
503 ptimer
->irq
.level
!= plevel
;
506 void kvm_timer_vcpu_put(struct kvm_vcpu
*vcpu
)
508 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
510 if (unlikely(!timer
->enabled
))
514 enable_el1_phys_timer_access();
516 vtimer_save_state(vcpu
);
519 * Cancel the physical timer emulation, because the only case where we
520 * need it after a vcpu_put is in the context of a sleeping VCPU, and
521 * in that case we already factor in the deadline for the physical
522 * timer when scheduling the bg_timer.
524 * In any case, we re-schedule the hrtimer for the physical timer when
525 * coming back to the VCPU thread in kvm_timer_vcpu_load().
527 soft_timer_cancel(&timer
->phys_timer
, NULL
);
530 * The kernel may decide to run userspace after calling vcpu_put, so
531 * we reset cntvoff to 0 to ensure a consistent read between user
532 * accesses to the virtual counter and kernel access to the physical
538 static void unmask_vtimer_irq(struct kvm_vcpu
*vcpu
)
540 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
542 if (unlikely(!irqchip_in_kernel(vcpu
->kvm
))) {
543 kvm_vtimer_update_mask_user(vcpu
);
548 * If the guest disabled the timer without acking the interrupt, then
549 * we must make sure the physical and virtual active states are in
550 * sync by deactivating the physical interrupt, because otherwise we
551 * wouldn't see the next timer interrupt in the host.
553 if (!kvm_vgic_map_is_active(vcpu
, vtimer
->irq
.irq
)) {
555 ret
= irq_set_irqchip_state(host_vtimer_irq
,
556 IRQCHIP_STATE_ACTIVE
,
563 * kvm_timer_sync_hwstate - sync timer state from cpu
564 * @vcpu: The vcpu pointer
566 * Check if any of the timers have expired while we were running in the guest,
567 * and inject an interrupt if that was the case.
569 void kvm_timer_sync_hwstate(struct kvm_vcpu
*vcpu
)
571 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
574 * If we entered the guest with the vtimer output asserted we have to
575 * check if the guest has modified the timer so that we should lower
576 * the line at this point.
578 if (vtimer
->irq
.level
) {
579 vtimer
->cnt_ctl
= read_sysreg_el0(cntv_ctl
);
580 vtimer
->cnt_cval
= read_sysreg_el0(cntv_cval
);
581 if (!kvm_timer_should_fire(vtimer
)) {
582 kvm_timer_update_irq(vcpu
, false, vtimer
);
583 unmask_vtimer_irq(vcpu
);
588 int kvm_timer_vcpu_reset(struct kvm_vcpu
*vcpu
)
590 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
591 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
594 * The bits in CNTV_CTL are architecturally reset to UNKNOWN for ARMv8
595 * and to 0 for ARMv7. We provide an implementation that always
596 * resets the timer to be disabled and unmasked and is compliant with
597 * the ARMv7 architecture.
601 kvm_timer_update_state(vcpu
);
606 /* Make the updates of cntvoff for all vtimer contexts atomic */
607 static void update_vtimer_cntvoff(struct kvm_vcpu
*vcpu
, u64 cntvoff
)
610 struct kvm
*kvm
= vcpu
->kvm
;
611 struct kvm_vcpu
*tmp
;
613 mutex_lock(&kvm
->lock
);
614 kvm_for_each_vcpu(i
, tmp
, kvm
)
615 vcpu_vtimer(tmp
)->cntvoff
= cntvoff
;
618 * When called from the vcpu create path, the CPU being created is not
619 * included in the loop above, so we just set it here as well.
621 vcpu_vtimer(vcpu
)->cntvoff
= cntvoff
;
622 mutex_unlock(&kvm
->lock
);
625 void kvm_timer_vcpu_init(struct kvm_vcpu
*vcpu
)
627 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
628 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
629 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
631 /* Synchronize cntvoff across all vtimers of a VM. */
632 update_vtimer_cntvoff(vcpu
, kvm_phys_timer_read());
633 vcpu_ptimer(vcpu
)->cntvoff
= 0;
635 INIT_WORK(&timer
->expired
, kvm_timer_inject_irq_work
);
636 hrtimer_init(&timer
->bg_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_ABS
);
637 timer
->bg_timer
.function
= kvm_bg_timer_expire
;
639 hrtimer_init(&timer
->phys_timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_ABS
);
640 timer
->phys_timer
.function
= kvm_phys_timer_expire
;
642 vtimer
->irq
.irq
= default_vtimer_irq
.irq
;
643 ptimer
->irq
.irq
= default_ptimer_irq
.irq
;
646 static void kvm_timer_init_interrupt(void *info
)
648 enable_percpu_irq(host_vtimer_irq
, host_vtimer_irq_flags
);
651 int kvm_arm_timer_set_reg(struct kvm_vcpu
*vcpu
, u64 regid
, u64 value
)
653 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
654 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
657 case KVM_REG_ARM_TIMER_CTL
:
658 vtimer
->cnt_ctl
= value
& ~ARCH_TIMER_CTRL_IT_STAT
;
660 case KVM_REG_ARM_TIMER_CNT
:
661 update_vtimer_cntvoff(vcpu
, kvm_phys_timer_read() - value
);
663 case KVM_REG_ARM_TIMER_CVAL
:
664 vtimer
->cnt_cval
= value
;
666 case KVM_REG_ARM_PTIMER_CTL
:
667 ptimer
->cnt_ctl
= value
& ~ARCH_TIMER_CTRL_IT_STAT
;
669 case KVM_REG_ARM_PTIMER_CVAL
:
670 ptimer
->cnt_cval
= value
;
677 kvm_timer_update_state(vcpu
);
681 static u64
read_timer_ctl(struct arch_timer_context
*timer
)
684 * Set ISTATUS bit if it's expired.
685 * Note that according to ARMv8 ARM Issue A.k, ISTATUS bit is
686 * UNKNOWN when ENABLE bit is 0, so we chose to set ISTATUS bit
687 * regardless of ENABLE bit for our implementation convenience.
689 if (!kvm_timer_compute_delta(timer
))
690 return timer
->cnt_ctl
| ARCH_TIMER_CTRL_IT_STAT
;
692 return timer
->cnt_ctl
;
695 u64
kvm_arm_timer_get_reg(struct kvm_vcpu
*vcpu
, u64 regid
)
697 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
698 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
701 case KVM_REG_ARM_TIMER_CTL
:
702 return read_timer_ctl(vtimer
);
703 case KVM_REG_ARM_TIMER_CNT
:
704 return kvm_phys_timer_read() - vtimer
->cntvoff
;
705 case KVM_REG_ARM_TIMER_CVAL
:
706 return vtimer
->cnt_cval
;
707 case KVM_REG_ARM_PTIMER_CTL
:
708 return read_timer_ctl(ptimer
);
709 case KVM_REG_ARM_PTIMER_CVAL
:
710 return ptimer
->cnt_cval
;
711 case KVM_REG_ARM_PTIMER_CNT
:
712 return kvm_phys_timer_read();
717 static int kvm_timer_starting_cpu(unsigned int cpu
)
719 kvm_timer_init_interrupt(NULL
);
723 static int kvm_timer_dying_cpu(unsigned int cpu
)
725 disable_percpu_irq(host_vtimer_irq
);
729 int kvm_timer_hyp_init(void)
731 struct arch_timer_kvm_info
*info
;
734 info
= arch_timer_get_kvm_info();
735 timecounter
= &info
->timecounter
;
737 if (!timecounter
->cc
) {
738 kvm_err("kvm_arch_timer: uninitialized timecounter\n");
742 if (info
->virtual_irq
<= 0) {
743 kvm_err("kvm_arch_timer: invalid virtual timer IRQ: %d\n",
747 host_vtimer_irq
= info
->virtual_irq
;
749 host_vtimer_irq_flags
= irq_get_trigger_type(host_vtimer_irq
);
750 if (host_vtimer_irq_flags
!= IRQF_TRIGGER_HIGH
&&
751 host_vtimer_irq_flags
!= IRQF_TRIGGER_LOW
) {
752 kvm_err("Invalid trigger for IRQ%d, assuming level low\n",
754 host_vtimer_irq_flags
= IRQF_TRIGGER_LOW
;
757 err
= request_percpu_irq(host_vtimer_irq
, kvm_arch_timer_handler
,
758 "kvm guest timer", kvm_get_running_vcpus());
760 kvm_err("kvm_arch_timer: can't request interrupt %d (%d)\n",
761 host_vtimer_irq
, err
);
765 err
= irq_set_vcpu_affinity(host_vtimer_irq
, kvm_get_running_vcpus());
767 kvm_err("kvm_arch_timer: error setting vcpu affinity\n");
771 kvm_info("virtual timer IRQ%d\n", host_vtimer_irq
);
773 cpuhp_setup_state(CPUHP_AP_KVM_ARM_TIMER_STARTING
,
774 "kvm/arm/timer:starting", kvm_timer_starting_cpu
,
775 kvm_timer_dying_cpu
);
778 free_percpu_irq(host_vtimer_irq
, kvm_get_running_vcpus());
782 void kvm_timer_vcpu_terminate(struct kvm_vcpu
*vcpu
)
784 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
785 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
787 soft_timer_cancel(&timer
->bg_timer
, &timer
->expired
);
788 soft_timer_cancel(&timer
->phys_timer
, NULL
);
789 kvm_vgic_unmap_phys_irq(vcpu
, vtimer
->irq
.irq
);
792 static bool timer_irqs_are_valid(struct kvm_vcpu
*vcpu
)
794 int vtimer_irq
, ptimer_irq
;
797 vtimer_irq
= vcpu_vtimer(vcpu
)->irq
.irq
;
798 ret
= kvm_vgic_set_owner(vcpu
, vtimer_irq
, vcpu_vtimer(vcpu
));
802 ptimer_irq
= vcpu_ptimer(vcpu
)->irq
.irq
;
803 ret
= kvm_vgic_set_owner(vcpu
, ptimer_irq
, vcpu_ptimer(vcpu
));
807 kvm_for_each_vcpu(i
, vcpu
, vcpu
->kvm
) {
808 if (vcpu_vtimer(vcpu
)->irq
.irq
!= vtimer_irq
||
809 vcpu_ptimer(vcpu
)->irq
.irq
!= ptimer_irq
)
816 int kvm_timer_enable(struct kvm_vcpu
*vcpu
)
818 struct arch_timer_cpu
*timer
= &vcpu
->arch
.timer_cpu
;
819 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
820 struct irq_desc
*desc
;
821 struct irq_data
*data
;
828 /* Without a VGIC we do not map virtual IRQs to physical IRQs */
829 if (!irqchip_in_kernel(vcpu
->kvm
))
832 if (!vgic_initialized(vcpu
->kvm
))
835 if (!timer_irqs_are_valid(vcpu
)) {
836 kvm_debug("incorrectly configured timer irqs\n");
841 * Find the physical IRQ number corresponding to the host_vtimer_irq
843 desc
= irq_to_desc(host_vtimer_irq
);
845 kvm_err("%s: no interrupt descriptor\n", __func__
);
849 data
= irq_desc_get_irq_data(desc
);
850 while (data
->parent_data
)
851 data
= data
->parent_data
;
853 phys_irq
= data
->hwirq
;
856 * Tell the VGIC that the virtual interrupt is tied to a
857 * physical interrupt. We do that once per VCPU.
859 ret
= kvm_vgic_map_phys_irq(vcpu
, vtimer
->irq
.irq
, phys_irq
);
866 kvm_timer_vcpu_load_vgic(vcpu
);
873 * On VHE system, we only need to configure trap on physical timer and counter
874 * accesses in EL0 and EL1 once, not for every world switch.
875 * The host kernel runs at EL2 with HCR_EL2.TGE == 1,
876 * and this makes those bits have no effect for the host kernel execution.
878 void kvm_timer_init_vhe(void)
880 /* When HCR_EL2.E2H ==1, EL1PCEN and EL1PCTEN are shifted by 10 */
881 u32 cnthctl_shift
= 10;
885 * Disallow physical timer access for the guest.
886 * Physical counter access is allowed.
888 val
= read_sysreg(cnthctl_el2
);
889 val
&= ~(CNTHCTL_EL1PCEN
<< cnthctl_shift
);
890 val
|= (CNTHCTL_EL1PCTEN
<< cnthctl_shift
);
891 write_sysreg(val
, cnthctl_el2
);
894 static void set_timer_irqs(struct kvm
*kvm
, int vtimer_irq
, int ptimer_irq
)
896 struct kvm_vcpu
*vcpu
;
899 kvm_for_each_vcpu(i
, vcpu
, kvm
) {
900 vcpu_vtimer(vcpu
)->irq
.irq
= vtimer_irq
;
901 vcpu_ptimer(vcpu
)->irq
.irq
= ptimer_irq
;
905 int kvm_arm_timer_set_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
907 int __user
*uaddr
= (int __user
*)(long)attr
->addr
;
908 struct arch_timer_context
*vtimer
= vcpu_vtimer(vcpu
);
909 struct arch_timer_context
*ptimer
= vcpu_ptimer(vcpu
);
912 if (!irqchip_in_kernel(vcpu
->kvm
))
915 if (get_user(irq
, uaddr
))
918 if (!(irq_is_ppi(irq
)))
921 if (vcpu
->arch
.timer_cpu
.enabled
)
924 switch (attr
->attr
) {
925 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
926 set_timer_irqs(vcpu
->kvm
, irq
, ptimer
->irq
.irq
);
928 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
:
929 set_timer_irqs(vcpu
->kvm
, vtimer
->irq
.irq
, irq
);
938 int kvm_arm_timer_get_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
940 int __user
*uaddr
= (int __user
*)(long)attr
->addr
;
941 struct arch_timer_context
*timer
;
944 switch (attr
->attr
) {
945 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
946 timer
= vcpu_vtimer(vcpu
);
948 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
:
949 timer
= vcpu_ptimer(vcpu
);
955 irq
= timer
->irq
.irq
;
956 return put_user(irq
, uaddr
);
959 int kvm_arm_timer_has_attr(struct kvm_vcpu
*vcpu
, struct kvm_device_attr
*attr
)
961 switch (attr
->attr
) {
962 case KVM_ARM_VCPU_TIMER_IRQ_VTIMER
:
963 case KVM_ARM_VCPU_TIMER_IRQ_PTIMER
: