Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1201211 > unrolled thread

[PATCH v3] virt: IRQ bypass manager

Back to article view | Back to linux.kernel

Contents

  [PATCH v3] virt: IRQ bypass manager Alex Williamson <alex.williamson@redhat.com> - 2015-08-06 00:10 +0200
    RE: [PATCH v3] virt: IRQ bypass manager "Wu, Feng" <feng.wu@intel.com> - 2015-08-06 04:20 +0200

#1201211 — [PATCH v3] 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>
---

v3: Fix list_for_each_entry issue noted by Eric

Do we want to revisit whether add and del are required callbacks?
Maybe they should only be required for the consumer?  If Feng already
doesn't require them for Intel PI, let's not impose stub callback
requirements.

 MAINTAINERS               |    7 +
 include/linux/irqbypass.h |   90 ++++++++++++++++
 virt/lib/Kconfig          |    2 
 virt/lib/Makefile         |    1 
 virt/lib/irqbypass.c      |  256 +++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 356 insertions(+)
 create mode 100644 include/linux/irqbypass.h
 create mode 100644 virt/lib/Kconfig
 create mode 100644 virt/lib/Makefile
 create mode 100644 virt/lib/irqbypass.c

diff --git a/MAINTAINERS b/MAINTAINERS
index a9ae6c1..10c8b2f 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -10963,6 +10963,13 @@ L:	netdev@vger.kernel.org
 S:	Maintained
 F:	drivers/net/ethernet/via/via-velocity.*
 
+VIRT LIB
+M:	Alex Williamson <alex.williamson@redhat.com>
+M:	Paolo Bonzini <pbonzini@redhat.com>
+L:	kvm@vger.kernel.org
+S:	Supported
+F:	virt/lib/
+
 VIVID VIRTUAL VIDEO DRIVER
 M:	Hans Verkuil <hverkuil@xs4all.nl>
 L:	linux-media@vger.kernel.org
diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
new file mode 100644
index 0000000..fde7b64
--- /dev/null
+++ b/include/linux/irqbypass.h
@@ -0,0 +1,90 @@
+/*
+ * 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.
+ */
+#ifndef IRQBYPASS_H
+#define IRQBYPASS_H
+
+#include <linux/list.h>
+
+struct irq_bypass_consumer;
+
+/*
+ * Theory of operation
+ *
+ * The IRQ bypass manager is a simple set of lists and callbacks that allows
+ * IRQ producers (ex. physical interrupt sources) to be matched to IRQ
+ * consumers (ex. virtualization hardware that allows IRQ bypass or offload)
+ * via a shared token (ex. eventfd_ctx).  Producers and consumers register
+ * independently.  When a token match is found, the optional @stop callback
+ * will be called for each participant.  The pair will then be connected via
+ * the @add_* callbacks, and finally the optional @start callback will allow
+ * any final coordination.  When either participant is unregistered, the
+ * process is repeated using the @del_* callbacks in place of the @add_*
+ * callbacks.  Match tokens must be unique per producer/consumer, 1:N pairings
+ * are not supported.
+ */
+
+/**
+ * struct irq_bypass_producer - IRQ bypass producer definition
+ * @node: IRQ bypass manager private list management
+ * @token: opaque token to match between producer and consumer
+ * @irq: Linux IRQ number for the producer device
+ * @add_consumer: Connect the IRQ producer to an IRQ consumer
+ * @del_consumer: Disconnect the IRQ producer from an IRQ consumer
+ * @stop: Perform any quiesce operations necessary prior to add/del (optional)
+ * @start: Perform any startup operations necessary after add/del (optional)
+ *
+ * The IRQ bypass producer structure represents an interrupt source for
+ * participation in possible host bypass, for instance an interrupt vector
+ * for a physical device assigned to a VM.
+ */
+struct irq_bypass_producer {
+	struct list_head node;
+	void *token;
+	int irq;
+	int (*add_consumer)(struct irq_bypass_producer *,
+			    struct irq_bypass_consumer *);
+	void (*del_consumer)(struct irq_bypass_producer *,
+			     struct irq_bypass_consumer *);
+	void (*stop)(struct irq_bypass_producer *);
+	void (*start)(struct irq_bypass_producer *);
+};
+
+/**
+ * struct irq_bypass_consumer - IRQ bypass consumer definition
+ * @node: IRQ bypass manager private list management
+ * @token: opaque token to match between producer and consumer
+ * @add_producer: Connect the IRQ consumer to an IRQ producer
+ * @del_producer: Disconnect the IRQ consumer from an IRQ producer
+ * @stop: Perform any quiesce operations necessary prior to add/del (optional)
+ * @start: Perform any startup operations necessary after add/del (optional)
+ *
+ * The IRQ bypass consumer structure represents an interrupt sink for
+ * participation in possible host bypass, for instance a hypervisor may
+ * support offloads to allow bypassing the host entirely or offload
+ * portions of the interrupt handling to the VM.
+ */
+struct irq_bypass_consumer {
+	struct list_head node;
+	void *token;
+	int (*add_producer)(struct irq_bypass_consumer *,
+			    struct irq_bypass_producer *);
+	void (*del_producer)(struct irq_bypass_consumer *,
+			     struct irq_bypass_producer *);
+	void (*stop)(struct irq_bypass_consumer *);
+	void (*start)(struct irq_bypass_consumer *);
+};
+
+int irq_bypass_register_producer(struct irq_bypass_producer *);
+void irq_bypass_unregister_producer(struct irq_bypass_producer *);
+int irq_bypass_register_consumer(struct irq_bypass_consumer *);
+void irq_bypass_unregister_consumer(struct irq_bypass_consumer *);
+
+#endif /* IRQBYPASS_H */
diff --git a/virt/lib/Kconfig b/virt/lib/Kconfig
new file mode 100644
index 0000000..89a414f
--- /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 0000000..901228d
--- /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 0000000..98a4141
--- /dev/null
+++ b/virt/lib/irqbypass.c
@@ -0,0 +1,256 @@
+/*
+ * 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;
+
+	if (prod->stop)
+		prod->stop(prod);
+	if (cons->stop)
+		cons->stop(cons);
+
+	ret = prod->add_consumer(prod, cons);
+	if (!ret) {
+		ret = cons->add_producer(cons, prod);
+		if (ret)
+			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);
+	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;
+
+	if (!producer->add_consumer || !producer->del_consumer)
+		return -EINVAL;
+
+	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);

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [next] | [standalone]

#1201389
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--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web