1 files changed, 284 insertions, 13 deletions
diff --git a/virt/kvm/irq_comm.c b/virt/kvm/irq_comm.c
index aa5d1e5c497e..864ac5483baa 100644
--- a/virt/kvm/irq_comm.c
+++ b/virt/kvm/irq_comm.c
@@ -20,35 +20,132 @@
 */
 #include <linux/kvm_host.h>
+#include <asm/msidef.h>
 #include "irq.h"
 #include "ioapic.h"
-/* This should be called with the kvm->lock mutex held */
+static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
-void kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level)
+                           struct kvm *kvm, int level)
+{
+#ifdef CONFIG_X86
+        return kvm_pic_set_irq(pic_irqchip(kvm), e->irqchip.pin, level);
+#else
+        return -1;
+#endif
+}
+static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
+                              struct kvm *kvm, int level)
+{
+        return kvm_ioapic_set_irq(kvm->arch.vioapic, e->irqchip.pin, level);
+}
+static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
+                       struct kvm *kvm, int level)
+{
+        int vcpu_id, r = -1;
+        struct kvm_vcpu *vcpu;
+        struct kvm_ioapic *ioapic = ioapic_irqchip(kvm);
+        int dest_id = (e->msi.address_lo & MSI_ADDR_DEST_ID_MASK)
+                        >> MSI_ADDR_DEST_ID_SHIFT;
+        int vector = (e->msi.data & MSI_DATA_VECTOR_MASK)
+                        >> MSI_DATA_VECTOR_SHIFT;
+        int dest_mode = test_bit(MSI_ADDR_DEST_MODE_SHIFT,
+                                (unsigned long *)&e->msi.address_lo);
+        int trig_mode = test_bit(MSI_DATA_TRIGGER_SHIFT,
+                                (unsigned long *)&e->msi.data);
+        int delivery_mode = test_bit(MSI_DATA_DELIVERY_MODE_SHIFT,
+                                (unsigned long *)&e->msi.data);
+        u32 deliver_bitmask;
+        BUG_ON(!ioapic);
+        deliver_bitmask = kvm_ioapic_get_delivery_bitmask(ioapic,
+                                dest_id, dest_mode);
+        /* IOAPIC delivery mode value is the same as MSI here */
+        switch (delivery_mode) {
+        case IOAPIC_LOWEST_PRIORITY:
+                vcpu = kvm_get_lowest_prio_vcpu(ioapic->kvm, vector,
+                                deliver_bitmask);
+                if (vcpu != NULL)
+                        r = kvm_apic_set_irq(vcpu, vector, trig_mode);
+                else
+                        printk(KERN_INFO "kvm: null lowest priority vcpu!\n");
+                break;
+        case IOAPIC_FIXED:
+                for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
+                        if (!(deliver_bitmask & (1 << vcpu_id)))
+                                continue;
+                        deliver_bitmask &= ~(1 << vcpu_id);
+                        vcpu = ioapic->kvm->vcpus[vcpu_id];
+                        if (vcpu) {
+                                if (r < 0)
+                                        r = 0;
+                                r += kvm_apic_set_irq(vcpu, vector, trig_mode);
+                        }
+                }
+                break;
+        default:
+                break;
+        }
+        return r;
+}
+/* This should be called with the kvm->lock mutex held
+ * Return value:
+ *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
+ *  = 0   Interrupt was coalesced (previous irq is still pending)
+ *  > 0   Number of CPUs interrupt was delivered to
+ */
+int kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level)
 {
-        unsigned long *irq_state = (unsigned long *)&kvm->arch.irq_states[irq];
+        struct kvm_kernel_irq_routing_entry *e;
+        unsigned long *irq_state, sig_level;
+        int ret = -1;
+        if (irq < KVM_IOAPIC_NUM_PINS) {
+                irq_state = (unsigned long *)&kvm->arch.irq_states[irq];
-        /* Logical OR for level trig interrupt */
+                /* Logical OR for level trig interrupt */
-        if (level)
+                if (level)
-                set_bit(irq_source_id, irq_state);
+                        set_bit(irq_source_id, irq_state);
-        else
+                else
-                clear_bit(irq_source_id, irq_state);
+                        clear_bit(irq_source_id, irq_state);
+                sig_level = !!(*irq_state);
+        } else /* Deal with MSI/MSI-X */
+                sig_level = 1;
        /* Not possible to detect if the guest uses the PIC or the
         * IOAPIC.  So set the bit in both. The guest will ignore
         * writes to the unused one.
         */
-        kvm_ioapic_set_irq(kvm->arch.vioapic, irq, !!(*irq_state));
+        list_for_each_entry(e, &kvm->irq_routing, link)
-#ifdef CONFIG_X86
+                if (e->gsi == irq) {
-        kvm_pic_set_irq(pic_irqchip(kvm), irq, !!(*irq_state));
+                        int r = e->set(e, kvm, sig_level);
-#endif
+                        if (r < 0)
+                                continue;
+                        ret = r + ((ret < 0) ? 0 : ret);
+                }
+        return ret;
 }
