virt: IRQ bypass manager

When a physical I/O device is assigned to a virtual machine through
facilities like VFIO and KVM, the interrupt for the device generally
bounces through the host system before being injected into the VM.
However, hardware technologies exist that often allow the host to be
bypassed for some of these scenarios.  Intel Posted Interrupts allow
the specified physical edge interrupts to be directly injected into a
guest when delivered to a physical processor while the vCPU is
running.  ARM IRQ Forwarding allows forwarded physical interrupts to
be directly deactivated by the guest.

The IRQ bypass manager here is meant to provide the shim to connect
interrupt producers, generally the host physical device driver, with
interrupt consumers, generally the hypervisor, in order to configure
these bypass mechanism.  To do this, we base the connection on a
shared, opaque token.  For KVM-VFIO this is expected to be an
eventfd_ctx since this is the connection we already use to connect an
eventfd to an irqfd on the in-kernel path.  When a producer and
consumer with matching tokens is found, callbacks via both registered
participants allow the bypass facilities to be automatically enabled.

Signed-off-by: Alex Williamson <alex.williamson@redhat.com>
Reviewed-by: Eric Auger <eric.auger@linaro.org>
Tested-by: Eric Auger <eric.auger@linaro.org>
Tested-by: Feng Wu <feng.wu@intel.com>
Signed-off-by: Feng Wu <feng.wu@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

3 files changed, 260 insertions, 0 deletions

