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/export.h>
 30#include <trace/events/kvm.h>
 31#include "irq.h"
 32
 33bool kvm_irq_has_notifier(struct kvm *kvm, unsigned irqchip, unsigned pin)
 34{
 35	struct kvm_irq_ack_notifier *kian;
 36	int gsi;
 37
 38	rcu_read_lock();
 39	gsi = rcu_dereference(kvm->irq_routing)->chip[irqchip][pin];
 40	if (gsi != -1)
 41		hlist_for_each_entry_rcu(kian, &kvm->irq_ack_notifier_list,
 42					 link)
 43			if (kian->gsi == gsi) {
 44				rcu_read_unlock();
 45				return true;
 46			}
 47
 48	rcu_read_unlock();
 49
 50	return false;
 51}
 52EXPORT_SYMBOL_GPL(kvm_irq_has_notifier);
 53
 54void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
 55{
 56	struct kvm_irq_ack_notifier *kian;
 57	int gsi;
 58
 59	trace_kvm_ack_irq(irqchip, pin);
 60
 61	rcu_read_lock();
 62	gsi = rcu_dereference(kvm->irq_routing)->chip[irqchip][pin];
 63	if (gsi != -1)
 64		hlist_for_each_entry_rcu(kian, &kvm->irq_ack_notifier_list,
 65					 link)
 66			if (kian->gsi == gsi)
 67				kian->irq_acked(kian);
 68	rcu_read_unlock();
 69}
 70
 71void kvm_register_irq_ack_notifier(struct kvm *kvm,
 72				   struct kvm_irq_ack_notifier *kian)
 73{
 74	mutex_lock(&kvm->irq_lock);
 75	hlist_add_head_rcu(&kian->link, &kvm->irq_ack_notifier_list);
 76	mutex_unlock(&kvm->irq_lock);
 77#ifdef __KVM_HAVE_IOAPIC
 78	kvm_vcpu_request_scan_ioapic(kvm);
 79#endif
 80}
 81
 82void kvm_unregister_irq_ack_notifier(struct kvm *kvm,
 83				    struct kvm_irq_ack_notifier *kian)
 84{
 85	mutex_lock(&kvm->irq_lock);
 86	hlist_del_init_rcu(&kian->link);
 87	mutex_unlock(&kvm->irq_lock);
 88	synchronize_rcu();
 89#ifdef __KVM_HAVE_IOAPIC
 90	kvm_vcpu_request_scan_ioapic(kvm);
 91#endif
 92}
 93
 94int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
 95{
 96	struct kvm_kernel_irq_routing_entry route;
 97
 98	if (!irqchip_in_kernel(kvm) || msi->flags != 0)
 99		return -EINVAL;
100
101	route.msi.address_lo = msi->address_lo;
102	route.msi.address_hi = msi->address_hi;
103	route.msi.data = msi->data;
104
105	return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
106}
107
108/*
109 * Return value:
110 *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
111 *  = 0   Interrupt was coalesced (previous irq is still pending)
112 *  > 0   Number of CPUs interrupt was delivered to
113 */
114int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
115		bool line_status)
116{
117	struct kvm_kernel_irq_routing_entry *e, irq_set[KVM_NR_IRQCHIPS];
118	int ret = -1, i = 0;
119	struct kvm_irq_routing_table *irq_rt;
120
121	trace_kvm_set_irq(irq, level, irq_source_id);
122
123	/* Not possible to detect if the guest uses the PIC or the
124	 * IOAPIC.  So set the bit in both. The guest will ignore
125	 * writes to the unused one.
126	 */
127	rcu_read_lock();
128	irq_rt = rcu_dereference(kvm->irq_routing);
129	if (irq < irq_rt->nr_rt_entries)
130		hlist_for_each_entry(e, &irq_rt->map[irq], link)
131			irq_set[i++] = *e;
132	rcu_read_unlock();
133
134	while(i--) {
135		int r;
136		r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
137				   line_status);
138		if (r < 0)
139			continue;
140
141		ret = r + ((ret < 0) ? 0 : ret);
142	}
143
144	return ret;
145}
146
147void kvm_free_irq_routing(struct kvm *kvm)
148{
149	/* Called only during vm destruction. Nobody can use the pointer
150	   at this stage */
151	kfree(kvm->irq_routing);
152}
153
154static int setup_routing_entry(struct kvm_irq_routing_table *rt,
155			       struct kvm_kernel_irq_routing_entry *e,
156			       const struct kvm_irq_routing_entry *ue)
157{
158	int r = -EINVAL;
159	struct kvm_kernel_irq_routing_entry *ei;
160
161	/*
162	 * Do not allow GSI to be mapped to the same irqchip more than once.
163	 * Allow only one to one mapping between GSI and MSI.
164	 */
165	hlist_for_each_entry(ei, &rt->map[ue->gsi], link)
166		if (ei->type == KVM_IRQ_ROUTING_MSI ||
167		    ue->type == KVM_IRQ_ROUTING_MSI ||
168		    ue->u.irqchip.irqchip == ei->irqchip.irqchip)
169			return r;
170
171	e->gsi = ue->gsi;
172	e->type = ue->type;
173	r = kvm_set_routing_entry(rt, e, ue);
174	if (r)
175		goto out;
176
177	hlist_add_head(&e->link, &rt->map[e->gsi]);
178	r = 0;
179out:
180	return r;
181}
182
183int kvm_set_irq_routing(struct kvm *kvm,
184			const struct kvm_irq_routing_entry *ue,
185			unsigned nr,
186			unsigned flags)
187{
188	struct kvm_irq_routing_table *new, *old;
189	u32 i, j, nr_rt_entries = 0;
190	int r;
191
192	for (i = 0; i < nr; ++i) {
193		if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
194			return -EINVAL;
195		nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
196	}
197
198	nr_rt_entries += 1;
199
200	new = kzalloc(sizeof(*new) + (nr_rt_entries * sizeof(struct hlist_head))
201		      + (nr * sizeof(struct kvm_kernel_irq_routing_entry)),
202		      GFP_KERNEL);
203
204	if (!new)
205		return -ENOMEM;
206
207	new->rt_entries = (void *)&new->map[nr_rt_entries];
208
209	new->nr_rt_entries = nr_rt_entries;
210	for (i = 0; i < KVM_NR_IRQCHIPS; i++)
211		for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
212			new->chip[i][j] = -1;
213
214	for (i = 0; i < nr; ++i) {
215		r = -EINVAL;
216		if (ue->flags)
217			goto out;
218		r = setup_routing_entry(new, &new->rt_entries[i], ue);
219		if (r)
220			goto out;
221		++ue;
222	}
223
224	mutex_lock(&kvm->irq_lock);
225	old = kvm->irq_routing;
226	kvm_irq_routing_update(kvm, new);
227	mutex_unlock(&kvm->irq_lock);
228
229	synchronize_rcu();
230
231	new = old;
232	r = 0;
233
234out:
235	kfree(new);
236	return r;
237}