-void kvm_notify_acked_irq(struct kvm *kvm, unsigned gsi)
+void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
 {
+        struct kvm_kernel_irq_routing_entry *e;
        struct kvm_irq_ack_notifier *kian;
        struct hlist_node *n;
+        unsigned gsi = pin;
+        list_for_each_entry(e, &kvm->irq_routing, link)
+                if (e->irqchip.irqchip == irqchip &&
+                    e->irqchip.pin == pin) {
+                        gsi = e->gsi;
+                        break;
+                }
        hlist_for_each_entry(kian, n, &kvm->arch.irq_ack_notifier_list, link)
                if (kian->gsi == gsi)
@@ -99,3 +196,177 @@ void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id)
                clear_bit(irq_source_id, &kvm->arch.irq_states[i]);
        clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap);
 }
+void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
+                                    struct kvm_irq_mask_notifier *kimn)
+{
+        kimn->irq = irq;
+        hlist_add_head(&kimn->link, &kvm->mask_notifier_list);
+}
+void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
+                                      struct kvm_irq_mask_notifier *kimn)
+{
+        hlist_del(&kimn->link);
+}
+void kvm_fire_mask_notifiers(struct kvm *kvm, int irq, bool mask)
+{
+        struct kvm_irq_mask_notifier *kimn;
+        struct hlist_node *n;
+        hlist_for_each_entry(kimn, n, &kvm->mask_notifier_list, link)
+                if (kimn->irq == irq)
+                        kimn->func(kimn, mask);
+}
+static void __kvm_free_irq_routing(struct list_head *irq_routing)
+{
+        struct kvm_kernel_irq_routing_entry *e, *n;
+        list_for_each_entry_safe(e, n, irq_routing, link)
+                kfree(e);
+}
+void kvm_free_irq_routing(struct kvm *kvm)
+{
+        __kvm_free_irq_routing(&kvm->irq_routing);
+}
+static int setup_routing_entry(struct kvm_kernel_irq_routing_entry *e,
+                               const struct kvm_irq_routing_entry *ue)
+{
+        int r = -EINVAL;
+        int delta;
+        e->gsi = ue->gsi;
+        switch (ue->type) {
+        case KVM_IRQ_ROUTING_IRQCHIP:
+                delta = 0;
+                switch (ue->u.irqchip.irqchip) {
+                case KVM_IRQCHIP_PIC_MASTER:
+                        e->set = kvm_set_pic_irq;
+                        break;
+                case KVM_IRQCHIP_PIC_SLAVE:
+                        e->set = kvm_set_pic_irq;
+                        delta = 8;
+                        break;
+                case KVM_IRQCHIP_IOAPIC:
+                                e->set = kvm_set_ioapic_irq;
+                        break;
+                default:
+                        goto out;
+                }
+                e->irqchip.irqchip = ue->u.irqchip.irqchip;
+                e->irqchip.pin = ue->u.irqchip.pin + delta;
+                break;
+        case KVM_IRQ_ROUTING_MSI:
+                e->set = kvm_set_msi;
+                e->msi.address_lo = ue->u.msi.address_lo;
+                e->msi.address_hi = ue->u.msi.address_hi;
+                e->msi.data = ue->u.msi.data;
+                break;
+        default:
+                goto out;
+        }
+        r = 0;
+out:
+        return r;
+}
+int kvm_set_irq_routing(struct kvm *kvm,
+                        const struct kvm_irq_routing_entry *ue,
+                        unsigned nr,
+                        unsigned flags)
+{
+        struct list_head irq_list = LIST_HEAD_INIT(irq_list);
+        struct list_head tmp = LIST_HEAD_INIT(tmp);
+        struct kvm_kernel_irq_routing_entry *e = NULL;
+        unsigned i;
+        int r;
+        for (i = 0; i < nr; ++i) {
+                r = -EINVAL;
+                if (ue->gsi >= KVM_MAX_IRQ_ROUTES)
+                        goto out;
+                if (ue->flags)
+                        goto out;
+                r = -ENOMEM;
+                e = kzalloc(sizeof(*e), GFP_KERNEL);
+                if (!e)
+                        goto out;
+                r = setup_routing_entry(e, ue);
+                if (r)
+                        goto out;
+                ++ue;
+                list_add(&e->link, &irq_list);
+                e = NULL;
+        }
+        mutex_lock(&kvm->lock);
+        list_splice(&kvm->irq_routing, &tmp);
+        INIT_LIST_HEAD(&kvm->irq_routing);
+        list_splice(&irq_list, &kvm->irq_routing);
+        INIT_LIST_HEAD(&irq_list);
+        list_splice(&tmp, &irq_list);
+        mutex_unlock(&kvm->lock);
+        r = 0;
+out:
+        kfree(e);
+        __kvm_free_irq_routing(&irq_list);
+        return r;
+}
+#define IOAPIC_ROUTING_ENTRY(irq) \
+        { .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP,  \
+          .u.irqchip.irqchip = KVM_IRQCHIP_IOAPIC, .u.irqchip.pin = (irq) }
+#define ROUTING_ENTRY1(irq) IOAPIC_ROUTING_ENTRY(irq)
+#ifdef CONFIG_X86
+#  define PIC_ROUTING_ENTRY(irq) \
+        { .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP,  \
+          .u.irqchip.irqchip = SELECT_PIC(irq), .u.irqchip.pin = (irq) % 8 }
+#  define ROUTING_ENTRY2(irq) \
+        IOAPIC_ROUTING_ENTRY(irq), PIC_ROUTING_ENTRY(irq)
+#else
+#  define ROUTING_ENTRY2(irq) \
+        IOAPIC_ROUTING_ENTRY(irq)
+#endif
+static const struct kvm_irq_routing_entry default_routing[] = {
+        ROUTING_ENTRY2(0), ROUTING_ENTRY2(1),
+        ROUTING_ENTRY2(2), ROUTING_ENTRY2(3),
+        ROUTING_ENTRY2(4), ROUTING_ENTRY2(5),
+        ROUTING_ENTRY2(6), ROUTING_ENTRY2(7),
+        ROUTING_ENTRY2(8), ROUTING_ENTRY2(9),
+        ROUTING_ENTRY2(10), ROUTING_ENTRY2(11),
+        ROUTING_ENTRY2(12), ROUTING_ENTRY2(13),
+        ROUTING_ENTRY2(14), ROUTING_ENTRY2(15),
+        ROUTING_ENTRY1(16), ROUTING_ENTRY1(17),
+        ROUTING_ENTRY1(18), ROUTING_ENTRY1(19),
+        ROUTING_ENTRY1(20), ROUTING_ENTRY1(21),
+        ROUTING_ENTRY1(22), ROUTING_ENTRY1(23),
+#ifdef CONFIG_IA64
+        ROUTING_ENTRY1(24), ROUTING_ENTRY1(25),
+        ROUTING_ENTRY1(26), ROUTING_ENTRY1(27),
+        ROUTING_ENTRY1(28), ROUTING_ENTRY1(29),
+        ROUTING_ENTRY1(30), ROUTING_ENTRY1(31),
+        ROUTING_ENTRY1(32), ROUTING_ENTRY1(33),
+        ROUTING_ENTRY1(34), ROUTING_ENTRY1(35),
+        ROUTING_ENTRY1(36), ROUTING_ENTRY1(37),
+        ROUTING_ENTRY1(38), ROUTING_ENTRY1(39),
+        ROUTING_ENTRY1(40), ROUTING_ENTRY1(41),
+        ROUTING_ENTRY1(42), ROUTING_ENTRY1(43),
+        ROUTING_ENTRY1(44), ROUTING_ENTRY1(45),
+        ROUTING_ENTRY1(46), ROUTING_ENTRY1(47),
+#endif
+};
+int kvm_setup_default_irq_routing(struct kvm *kvm)
+{
+        return kvm_set_irq_routing(kvm, default_routing,
+                                   ARRAY_SIZE(default_routing), 0);
+}

