irqchip.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * irqchip.c: Common API for in kernel interrupt controllers
  4. * Copyright (c) 2007, Intel Corporation.
  5. * Copyright 2010 Red Hat, Inc. and/or its affiliates.
  6. * Copyright (c) 2013, Alexander Graf <agraf@suse.de>
  7. *
  8. * This file is derived from virt/kvm/irq_comm.c.
  9. *
  10. * Authors:
  11. * Yaozu (Eddie) Dong <Eddie.dong@intel.com>
  12. * Alexander Graf <agraf@suse.de>
  13. */
  14. #include <linux/kvm_host.h>
  15. #include <linux/slab.h>
  16. #include <linux/srcu.h>
  17. #include <linux/export.h>
  18. #include <trace/events/kvm.h>
  19. #include "irq.h"
  20. int kvm_irq_map_gsi(struct kvm *kvm,
  21. struct kvm_kernel_irq_routing_entry *entries, int gsi)
  22. {
  23. struct kvm_irq_routing_table *irq_rt;
  24. struct kvm_kernel_irq_routing_entry *e;
  25. int n = 0;
  26. irq_rt = srcu_dereference_check(kvm->irq_routing, &kvm->irq_srcu,
  27. lockdep_is_held(&kvm->irq_lock));
  28. if (irq_rt && gsi < irq_rt->nr_rt_entries) {
  29. hlist_for_each_entry(e, &irq_rt->map[gsi], link) {
  30. entries[n] = *e;
  31. ++n;
  32. }
  33. }
  34. return n;
  35. }
  36. int kvm_irq_map_chip_pin(struct kvm *kvm, unsigned irqchip, unsigned pin)
  37. {
  38. struct kvm_irq_routing_table *irq_rt;
  39. irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
  40. return irq_rt->chip[irqchip][pin];
  41. }
  42. int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
  43. {
  44. struct kvm_kernel_irq_routing_entry route;
  45. if (!irqchip_in_kernel(kvm) || (msi->flags & ~KVM_MSI_VALID_DEVID))
  46. return -EINVAL;
  47. route.msi.address_lo = msi->address_lo;
  48. route.msi.address_hi = msi->address_hi;
  49. route.msi.data = msi->data;
  50. route.msi.flags = msi->flags;
  51. route.msi.devid = msi->devid;
  52. return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
  53. }
  54. /*
  55. * Return value:
  56. * < 0 Interrupt was ignored (masked or not delivered for other reasons)
  57. * = 0 Interrupt was coalesced (previous irq is still pending)
  58. * > 0 Number of CPUs interrupt was delivered to
  59. */
  60. int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
  61. bool line_status)
  62. {
  63. struct kvm_kernel_irq_routing_entry irq_set[KVM_NR_IRQCHIPS];
  64. int ret = -1, i, idx;
  65. trace_kvm_set_irq(irq, level, irq_source_id);
  66. /* Not possible to detect if the guest uses the PIC or the
  67. * IOAPIC. So set the bit in both. The guest will ignore
  68. * writes to the unused one.
  69. */
  70. idx = srcu_read_lock(&kvm->irq_srcu);
  71. i = kvm_irq_map_gsi(kvm, irq_set, irq);
  72. srcu_read_unlock(&kvm->irq_srcu, idx);
  73. while (i--) {
  74. int r;
  75. r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
  76. line_status);
  77. if (r < 0)
  78. continue;
  79. ret = r + ((ret < 0) ? 0 : ret);
  80. }
  81. return ret;
  82. }
  83. static void free_irq_routing_table(struct kvm_irq_routing_table *rt)
  84. {
  85. int i;
  86. if (!rt)
  87. return;
  88. for (i = 0; i < rt->nr_rt_entries; ++i) {
  89. struct kvm_kernel_irq_routing_entry *e;
  90. struct hlist_node *n;
  91. hlist_for_each_entry_safe(e, n, &rt->map[i], link) {
  92. hlist_del(&e->link);
  93. kfree(e);
  94. }
  95. }
  96. kfree(rt);
  97. }
  98. void kvm_free_irq_routing(struct kvm *kvm)
  99. {
  100. /* Called only during vm destruction. Nobody can use the pointer
  101. at this stage */
  102. struct kvm_irq_routing_table *rt = rcu_access_pointer(kvm->irq_routing);
  103. free_irq_routing_table(rt);
  104. }
  105. static int setup_routing_entry(struct kvm *kvm,
  106. struct kvm_irq_routing_table *rt,
  107. struct kvm_kernel_irq_routing_entry *e,
  108. const struct kvm_irq_routing_entry *ue)
  109. {
  110. struct kvm_kernel_irq_routing_entry *ei;
  111. int r;
  112. u32 gsi = array_index_nospec(ue->gsi, KVM_MAX_IRQ_ROUTES);
  113. /*
  114. * Do not allow GSI to be mapped to the same irqchip more than once.
  115. * Allow only one to one mapping between GSI and non-irqchip routing.
  116. */
  117. hlist_for_each_entry(ei, &rt->map[gsi], link)
  118. if (ei->type != KVM_IRQ_ROUTING_IRQCHIP ||
  119. ue->type != KVM_IRQ_ROUTING_IRQCHIP ||
  120. ue->u.irqchip.irqchip == ei->irqchip.irqchip)
  121. return -EINVAL;
  122. e->gsi = gsi;
  123. e->type = ue->type;
  124. r = kvm_set_routing_entry(kvm, e, ue);
  125. if (r)
  126. return r;
  127. if (e->type == KVM_IRQ_ROUTING_IRQCHIP)
  128. rt->chip[e->irqchip.irqchip][e->irqchip.pin] = e->gsi;
  129. hlist_add_head(&e->link, &rt->map[e->gsi]);
  130. return 0;
  131. }
  132. void __attribute__((weak)) kvm_arch_irq_routing_update(struct kvm *kvm)
  133. {
  134. }
  135. bool __weak kvm_arch_can_set_irq_routing(struct kvm *kvm)
  136. {
  137. return true;
  138. }
  139. int kvm_set_irq_routing(struct kvm *kvm,
  140. const struct kvm_irq_routing_entry *ue,
  141. unsigned nr,
  142. unsigned flags)
  143. {
  144. struct kvm_irq_routing_table *new, *old;
  145. struct kvm_kernel_irq_routing_entry *e;
  146. u32 i, j, nr_rt_entries = 0;
  147. int r;
  148. for (i = 0; i < nr; ++i) {
  149. if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
  150. return -EINVAL;
  151. nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
  152. }
  153. nr_rt_entries += 1;
  154. new = kzalloc(struct_size(new, map, nr_rt_entries), GFP_KERNEL_ACCOUNT);
  155. if (!new)
  156. return -ENOMEM;
  157. new->nr_rt_entries = nr_rt_entries;
  158. for (i = 0; i < KVM_NR_IRQCHIPS; i++)
  159. for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
  160. new->chip[i][j] = -1;
  161. for (i = 0; i < nr; ++i) {
  162. r = -ENOMEM;
  163. e = kzalloc(sizeof(*e), GFP_KERNEL_ACCOUNT);
  164. if (!e)
  165. goto out;
  166. r = -EINVAL;
  167. switch (ue->type) {
  168. case KVM_IRQ_ROUTING_MSI:
  169. if (ue->flags & ~KVM_MSI_VALID_DEVID)
  170. goto free_entry;
  171. break;
  172. default:
  173. if (ue->flags)
  174. goto free_entry;
  175. break;
  176. }
  177. r = setup_routing_entry(kvm, new, e, ue);
  178. if (r)
  179. goto free_entry;
  180. ++ue;
  181. }
  182. mutex_lock(&kvm->irq_lock);
  183. old = rcu_dereference_protected(kvm->irq_routing, 1);
  184. rcu_assign_pointer(kvm->irq_routing, new);
  185. kvm_irq_routing_update(kvm);
  186. kvm_arch_irq_routing_update(kvm);
  187. mutex_unlock(&kvm->irq_lock);
  188. kvm_arch_post_irq_routing_update(kvm);
  189. synchronize_srcu_expedited(&kvm->irq_srcu);
  190. new = old;
  191. r = 0;
  192. goto out;
  193. free_entry:
  194. kfree(e);
  195. out:
  196. free_irq_routing_table(new);
  197. return r;
  198. }