diff --git a/virt/lib/Kconfig b/virt/lib/Kconfig
new file mode 100644
index 000000000000..89a414f815d2
--- /dev/null
+++ b/virt/lib/Kconfig
@@ -0,0 +1,2 @@
+config IRQ_BYPASS_MANAGER
+        tristate
diff --git a/virt/lib/Makefile b/virt/lib/Makefile
new file mode 100644
index 000000000000..901228d1ffbc
--- /dev/null
+++ b/virt/lib/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
diff --git a/virt/lib/irqbypass.c b/virt/lib/irqbypass.c
new file mode 100644
index 000000000000..09a03b5a21ff
--- /dev/null
+++ b/virt/lib/irqbypass.c
@@ -0,0 +1,257 @@
+/*
+ * IRQ offload/bypass manager
+ *
+ * Copyright (C) 2015 Red Hat, Inc.
+ * Copyright (c) 2015 Linaro Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Various virtualization hardware acceleration techniques allow bypassing or
+ * offloading interrupts received from devices around the host kernel.  Posted
+ * Interrupts on Intel VT-d systems can allow interrupts to be received
+ * directly by a virtual machine.  ARM IRQ Forwarding allows forwarded physical
+ * interrupts to be directly deactivated by the guest.  This manager allows
+ * interrupt producers and consumers to find each other to enable this sort of
+ * bypass.
+ */
+
+#include <linux/irqbypass.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("IRQ bypass manager utility module");
+
+static LIST_HEAD(producers);
+static LIST_HEAD(consumers);
+static DEFINE_MUTEX(lock);
+
+/* @lock must be held when calling connect */
+static int __connect(struct irq_bypass_producer *prod,
+                     struct irq_bypass_consumer *cons)
+{
+        int ret = 0;
+
+        if (prod->stop)
+                prod->stop(prod);
+        if (cons->stop)
+                cons->stop(cons);
+
+        if (prod->add_consumer)
+                ret = prod->add_consumer(prod, cons);
+
+        if (!ret) {
+                ret = cons->add_producer(cons, prod);
+                if (ret && prod->del_consumer)
+                        prod->del_consumer(prod, cons);
+        }
+
+        if (cons->start)
+                cons->start(cons);
+        if (prod->start)
+                prod->start(prod);
+
+        return ret;
+}
+
+/* @lock must be held when calling disconnect */
+static void __disconnect(struct irq_bypass_producer *prod,
+                         struct irq_bypass_consumer *cons)
+{
+        if (prod->stop)
+                prod->stop(prod);
+        if (cons->stop)
+                cons->stop(cons);
+
+        cons->del_producer(cons, prod);
+
+        if (prod->del_consumer)
+                prod->del_consumer(prod, cons);
+
+        if (cons->start)
+                cons->start(cons);
+        if (prod->start)
+                prod->start(prod);
+}
+
+/**
+ * irq_bypass_register_producer - register IRQ bypass producer
+ * @producer: pointer to producer structure
+ *
+ * Add the provided IRQ producer to the list of producers and connect
+ * with any matching token found on the IRQ consumers list.
+ */
+int irq_bypass_register_producer(struct irq_bypass_producer *producer)
+{
+        struct irq_bypass_producer *tmp;
+        struct irq_bypass_consumer *consumer;
+
+        might_sleep();
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        mutex_lock(&lock);
+
+        list_for_each_entry(tmp, &producers, node) {
+                if (tmp->token == producer->token) {
+                        mutex_unlock(&lock);
+                        module_put(THIS_MODULE);
+                        return -EBUSY;
+                }
+        }
+
+        list_for_each_entry(consumer, &consumers, node) {
+                if (consumer->token == producer->token) {
+                        int ret = __connect(producer, consumer);
+                        if (ret) {
+                                mutex_unlock(&lock);
+                                module_put(THIS_MODULE);
+                                return ret;
+                        }
+                        break;
+                }
+        }
+
+        list_add(&producer->node, &producers);
+
+        mutex_unlock(&lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(irq_bypass_register_producer);
+
+/**
+ * irq_bypass_unregister_producer - unregister IRQ bypass producer
+ * @producer: pointer to producer structure
+ *
+ * Remove a previously registered IRQ producer from the list of producers
+ * and disconnect it from any connected IRQ consumer.
+ */
+void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
+{
+        struct irq_bypass_producer *tmp;
+        struct irq_bypass_consumer *consumer;
+
+        might_sleep();
+
+        if (!try_module_get(THIS_MODULE))
+                return; /* nothing in the list anyway */
+
+        mutex_lock(&lock);
+
+        list_for_each_entry(tmp, &producers, node) {
+                if (tmp->token != producer->token)
+                        continue;
+
+                list_for_each_entry(consumer, &consumers, node) {
+                        if (consumer->token == producer->token) {
+                                __disconnect(producer, consumer);
+                                break;
+                        }
+                }
+
+                list_del(&producer->node);
+                module_put(THIS_MODULE);
+                break;
+        }
+
+        mutex_unlock(&lock);
+
+        module_put(THIS_MODULE);
+}
+EXPORT_SYMBOL_GPL(irq_bypass_unregister_producer);
+
+/**
+ * irq_bypass_register_consumer - register IRQ bypass consumer
+ * @consumer: pointer to consumer structure
+ *
+ * Add the provided IRQ consumer to the list of consumers and connect
+ * with any matching token found on the IRQ producer list.
+ */
+int irq_bypass_register_consumer(struct irq_bypass_consumer *consumer)
+{
+        struct irq_bypass_consumer *tmp;
+        struct irq_bypass_producer *producer;
+
+        if (!consumer->add_producer || !consumer->del_producer)
+                return -EINVAL;
+
+        might_sleep();
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        mutex_lock(&lock);
+
+        list_for_each_entry(tmp, &consumers, node) {
+                if (tmp->token == consumer->token) {
+                        mutex_unlock(&lock);
+                        module_put(THIS_MODULE);
+                        return -EBUSY;
+                }
+        }
+
+        list_for_each_entry(producer, &producers, node) {
+                if (producer->token == consumer->token) {
+                        int ret = __connect(producer, consumer);
+                        if (ret) {
+                                mutex_unlock(&lock);
+                                module_put(THIS_MODULE);
+                                return ret;
+                        }
+                        break;
+                }
+        }
+
+        list_add(&consumer->node, &consumers);
+
+        mutex_unlock(&lock);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(irq_bypass_register_consumer);
+
+/**
+ * irq_bypass_unregister_consumer - unregister IRQ bypass consumer
+ * @consumer: pointer to consumer structure
+ *
+ * Remove a previously registered IRQ consumer from the list of consumers
+ * and disconnect it from any connected IRQ producer.
+ */
+void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer)
+{
+        struct irq_bypass_consumer *tmp;
+        struct irq_bypass_producer *producer;
+
+        might_sleep();
+
+        if (!try_module_get(THIS_MODULE))
+                return; /* nothing in the list anyway */
+
+        mutex_lock(&lock);
+
+        list_for_each_entry(tmp, &consumers, node) {
+                if (tmp->token != consumer->token)
+                        continue;
+
+                list_for_each_entry(producer, &producers, node) {
+                        if (producer->token == consumer->token) {
+                                __disconnect(producer, consumer);
+                                break;
+                        }
+                }
+
+                list_del(&consumer->node);
+                module_put(THIS_MODULE);
+                break;
+        }
+
+        mutex_unlock(&lock);
+
+        module_put(THIS_MODULE);
+}
+EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);