diff --git a/virt/kvm/irq_comm.c b/virt/kvm/irq_comm.c index aa5d1e5c497e..864ac5483baa 100644 --- a/virt/kvm/irq_comm.c +++ b/virt/kvm/irq_comm.c
@@ -20,35 +20,132 @@
20	*/	20	*/
21		21
22	#include <linux/kvm_host.h>	22	#include <linux/kvm_host.h>
		23
		24	#include <asm/msidef.h>
		25
23	#include "irq.h"	26	#include "irq.h"
24		27
25	#include "ioapic.h"	28	#include "ioapic.h"
26		29
27	/* This should be called with the kvm->lock mutex held */	30	static int kvm_set_pic_irq(struct kvm_kernel_irq_routing_entry *e,
28	void kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level)	31	struct kvm *kvm, int level)
		32	{
		33	#ifdef CONFIG_X86
		34	return kvm_pic_set_irq(pic_irqchip(kvm), e->irqchip.pin, level);
		35	#else
		36	return -1;
		37	#endif
		38	}
		39
		40	static int kvm_set_ioapic_irq(struct kvm_kernel_irq_routing_entry *e,
		41	struct kvm *kvm, int level)
		42	{
		43	return kvm_ioapic_set_irq(kvm->arch.vioapic, e->irqchip.pin, level);
		44	}
		45
		46	static int kvm_set_msi(struct kvm_kernel_irq_routing_entry *e,
		47	struct kvm *kvm, int level)
		48	{
		49	int vcpu_id, r = -1;
		50	struct kvm_vcpu *vcpu;
		51	struct kvm_ioapic *ioapic = ioapic_irqchip(kvm);
		52	int dest_id = (e->msi.address_lo & MSI_ADDR_DEST_ID_MASK)
		53	>> MSI_ADDR_DEST_ID_SHIFT;
		54	int vector = (e->msi.data & MSI_DATA_VECTOR_MASK)
		55	>> MSI_DATA_VECTOR_SHIFT;
		56	int dest_mode = test_bit(MSI_ADDR_DEST_MODE_SHIFT,
		57	(unsigned long *)&e->msi.address_lo);
		58	int trig_mode = test_bit(MSI_DATA_TRIGGER_SHIFT,
		59	(unsigned long *)&e->msi.data);
		60	int delivery_mode = test_bit(MSI_DATA_DELIVERY_MODE_SHIFT,
		61	(unsigned long *)&e->msi.data);
		62	u32 deliver_bitmask;
		63
		64	BUG_ON(!ioapic);
		65
		66	deliver_bitmask = kvm_ioapic_get_delivery_bitmask(ioapic,
		67	dest_id, dest_mode);
		68	/* IOAPIC delivery mode value is the same as MSI here */
		69	switch (delivery_mode) {
		70	case IOAPIC_LOWEST_PRIORITY:
		71	vcpu = kvm_get_lowest_prio_vcpu(ioapic->kvm, vector,
		72	deliver_bitmask);
		73	if (vcpu != NULL)
		74	r = kvm_apic_set_irq(vcpu, vector, trig_mode);
		75	else
		76	printk(KERN_INFO "kvm: null lowest priority vcpu!\n");
		77	break;
		78	case IOAPIC_FIXED:
		79	for (vcpu_id = 0; deliver_bitmask != 0; vcpu_id++) {
		80	if (!(deliver_bitmask & (1 << vcpu_id)))
		81	continue;
		82	deliver_bitmask &= ~(1 << vcpu_id);
		83	vcpu = ioapic->kvm->vcpus[vcpu_id];
		84	if (vcpu) {
		85	if (r < 0)
		86	r = 0;
		87	r += kvm_apic_set_irq(vcpu, vector, trig_mode);
		88	}
		89	}
		90	break;
		91	default:
		92	break;
		93	}
		94	return r;
		95	}
		96
		97	/* This should be called with the kvm->lock mutex held
		98	* Return value:
		99	* < 0 Interrupt was ignored (masked or not delivered for other reasons)
		100	* = 0 Interrupt was coalesced (previous irq is still pending)
		101	* > 0 Number of CPUs interrupt was delivered to
		102	*/
		103	int kvm_set_irq(struct kvm *kvm, int irq_source_id, int irq, int level)
