xref: /openbmc/linux/virt/kvm/irqchip.c (revision d2999e1b)
1 /*
2  * irqchip.c: Common API for in kernel interrupt controllers
3  * Copyright (c) 2007, Intel Corporation.
4  * Copyright 2010 Red Hat, Inc. and/or its affiliates.
5  * Copyright (c) 2013, Alexander Graf <agraf@suse.de>
6  *
7  * This program is free software; you can redistribute it and/or modify it
8  * under the terms and conditions of the GNU General Public License,
9  * version 2, as published by the Free Software Foundation.
10  *
11  * This program is distributed in the hope it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along with
17  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
18  * Place - Suite 330, Boston, MA 02111-1307 USA.
19  *
20  * This file is derived from virt/kvm/irq_comm.c.
21  *
22  * Authors:
23  *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
24  *   Alexander Graf <agraf@suse.de>
25  */
26 
27 #include <linux/kvm_host.h>
28 #include <linux/slab.h>
29 #include <linux/srcu.h>
30 #include <linux/export.h>
31 #include <trace/events/kvm.h>
32 #include "irq.h"
33 
34 bool kvm_irq_has_notifier(struct kvm *kvm, unsigned irqchip, unsigned pin)
35 {
36 	struct kvm_irq_ack_notifier *kian;
37 	int gsi, idx;
38 
39 	idx = srcu_read_lock(&kvm->irq_srcu);
40 	gsi = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu)->chip[irqchip][pin];
41 	if (gsi != -1)
42 		hlist_for_each_entry_rcu(kian, &kvm->irq_ack_notifier_list,
43 					 link)
44 			if (kian->gsi == gsi) {
45 				srcu_read_unlock(&kvm->irq_srcu, idx);
46 				return true;
47 			}
48 
49 	srcu_read_unlock(&kvm->irq_srcu, idx);
50 
51 	return false;
52 }
53 EXPORT_SYMBOL_GPL(kvm_irq_has_notifier);
54 
55 void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
56 {
57 	struct kvm_irq_ack_notifier *kian;
58 	int gsi, idx;
59 
60 	trace_kvm_ack_irq(irqchip, pin);
61 
62 	idx = srcu_read_lock(&kvm->irq_srcu);
63 	gsi = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu)->chip[irqchip][pin];
64 	if (gsi != -1)
65 		hlist_for_each_entry_rcu(kian, &kvm->irq_ack_notifier_list,
66 					 link)
67 			if (kian->gsi == gsi)
68 				kian->irq_acked(kian);
69 	srcu_read_unlock(&kvm->irq_srcu, idx);
70 }
71 
72 void kvm_register_irq_ack_notifier(struct kvm *kvm,
73 				   struct kvm_irq_ack_notifier *kian)
74 {
75 	mutex_lock(&kvm->irq_lock);
76 	hlist_add_head_rcu(&kian->link, &kvm->irq_ack_notifier_list);
77 	mutex_unlock(&kvm->irq_lock);
78 #ifdef __KVM_HAVE_IOAPIC
79 	kvm_vcpu_request_scan_ioapic(kvm);
80 #endif
81 }
82 
83 void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
84 				    struct kvm_irq_ack_notifier *kian)
85 {
86 	mutex_lock(&kvm->irq_lock);
87 	hlist_del_init_rcu(&kian->link);
88 	mutex_unlock(&kvm->irq_lock);
89 	synchronize_srcu(&kvm->irq_srcu);
90 #ifdef __KVM_HAVE_IOAPIC
91 	kvm_vcpu_request_scan_ioapic(kvm);
92 #endif
93 }
94 
95 int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
96 {
97 	struct kvm_kernel_irq_routing_entry route;
98 
99 	if (!irqchip_in_kernel(kvm) || msi->flags != 0)
100 		return -EINVAL;
101 
102 	route.msi.address_lo = msi->address_lo;
103 	route.msi.address_hi = msi->address_hi;
104 	route.msi.data = msi->data;
105 
106 	return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
107 }
108 
109 /*
110  * Return value:
111  *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
112  *  = 0   Interrupt was coalesced (previous irq is still pending)
113  *  > 0   Number of CPUs interrupt was delivered to
114  */
115 int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
116 		bool line_status)
117 {
118 	struct kvm_kernel_irq_routing_entry *e, irq_set[KVM_NR_IRQCHIPS];
119 	int ret = -1, i = 0, idx;
120 	struct kvm_irq_routing_table *irq_rt;
121 
122 	trace_kvm_set_irq(irq, level, irq_source_id);
123 
124 	/* Not possible to detect if the guest uses the PIC or the
125 	 * IOAPIC.  So set the bit in both. The guest will ignore
126 	 * writes to the unused one.
127 	 */
128 	idx = srcu_read_lock(&kvm->irq_srcu);
129 	irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
130 	if (irq < irq_rt->nr_rt_entries)
131 		hlist_for_each_entry(e, &irq_rt->map[irq], link)
132 			irq_set[i++] = *e;
133 	srcu_read_unlock(&kvm->irq_srcu, idx);
134 
135 	while(i--) {
136 		int r;
137 		r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
138 				   line_status);
139 		if (r < 0)
140 			continue;
141 
142 		ret = r + ((ret < 0) ? 0 : ret);
143 	}
144 
145 	return ret;
146 }
147 
148 void kvm_free_irq_routing(struct kvm *kvm)
149 {
150 	/* Called only during vm destruction. Nobody can use the pointer
151 	   at this stage */
152 	kfree(kvm->irq_routing);
153 }
154 
155 static int setup_routing_entry(struct kvm_irq_routing_table *rt,
156 			       struct kvm_kernel_irq_routing_entry *e,
157 			       const struct kvm_irq_routing_entry *ue)
158 {
159 	int r = -EINVAL;
160 	struct kvm_kernel_irq_routing_entry *ei;
161 
162 	/*
163 	 * Do not allow GSI to be mapped to the same irqchip more than once.
164 	 * Allow only one to one mapping between GSI and MSI.
165 	 */
166 	hlist_for_each_entry(ei, &rt->map[ue->gsi], link)
167 		if (ei->type == KVM_IRQ_ROUTING_MSI ||
168 		    ue->type == KVM_IRQ_ROUTING_MSI ||
169 		    ue->u.irqchip.irqchip == ei->irqchip.irqchip)
170 			return r;
171 
172 	e->gsi = ue->gsi;
173 	e->type = ue->type;
174 	r = kvm_set_routing_entry(rt, e, ue);
175 	if (r)
176 		goto out;
177 
178 	hlist_add_head(&e->link, &rt->map[e->gsi]);
179 	r = 0;
180 out:
181 	return r;
182 }
183 
184 int kvm_set_irq_routing(struct kvm *kvm,
185 			const struct kvm_irq_routing_entry *ue,
186 			unsigned nr,
187 			unsigned flags)
188 {
189 	struct kvm_irq_routing_table *new, *old;
190 	u32 i, j, nr_rt_entries = 0;
191 	int r;
192 
193 	for (i = 0; i < nr; ++i) {
194 		if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
195 			return -EINVAL;
196 		nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
197 	}
198 
199 	nr_rt_entries += 1;
200 
201 	new = kzalloc(sizeof(*new) + (nr_rt_entries * sizeof(struct hlist_head))
202 		      + (nr * sizeof(struct kvm_kernel_irq_routing_entry)),
203 		      GFP_KERNEL);
204 
205 	if (!new)
206 		return -ENOMEM;
207 
208 	new->rt_entries = (void *)&new->map[nr_rt_entries];
209 
210 	new->nr_rt_entries = nr_rt_entries;
211 	for (i = 0; i < KVM_NR_IRQCHIPS; i++)
212 		for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
213 			new->chip[i][j] = -1;
214 
215 	for (i = 0; i < nr; ++i) {
216 		r = -EINVAL;
217 		if (ue->flags)
218 			goto out;
219 		r = setup_routing_entry(new, &new->rt_entries[i], ue);
220 		if (r)
221 			goto out;
222 		++ue;
223 	}
224 
225 	mutex_lock(&kvm->irq_lock);
226 	old = kvm->irq_routing;
227 	kvm_irq_routing_update(kvm, new);
228 	mutex_unlock(&kvm->irq_lock);
229 
230 	synchronize_srcu_expedited(&kvm->irq_srcu);
231 
232 	new = old;
233 	r = 0;
234 
235 out:
236 	kfree(new);
237 	return r;
238 }
239