arch_timer.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272
  1. /*
  2. * Copyright (C) 2012 ARM Ltd.
  3. * Author: Marc Zyngier <marc.zyngier@arm.com>
  4. *
  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.
  8. *
  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.
  13. *
  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
  17. */
  18. #include <linux/cpu.h>
  19. #include <linux/of_irq.h>
  20. #include <linux/kvm.h>
  21. #include <linux/kvm_host.h>
  22. #include <linux/interrupt.h>
  23. #include <clocksource/arm_arch_timer.h>
  24. #include <asm/arch_timer.h>
  25. #include <asm/kvm_vgic.h>
  26. #include <asm/kvm_arch_timer.h>
  27. static struct timecounter *timecounter;
  28. static struct workqueue_struct *wqueue;
  29. static struct kvm_irq_level timer_irq = {
  30. .level = 1,
  31. };
  32. static cycle_t kvm_phys_timer_read(void)
  33. {
  34. return timecounter->cc->read(timecounter->cc);
  35. }
  36. static bool timer_is_armed(struct arch_timer_cpu *timer)
  37. {
  38. return timer->armed;
  39. }
  40. /* timer_arm: as in "arm the timer", not as in ARM the company */
  41. static void timer_arm(struct arch_timer_cpu *timer, u64 ns)
  42. {
  43. timer->armed = true;
  44. hrtimer_start(&timer->timer, ktime_add_ns(ktime_get(), ns),
  45. HRTIMER_MODE_ABS);
  46. }
  47. static void timer_disarm(struct arch_timer_cpu *timer)
  48. {
  49. if (timer_is_armed(timer)) {
  50. hrtimer_cancel(&timer->timer);
  51. cancel_work_sync(&timer->expired);
  52. timer->armed = false;
  53. }
  54. }
  55. static void kvm_timer_inject_irq(struct kvm_vcpu *vcpu)
  56. {
  57. struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
  58. timer->cntv_ctl |= ARCH_TIMER_CTRL_IT_MASK;
  59. kvm_vgic_inject_irq(vcpu->kvm, vcpu->vcpu_id,
  60. vcpu->arch.timer_cpu.irq->irq,
  61. vcpu->arch.timer_cpu.irq->level);
  62. }
  63. static irqreturn_t kvm_arch_timer_handler(int irq, void *dev_id)
  64. {
  65. struct kvm_vcpu *vcpu = *(struct kvm_vcpu **)dev_id;
  66. /*
  67. * We disable the timer in the world switch and let it be
  68. * handled by kvm_timer_sync_hwstate(). Getting a timer
  69. * interrupt at this point is a sure sign of some major
  70. * breakage.
  71. */
  72. pr_warn("Unexpected interrupt %d on vcpu %p\n", irq, vcpu);
  73. return IRQ_HANDLED;
  74. }
  75. static void kvm_timer_inject_irq_work(struct work_struct *work)
  76. {
  77. struct kvm_vcpu *vcpu;
  78. vcpu = container_of(work, struct kvm_vcpu, arch.timer_cpu.expired);
  79. vcpu->arch.timer_cpu.armed = false;
  80. kvm_timer_inject_irq(vcpu);
  81. }
  82. static enum hrtimer_restart kvm_timer_expire(struct hrtimer *hrt)
  83. {
  84. struct arch_timer_cpu *timer;
  85. timer = container_of(hrt, struct arch_timer_cpu, timer);
  86. queue_work(wqueue, &timer->expired);
  87. return HRTIMER_NORESTART;
  88. }
  89. /**
  90. * kvm_timer_flush_hwstate - prepare to move the virt timer to the cpu
  91. * @vcpu: The vcpu pointer
  92. *
  93. * Disarm any pending soft timers, since the world-switch code will write the
  94. * virtual timer state back to the physical CPU.
  95. */
  96. void kvm_timer_flush_hwstate(struct kvm_vcpu *vcpu)
  97. {
  98. struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
  99. /*
  100. * We're about to run this vcpu again, so there is no need to
  101. * keep the background timer running, as we're about to
  102. * populate the CPU timer again.
  103. */
  104. timer_disarm(timer);
  105. }
  106. /**
  107. * kvm_timer_sync_hwstate - sync timer state from cpu
  108. * @vcpu: The vcpu pointer
  109. *
  110. * Check if the virtual timer was armed and either schedule a corresponding
  111. * soft timer or inject directly if already expired.
  112. */
  113. void kvm_timer_sync_hwstate(struct kvm_vcpu *vcpu)
  114. {
  115. struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
  116. cycle_t cval, now;
  117. u64 ns;
  118. if ((timer->cntv_ctl & ARCH_TIMER_CTRL_IT_MASK) ||
  119. !(timer->cntv_ctl & ARCH_TIMER_CTRL_ENABLE))
  120. return;
  121. cval = timer->cntv_cval;
  122. now = kvm_phys_timer_read() - vcpu->kvm->arch.timer.cntvoff;
  123. BUG_ON(timer_is_armed(timer));
  124. if (cval <= now) {
  125. /*
  126. * Timer has already expired while we were not
  127. * looking. Inject the interrupt and carry on.
  128. */
  129. kvm_timer_inject_irq(vcpu);
  130. return;
  131. }
  132. ns = cyclecounter_cyc2ns(timecounter->cc, cval - now);
  133. timer_arm(timer, ns);
  134. }
  135. void kvm_timer_vcpu_init(struct kvm_vcpu *vcpu)
  136. {
  137. struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
  138. INIT_WORK(&timer->expired, kvm_timer_inject_irq_work);
  139. hrtimer_init(&timer->timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
  140. timer->timer.function = kvm_timer_expire;
  141. timer->irq = &timer_irq;
  142. }
  143. static void kvm_timer_init_interrupt(void *info)
  144. {
  145. enable_percpu_irq(timer_irq.irq, 0);
  146. }
  147. static int kvm_timer_cpu_notify(struct notifier_block *self,
  148. unsigned long action, void *cpu)
  149. {
  150. switch (action) {
  151. case CPU_STARTING:
  152. case CPU_STARTING_FROZEN:
  153. kvm_timer_init_interrupt(NULL);
  154. break;
  155. case CPU_DYING:
  156. case CPU_DYING_FROZEN:
  157. disable_percpu_irq(timer_irq.irq);
  158. break;
  159. }
  160. return NOTIFY_OK;
  161. }
  162. static struct notifier_block kvm_timer_cpu_nb = {
  163. .notifier_call = kvm_timer_cpu_notify,
  164. };
  165. static const struct of_device_id arch_timer_of_match[] = {
  166. { .compatible = "arm,armv7-timer", },
  167. {},
  168. };
  169. int kvm_timer_hyp_init(void)
  170. {
  171. struct device_node *np;
  172. unsigned int ppi;
  173. int err;
  174. timecounter = arch_timer_get_timecounter();
  175. if (!timecounter)
  176. return -ENODEV;
  177. np = of_find_matching_node(NULL, arch_timer_of_match);
  178. if (!np) {
  179. kvm_err("kvm_arch_timer: can't find DT node\n");
  180. return -ENODEV;
  181. }
  182. ppi = irq_of_parse_and_map(np, 2);
  183. if (!ppi) {
  184. kvm_err("kvm_arch_timer: no virtual timer interrupt\n");
  185. err = -EINVAL;
  186. goto out;
  187. }
  188. err = request_percpu_irq(ppi, kvm_arch_timer_handler,
  189. "kvm guest timer", kvm_get_running_vcpus());
  190. if (err) {
  191. kvm_err("kvm_arch_timer: can't request interrupt %d (%d)\n",
  192. ppi, err);
  193. goto out;
  194. }
  195. timer_irq.irq = ppi;
  196. err = register_cpu_notifier(&kvm_timer_cpu_nb);
  197. if (err) {
  198. kvm_err("Cannot register timer CPU notifier\n");
  199. goto out_free;
  200. }
  201. wqueue = create_singlethread_workqueue("kvm_arch_timer");
  202. if (!wqueue) {
  203. err = -ENOMEM;
  204. goto out_free;
  205. }
  206. kvm_info("%s IRQ%d\n", np->name, ppi);
  207. on_each_cpu(kvm_timer_init_interrupt, NULL, 1);
  208. goto out;
  209. out_free:
  210. free_percpu_irq(ppi, kvm_get_running_vcpus());
  211. out:
  212. of_node_put(np);
  213. return err;
  214. }
  215. void kvm_timer_vcpu_terminate(struct kvm_vcpu *vcpu)
  216. {
  217. struct arch_timer_cpu *timer = &vcpu->arch.timer_cpu;
  218. timer_disarm(timer);
  219. }
  220. int kvm_timer_init(struct kvm *kvm)
  221. {
  222. if (timecounter && wqueue) {
  223. kvm->arch.timer.cntvoff = kvm_phys_timer_read();
  224. kvm->arch.timer.enabled = 1;
  225. }
  226. return 0;
  227. }