29	{	104	{
30	unsigned long irq_state = (unsigned long )&kvm->arch.irq_states[irq];	105	struct kvm_kernel_irq_routing_entry *e;
		106	unsigned long *irq_state, sig_level;
		107	int ret = -1;
		108
		109	if (irq < KVM_IOAPIC_NUM_PINS) {
		110	irq_state = (unsigned long *)&kvm->arch.irq_states[irq];
31		111
32	/* Logical OR for level trig interrupt */	112	/* Logical OR for level trig interrupt */
33	if (level)	113	if (level)
34	set_bit(irq_source_id, irq_state);	114	set_bit(irq_source_id, irq_state);
35	else	115	else
36	clear_bit(irq_source_id, irq_state);	116	clear_bit(irq_source_id, irq_state);
		117	sig_level = !!(*irq_state);
		118	} else /* Deal with MSI/MSI-X */
		119	sig_level = 1;
37		120
38	/* Not possible to detect if the guest uses the PIC or the	121	/* Not possible to detect if the guest uses the PIC or the
39	* IOAPIC. So set the bit in both. The guest will ignore	122	* IOAPIC. So set the bit in both. The guest will ignore
40	* writes to the unused one.	123	* writes to the unused one.
41	*/	124	*/
42	kvm_ioapic_set_irq(kvm->arch.vioapic, irq, !!(*irq_state));	125	list_for_each_entry(e, &kvm->irq_routing, link)
43	#ifdef CONFIG_X86	126	if (e->gsi == irq) {
44	kvm_pic_set_irq(pic_irqchip(kvm), irq, !!(*irq_state));	127	int r = e->set(e, kvm, sig_level);
45	#endif	128	if (r < 0)
		129	continue;
		130
		131	ret = r + ((ret < 0) ? 0 : ret);
		132	}
		133	return ret;
46	}	134	}
47		135
48	void kvm_notify_acked_irq(struct kvm *kvm, unsigned gsi)	136	void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin)
49	{	137	{
		138	struct kvm_kernel_irq_routing_entry *e;
50	struct kvm_irq_ack_notifier *kian;	139	struct kvm_irq_ack_notifier *kian;
51	struct hlist_node *n;	140	struct hlist_node *n;
		141	unsigned gsi = pin;
		142
		143	list_for_each_entry(e, &kvm->irq_routing, link)
		144	if (e->irqchip.irqchip == irqchip &&
		145	e->irqchip.pin == pin) {
		146	gsi = e->gsi;
		147	break;
		148	}
52		149
53	hlist_for_each_entry(kian, n, &kvm->arch.irq_ack_notifier_list, link)	150	hlist_for_each_entry(kian, n, &kvm->arch.irq_ack_notifier_list, link)
54	if (kian->gsi == gsi)	151	if (kian->gsi == gsi)
@@ -99,3 +196,177 @@ void kvm_free_irq_source_id(struct kvm *kvm, int irq_source_id)
99	clear_bit(irq_source_id, &kvm->arch.irq_states[i]);	196	clear_bit(irq_source_id, &kvm->arch.irq_states[i]);
100	clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap);	197	clear_bit(irq_source_id, &kvm->arch.irq_sources_bitmap);
101	}	198	}
		199
		200	void kvm_register_irq_mask_notifier(struct kvm *kvm, int irq,
		201	struct kvm_irq_mask_notifier *kimn)
		202	{
		203	kimn->irq = irq;
		204	hlist_add_head(&kimn->link, &kvm->mask_notifier_list);
		205	}
		206
		207	void kvm_unregister_irq_mask_notifier(struct kvm *kvm, int irq,
		208	struct kvm_irq_mask_notifier *kimn)
		209	{
		210	hlist_del(&kimn->link);
		211	}
		212
		213	void kvm_fire_mask_notifiers(struct kvm *kvm, int irq, bool mask)
		214	{
		215	struct kvm_irq_mask_notifier *kimn;
		216	struct hlist_node *n;
		217
		218	hlist_for_each_entry(kimn, n, &kvm->mask_notifier_list, link)
		219	if (kimn->irq == irq)
		220	kimn->func(kimn, mask);
		221	}
		222
		223	static void __kvm_free_irq_routing(struct list_head *irq_routing)
		224	{
		225	struct kvm_kernel_irq_routing_entry e, n;
		226
		227	list_for_each_entry_safe(e, n, irq_routing, link)
		228	kfree(e);
		229	}
		230
		231	void kvm_free_irq_routing(struct kvm *kvm)
		232	{
		233	__kvm_free_irq_routing(&kvm->irq_routing);
		234	}
		235
		236	static int setup_routing_entry(struct kvm_kernel_irq_routing_entry *e,
		237	const struct kvm_irq_routing_entry *ue)
		238	{
		239	int r = -EINVAL;
		240	int delta;
		241
		242	e->gsi = ue->gsi;
		243	switch (ue->type) {
		244	case KVM_IRQ_ROUTING_IRQCHIP:
		245	delta = 0;
		246	switch (ue->u.irqchip.irqchip) {
		247	case KVM_IRQCHIP_PIC_MASTER:
		248	e->set = kvm_set_pic_irq;
		249	break;
		250	case KVM_IRQCHIP_PIC_SLAVE:
		251	e->set = kvm_set_pic_irq;
		252	delta = 8;
		253	break;
		254	case KVM_IRQCHIP_IOAPIC:
		255	e->set = kvm_set_ioapic_irq;
		256	break;
		257	default:
		258	goto out;
		259	}
		260	e->irqchip.irqchip = ue->u.irqchip.irqchip;
		261	e->irqchip.pin = ue->u.irqchip.pin + delta;
		262	break;
		263	case KVM_IRQ_ROUTING_MSI:
		264	e->set = kvm_set_msi;
		265	e->msi.address_lo = ue->u.msi.address_lo;
		266	e->msi.address_hi = ue->u.msi.address_hi;
		267	e->msi.data = ue->u.msi.data;
		268	break;
		269	default:
		270	goto out;
		271	}
		272	r = 0;
		273	out:
		274	return r;
		275	}
		276
		277
		278	int kvm_set_irq_routing(struct kvm *kvm,
		279	const struct kvm_irq_routing_entry *ue,
		280	unsigned nr,
		281	unsigned flags)
		282	{
		283	struct list_head irq_list = LIST_HEAD_INIT(irq_list);
		284	struct list_head tmp = LIST_HEAD_INIT(tmp);
		285	struct kvm_kernel_irq_routing_entry *e = NULL;
		286	unsigned i;
		287	int r;
		288
		289	for (i = 0; i < nr; ++i) {
		290	r = -EINVAL;
		291	if (ue->gsi >= KVM_MAX_IRQ_ROUTES)
		292	goto out;
		293	if (ue->flags)
		294	goto out;
		295	r = -ENOMEM;
		296	e = kzalloc(sizeof(*e), GFP_KERNEL);
		297	if (!e)
		298	goto out;
		299	r = setup_routing_entry(e, ue);
		300	if (r)
		301	goto out;
		302	++ue;
		303	list_add(&e->link, &irq_list);
		304	e = NULL;
		305	}
		306
		307	mutex_lock(&kvm->lock);
		308	list_splice(&kvm->irq_routing, &tmp);
		309	INIT_LIST_HEAD(&kvm->irq_routing);
		310	list_splice(&irq_list, &kvm->irq_routing);
		311	INIT_LIST_HEAD(&irq_list);
		312	list_splice(&tmp, &irq_list);
		313	mutex_unlock(&kvm->lock);
		314
		315	r = 0;
		316
		317	out:
		318	kfree(e);
		319	__kvm_free_irq_routing(&irq_list);
		320	return r;
		321	}
		322
		323	#define IOAPIC_ROUTING_ENTRY(irq) \
		324	{ .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP, \
		325	.u.irqchip.irqchip = KVM_IRQCHIP_IOAPIC, .u.irqchip.pin = (irq) }
		326	#define ROUTING_ENTRY1(irq) IOAPIC_ROUTING_ENTRY(irq)
		327
		328	#ifdef CONFIG_X86
		329	# define PIC_ROUTING_ENTRY(irq) \
		330	{ .gsi = irq, .type = KVM_IRQ_ROUTING_IRQCHIP, \
		331	.u.irqchip.irqchip = SELECT_PIC(irq), .u.irqchip.pin = (irq) % 8 }
		332	# define ROUTING_ENTRY2(irq) \
		333	IOAPIC_ROUTING_ENTRY(irq), PIC_ROUTING_ENTRY(irq)
		334	#else
		335	# define ROUTING_ENTRY2(irq) \
		336	IOAPIC_ROUTING_ENTRY(irq)
		337	#endif
		338
		339	static const struct kvm_irq_routing_entry default_routing[] = {
		340	ROUTING_ENTRY2(0), ROUTING_ENTRY2(1),
		341	ROUTING_ENTRY2(2), ROUTING_ENTRY2(3),
		342	ROUTING_ENTRY2(4), ROUTING_ENTRY2(5),
		343	ROUTING_ENTRY2(6), ROUTING_ENTRY2(7),
		344	ROUTING_ENTRY2(8), ROUTING_ENTRY2(9),
		345	ROUTING_ENTRY2(10), ROUTING_ENTRY2(11),
		346	ROUTING_ENTRY2(12), ROUTING_ENTRY2(13),
		347	ROUTING_ENTRY2(14), ROUTING_ENTRY2(15),
		348	ROUTING_ENTRY1(16), ROUTING_ENTRY1(17),
		349	ROUTING_ENTRY1(18), ROUTING_ENTRY1(19),
		350	ROUTING_ENTRY1(20), ROUTING_ENTRY1(21),
		351	ROUTING_ENTRY1(22), ROUTING_ENTRY1(23),
		352	#ifdef CONFIG_IA64
		353	ROUTING_ENTRY1(24), ROUTING_ENTRY1(25),
		354	ROUTING_ENTRY1(26), ROUTING_ENTRY1(27),
		355	ROUTING_ENTRY1(28), ROUTING_ENTRY1(29),
		356	ROUTING_ENTRY1(30), ROUTING_ENTRY1(31),
		357	ROUTING_ENTRY1(32), ROUTING_ENTRY1(33),
		358	ROUTING_ENTRY1(34), ROUTING_ENTRY1(35),
		359	ROUTING_ENTRY1(36), ROUTING_ENTRY1(37),
		360	ROUTING_ENTRY1(38), ROUTING_ENTRY1(39),
		361	ROUTING_ENTRY1(40), ROUTING_ENTRY1(41),
		362	ROUTING_ENTRY1(42), ROUTING_ENTRY1(43),
		363	ROUTING_ENTRY1(44), ROUTING_ENTRY1(45),
		364	ROUTING_ENTRY1(46), ROUTING_ENTRY1(47),
		365	#endif
		366	};
		367
		368	int kvm_setup_default_irq_routing(struct kvm *kvm)
		369	{
		370	return kvm_set_irq_routing(kvm, default_routing,
		371	ARRAY_SIZE(default_routing), 0);
		372	}