[RFC] irq: IRQ bypass manager

Commit Message

Alex Williamson July 7, 2015, 9:40 p.m. UTC

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 the hypervisor to handle level
triggered device interrupts as edge interrupts, by giving the guest
control of de-asserting and unmasking the interrupt line.

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 <[e-mail]>
Cc: Eric Auger <[e-mail]>
---

This is the current draft of the IRQ bypass manager, I've made the
following changes:

 - Incorporated Eric's extensions (I would welcome Sign-offs from all
   involved in the development, especially Eric - I've gone ahead and
   added Linaro copyright for the contributions so far)
 - Module support with module reference tracking
 - might_sleep() as suggested by Paolo
 - kerneldoc as suggested by Paolo
 - Renamed file s/bypass/irqbypass/ because a module named "bypass"
   is strange

Issues:
 - The update() callback is defined but not used
 - We can't have *all* the callbacks be optional.  I assume add/del
   are required
 - Naming consistency, stop is to start as suspend is to resume, not
   stop/resume
 - Callback descriptions including why we need separate stop/start
   hooks when it seems like the callee could reasonably assume such
   around the add/del callbacks
 - Need functional prototypes for both PI and forwarding

 include/linux/irqbypass.h |   75 ++++++++++++++++
 kernel/irq/Kconfig        |    3 +
 kernel/irq/Makefile       |    1 
 kernel/irq/irqbypass.c    |  206 +++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 285 insertions(+)
 create mode 100644 include/linux/irqbypass.h
 create mode 100644 kernel/irq/irqbypass.c


--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Comments

Wu, Feng July 8, 2015, 1 a.m. UTC | #1

> -----Original Message-----

> From: Alex Williamson [mailto:[e-mail]]

> Sent: Wednesday, July 08, 2015 5:40 AM

> To: [e-mail]; [e-mail]

> Cc: [e-mail]; [e-mail]; [e-mail];

> [e-mail]; [e-mail]; Wu, Feng

> Subject: [RFC PATCH] irq: 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 the hypervisor to handle level

> triggered device interrupts as edge interrupts, by giving the guest

> control of de-asserting and unmasking the interrupt line.

> 

> 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 <[e-mail]>

> Cc: Eric Auger <[e-mail]>

> ---

> 

> This is the current draft of the IRQ bypass manager, I've made the

> following changes:

> 

>  - Incorporated Eric's extensions (I would welcome Sign-offs from all

>    involved in the development, especially Eric - I've gone ahead and

>    added Linaro copyright for the contributions so far)

>  - Module support with module reference tracking

>  - might_sleep() as suggested by Paolo

>  - kerneldoc as suggested by Paolo

>  - Renamed file s/bypass/irqbypass/ because a module named "bypass"

>    is strange

> 

> Issues:

>  - The update() callback is defined but not used


Yeah, the update() callback is added by me, I need it to update IRTE
in irqfd_update().

>  - We can't have *all* the callbacks be optional.  I assume add/del

>    are required

>  - Naming consistency, stop is to start as suspend is to resume, not

>    stop/resume

>  - Callback descriptions including why we need separate stop/start

>    hooks when it seems like the callee could reasonably assume such

>    around the add/del callbacks

>  - Need functional prototypes for both PI and forwarding

> 

>  include/linux/irqbypass.h |   75 ++++++++++++++++

>  kernel/irq/Kconfig        |    3 +

>  kernel/irq/Makefile       |    1

>  kernel/irq/irqbypass.c    |  206

> +++++++++++++++++++++++++++++++++++++++++++++

>  4 files changed, 285 insertions(+)

>  create mode 100644 include/linux/irqbypass.h

>  create mode 100644 kernel/irq/irqbypass.c

> 

> diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h

> new file mode 100644

> index 0000000..cc7ce45

> --- /dev/null

> +++ b/include/linux/irqbypass.h

> @@ -0,0 +1,75 @@

> +/*

> + * 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;

> +

> +/**

> + * 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

> + * @stop:

> + * @resume:

> + * @add_consumer:

> + * @del_consumer:

> + *

> + * 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; /* linux irq */

> +	void (*stop)(struct irq_bypass_producer *);

> +	void (*resume)(struct irq_bypass_producer *);

> +	void (*add_consumer)(struct irq_bypass_producer *,

> +			     struct irq_bypass_consumer *);

> +	void (*del_consumer)(struct irq_bypass_producer *,

> +			     struct irq_bypass_consumer *);

> +};

> +

> +/**

> + * struct irq_bypass_consumer - IRQ bypass consumer definition

> + * @node: IRQ bypass manager private list management

> + * @token: opaque token to match between producer and consumer

> + * @stop:

> + * @resume:

> + * @add_consumer:

> + * @del_consumer:

> + * @update:

> + *

> + * 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;

> +	void (*stop)(struct irq_bypass_consumer *);

> +	void (*resume)(struct irq_bypass_consumer *);

> +	void (*add_producer)(struct irq_bypass_consumer *,

> +			     struct irq_bypass_producer *);

> +	void (*del_producer)(struct irq_bypass_consumer *,

> +			     struct irq_bypass_producer *);

> +	void (*update)(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/kernel/irq/Kconfig b/kernel/irq/Kconfig

> index 9a76e3b..de5afe3 100644

> --- a/kernel/irq/Kconfig

> +++ b/kernel/irq/Kconfig

> @@ -100,4 +100,7 @@ config SPARSE_IRQ

> 

>  	  If you don't know what to do here, say N.

> 

> +config IRQ_BYPASS_MANAGER

> +	tristate

> +

>  endmenu

> diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile

> index d121235..a6cfec7 100644

> --- a/kernel/irq/Makefile

> +++ b/kernel/irq/Makefile

> @@ -7,3 +7,4 @@ obj-$(CONFIG_PROC_FS) += proc.o

>  obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o

>  obj-$(CONFIG_PM_SLEEP) += pm.o

>  obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o

> +obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o

> diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c

> new file mode 100644

> index 0000000..3fd828d

> --- /dev/null

> +++ b/kernel/irq/irqbypass.c

> @@ -0,0 +1,206 @@

> +/*

> + * 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 can allow

> + * level triggered device interrupts to be de-asserted directly by the VM.

> + * 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 void __connect(struct irq_bypass_producer *prod,

> +		      struct irq_bypass_consumer *cons)

> +{

> +	if (prod->stop)

> +		prod->stop(prod);

> +	if (cons->stop)

> +		cons->stop(cons);

> +	if (prod->add_consumer)

> +		prod->add_consumer(prod, cons);

> +	if (cons->add_producer)

> +		cons->add_producer(cons, prod);

> +	if (cons->resume)

> +		cons->resume(cons);

> +	if (prod->resume)

> +		prod->resume(prod);

> +}

> +

> +/* @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);

> +	if (cons->del_producer)

> +		cons->del_producer(cons, prod);

> +	if (prod->del_consumer)

> +		prod->del_consumer(prod, cons);

> +	if (cons->resume)

> +		cons->resume(cons);

> +	if (prod->resume)

> +		prod->resume(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 tokens 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 -EINVAL;

> +		}

> +	}

> +

> +	list_add(&producer->node, &producers);

> +

> +	list_for_each_entry(consumer, &consumers, node) {

> +		if (consumer->token == producer->token) {

> +			__connect(producer, consumer);

> +			break;

> +		}

> +	}

> +

> +	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 disconnected from any connected IRQ consumers.

> + */

> +void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)

> +{

> +	struct irq_bypass_consumer *consumer;

> +

> +	might_sleep();

> +

> +	mutex_lock(&lock);

> +

> +	list_for_each_entry(consumer, &consumers, node) {

> +		if (consumer->token == producer->token) {

> +			__disconnect(producer, consumer);

> +			break;

> +		}

> +	}

> +

> +	list_del(&producer->node);

> +

> +	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 tokens 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;

> +

> +	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 -EINVAL;

> +		}

> +	}

> +

> +	list_add(&consumer->node, &consumers);

> +

> +	list_for_each_entry(producer, &producers, node) {

> +		if (producer->token == consumer->token) {

> +			__connect(producer, consumer);

> +			break;

> +		}

> +	}

> +

> +	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 disconnected from any connected IRQ producers.

> + */

> +void irq_bypass_unregister_consumer(struct irq_bypass_consumer

> *consumer)

> +{

> +	struct irq_bypass_producer *producer;

> +

> +	might_sleep();

> +

> +	mutex_lock(&lock);

> +

> +	list_for_each_entry(producer, &producers, node) {

> +		if (producer->token == consumer->token) {

> +			__disconnect(producer, consumer);

> +			break;

> +		}

> +	}

> +

> +	list_del(&consumer->node);

> +

> +	mutex_unlock(&lock);

> +	module_put(THIS_MODULE);

> +}

> +EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);

Wu, Feng July 8, 2015, 12:22 p.m. UTC | #2
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--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Alex Williamson July 8, 2015, 12:54 p.m. UTC | #3

On Wed, 2015-07-08 at 12:22 +0000, Wu, Feng wrote:
> 
> 
> > -----Original Message-----
> > From: Alex Williamson [mailto:[e-mail]]
> > Sent: Wednesday, July 08, 2015 5:40 AM
> > To: [e-mail]; [e-mail]
> > Cc: [e-mail]; [e-mail]; [e-mail];
> > [e-mail]; [e-mail]; Wu, Feng
> > Subject: [RFC PATCH] irq: 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 the hypervisor to handle level
> > triggered device interrupts as edge interrupts, by giving the guest
> > control of de-asserting and unmasking the interrupt line.
> > 
> > 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.
> 
> My Pi patches can work well based on this one and the one Eric sent
> out earlier. Alex, what should we do in the next step to speed up the
> upstreaming process?

Hi Feng,

Post the patches.  Define how the update() callback is used.  Help to
address the issues I've outlined below.  Thanks,

Alex

> > 
> > Signed-off-by: Alex Williamson <[e-mail]>
> > Cc: Eric Auger <[e-mail]>
> > ---
> > 
> > This is the current draft of the IRQ bypass manager, I've made the
> > following changes:
> > 
> >  - Incorporated Eric's extensions (I would welcome Sign-offs from all
> >    involved in the development, especially Eric - I've gone ahead and
> >    added Linaro copyright for the contributions so far)
> >  - Module support with module reference tracking
> >  - might_sleep() as suggested by Paolo
> >  - kerneldoc as suggested by Paolo
> >  - Renamed file s/bypass/irqbypass/ because a module named "bypass"
> >    is strange
> > 
> > Issues:
> >  - The update() callback is defined but not used
> >  - We can't have *all* the callbacks be optional.  I assume add/del
> >    are required
> >  - Naming consistency, stop is to start as suspend is to resume, not
> >    stop/resume
> >  - Callback descriptions including why we need separate stop/start
> >    hooks when it seems like the callee could reasonably assume such
> >    around the add/del callbacks
> >  - Need functional prototypes for both PI and forwarding
> > 
> >  include/linux/irqbypass.h |   75 ++++++++++++++++
> >  kernel/irq/Kconfig        |    3 +
> >  kernel/irq/Makefile       |    1
> >  kernel/irq/irqbypass.c    |  206
> > +++++++++++++++++++++++++++++++++++++++++++++
> >  4 files changed, 285 insertions(+)
> >  create mode 100644 include/linux/irqbypass.h
> >  create mode 100644 kernel/irq/irqbypass.c
> > 
> > diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
> > new file mode 100644
> > index 0000000..cc7ce45
> > --- /dev/null
> > +++ b/include/linux/irqbypass.h
> > @@ -0,0 +1,75 @@
> > +/*
> > + * 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;
> > +
> > +/**
> > + * 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
> > + * @stop:
> > + * @resume:
> > + * @add_consumer:
> > + * @del_consumer:
> > + *
> > + * 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; /* linux irq */
> > +	void (*stop)(struct irq_bypass_producer *);
> > +	void (*resume)(struct irq_bypass_producer *);
> > +	void (*add_consumer)(struct irq_bypass_producer *,
> > +			     struct irq_bypass_consumer *);
> > +	void (*del_consumer)(struct irq_bypass_producer *,
> > +			     struct irq_bypass_consumer *);
> > +};
> > +
> > +/**
> > + * struct irq_bypass_consumer - IRQ bypass consumer definition
> > + * @node: IRQ bypass manager private list management
> > + * @token: opaque token to match between producer and consumer
> > + * @stop:
> > + * @resume:
> > + * @add_consumer:
> > + * @del_consumer:
> > + * @update:
> > + *
> > + * 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;
> > +	void (*stop)(struct irq_bypass_consumer *);
> > +	void (*resume)(struct irq_bypass_consumer *);
> > +	void (*add_producer)(struct irq_bypass_consumer *,
> > +			     struct irq_bypass_producer *);
> > +	void (*del_producer)(struct irq_bypass_consumer *,
> > +			     struct irq_bypass_producer *);
> > +	void (*update)(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/kernel/irq/Kconfig b/kernel/irq/Kconfig
> > index 9a76e3b..de5afe3 100644
> > --- a/kernel/irq/Kconfig
> > +++ b/kernel/irq/Kconfig
> > @@ -100,4 +100,7 @@ config SPARSE_IRQ
> > 
> >  	  If you don't know what to do here, say N.
> > 
> > +config IRQ_BYPASS_MANAGER
> > +	tristate
> > +
> >  endmenu
> > diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
> > index d121235..a6cfec7 100644
> > --- a/kernel/irq/Makefile
> > +++ b/kernel/irq/Makefile
> > @@ -7,3 +7,4 @@ obj-$(CONFIG_PROC_FS) += proc.o
> >  obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
> >  obj-$(CONFIG_PM_SLEEP) += pm.o
> >  obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
> > +obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
> > diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c
> > new file mode 100644
> > index 0000000..3fd828d
> > --- /dev/null
> > +++ b/kernel/irq/irqbypass.c
> > @@ -0,0 +1,206 @@
> > +/*
> > + * 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 can allow
> > + * level triggered device interrupts to be de-asserted directly by the VM.
> > + * 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 void __connect(struct irq_bypass_producer *prod,
> > +		      struct irq_bypass_consumer *cons)
> > +{
> > +	if (prod->stop)
> > +		prod->stop(prod);
> > +	if (cons->stop)
> > +		cons->stop(cons);
> > +	if (prod->add_consumer)
> > +		prod->add_consumer(prod, cons);
> > +	if (cons->add_producer)
> > +		cons->add_producer(cons, prod);
> > +	if (cons->resume)
> > +		cons->resume(cons);
> > +	if (prod->resume)
> > +		prod->resume(prod);
> > +}
> > +
> > +/* @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);
> > +	if (cons->del_producer)
> > +		cons->del_producer(cons, prod);
> > +	if (prod->del_consumer)
> > +		prod->del_consumer(prod, cons);
> > +	if (cons->resume)
> > +		cons->resume(cons);
> > +	if (prod->resume)
> > +		prod->resume(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 tokens 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 -EINVAL;
> > +		}
> > +	}
> > +
> > +	list_add(&producer->node, &producers);
> > +
> > +	list_for_each_entry(consumer, &consumers, node) {
> > +		if (consumer->token == producer->token) {
> > +			__connect(producer, consumer);
> > +			break;
> > +		}
> > +	}
> > +
> > +	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 disconnected from any connected IRQ consumers.
> > + */
> > +void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
> > +{
> > +	struct irq_bypass_consumer *consumer;
> > +
> > +	might_sleep();
> > +
> > +	mutex_lock(&lock);
> > +
> > +	list_for_each_entry(consumer, &consumers, node) {
> > +		if (consumer->token == producer->token) {
> > +			__disconnect(producer, consumer);
> > +			break;
> > +		}
> > +	}
> > +
> > +	list_del(&producer->node);
> > +
> > +	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 tokens 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;
> > +
> > +	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 -EINVAL;
> > +		}
> > +	}
> > +
> > +	list_add(&consumer->node, &consumers);
> > +
> > +	list_for_each_entry(producer, &producers, node) {
> > +		if (producer->token == consumer->token) {
> > +			__connect(producer, consumer);
> > +			break;
> > +		}
> > +	}
> > +
> > +	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 disconnected from any connected IRQ producers.
> > + */
> > +void irq_bypass_unregister_consumer(struct irq_bypass_consumer
> > *consumer)
> > +{
> > +	struct irq_bypass_producer *producer;
> > +
> > +	might_sleep();
> > +
> > +	mutex_lock(&lock);
> > +
> > +	list_for_each_entry(producer, &producers, node) {
> > +		if (producer->token == consumer->token) {
> > +			__disconnect(producer, consumer);
> > +			break;
> > +		}
> > +	}
> > +
> > +	list_del(&consumer->node);
> > +
> > +	mutex_unlock(&lock);
> > +	module_put(THIS_MODULE);
> > +}
> > +EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);
> 



--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Eric Auger July 8, 2015, 2:37 p.m. UTC | #4

Hi Alex,
On 07/07/2015 11:40 PM, Alex Williamson wrote:
> 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 the hypervisor to handle level
> triggered device interrupts as edge interrupts, by giving the guest
> control of de-asserting and unmasking the interrupt line.
> 
> 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 <[e-mail]>
> Cc: Eric Auger <[e-mail]>
> ---
> 
> This is the current draft of the IRQ bypass manager, I've made the
> following changes:
> 
>  - Incorporated Eric's extensions (I would welcome Sign-offs from all
>    involved in the development, especially Eric - I've gone ahead and
>    added Linaro copyright for the contributions so far)
Signed-off-by: Eric Auger <[e-mail]>
>  - Module support with module reference tracking
>  - might_sleep() as suggested by Paolo
>  - kerneldoc as suggested by Paolo
>  - Renamed file s/bypass/irqbypass/ because a module named "bypass"
>    is strange
> 
> Issues:
Currently, for IRQ forwarding, I use an active boolean on producer side
- on connect, this "active" boolean is set by cons->add_consumer and
used by prod->add_producer
- conversely on destruction it is set by cons->del_producer and used by
prod->del_consumer

For me this reflects the state of the IRQ. On connect, if the IRQ is
active of VFIO masked it is unsafe to connect - I still don't know how
to handle that case - . On disconnect, if the IRQ is active at interrupt
controller level I need to mask at VFIO level.

I introduced this boolean in the IRQ forwarding series(irq: bypass:
Extend skeleton for ARM forwarding control).

I know this is quite specific to IRQ forwarding stuff though.

Any suggestion of a more elegant implementation?

>  - The update() callback is defined but not used
I let Feng comment
>  - We can't have *all* the callbacks be optional.  I assume add/del
>    are required
yes to me add/del are mandated. Others are optional.
>  - Naming consistency, stop is to start as suspend is to resume, not
>    stop/resume
let's use start/stop then
>  - Callback descriptions including why we need separate stop/start
>    hooks when it seems like the callee could reasonably assume such
>    around the add/del callbacks
why we need to separate start/top:
on connect: I need to intertwine actions from producer/consumers for
forwarding
1) producer: disable IRQ
2) consumer: halt guest
3) producer: compute active state, set non automasked handler
4) consumer: program gic/irqchip, normally depending on active state
5) consumer: start guest
6) producer: enable IRQ

each action is private to a consumer/producer
action 3) only can be done after 1) and 2) to snapshot the active state

On disconnect, I need
1) producer: disable IRQ
2) consumer: halt guest
3) consumer: test active state, program gic/irqchip
4) producer: set automasked handled and mask the IRQ depending on active
state
5) consumer: start guest
6) producer: enable IRQ

again action 3) can only be done after 1) and 2) to snapshot the active
state
So rationale behind having start/stop is that I need a more complex
sequence than just 2 private functions. Then I thought that when setting
up/tearing down the link it could be natural to have start/stop
functions at source & sink.

start: start the IRQ consumption/production at sink/source
stop: stop the IRQ consumption/production at sink/source

>  - Need functional prototypes for both PI and forwarding
this is functional for forwarding. tested on calxeda midway but
dependencies mostly are RFC's.

Best Regards

Eric
> 
>  include/linux/irqbypass.h |   75 ++++++++++++++++
>  kernel/irq/Kconfig        |    3 +
>  kernel/irq/Makefile       |    1 
>  kernel/irq/irqbypass.c    |  206 +++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 285 insertions(+)
>  create mode 100644 include/linux/irqbypass.h
>  create mode 100644 kernel/irq/irqbypass.c
> 
> diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
> new file mode 100644
> index 0000000..cc7ce45
> --- /dev/null
> +++ b/include/linux/irqbypass.h
> @@ -0,0 +1,75 @@
> +/*
> + * 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;
> +
> +/**
> + * 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
> + * @stop:
> + * @resume:
> + * @add_consumer:
> + * @del_consumer:
> + *
> + * 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; /* linux irq */
> +	void (*stop)(struct irq_bypass_producer *);
> +	void (*resume)(struct irq_bypass_producer *);
> +	void (*add_consumer)(struct irq_bypass_producer *,
> +			     struct irq_bypass_consumer *);
> +	void (*del_consumer)(struct irq_bypass_producer *,
> +			     struct irq_bypass_consumer *);
> +};
> +
> +/**
> + * struct irq_bypass_consumer - IRQ bypass consumer definition
> + * @node: IRQ bypass manager private list management
> + * @token: opaque token to match between producer and consumer
> + * @stop:
> + * @resume:
> + * @add_consumer:
> + * @del_consumer:
> + * @update:
> + *
> + * 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;
> +	void (*stop)(struct irq_bypass_consumer *);
> +	void (*resume)(struct irq_bypass_consumer *);
> +	void (*add_producer)(struct irq_bypass_consumer *,
> +			     struct irq_bypass_producer *);
> +	void (*del_producer)(struct irq_bypass_consumer *,
> +			     struct irq_bypass_producer *);
> +	void (*update)(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/kernel/irq/Kconfig b/kernel/irq/Kconfig
> index 9a76e3b..de5afe3 100644
> --- a/kernel/irq/Kconfig
> +++ b/kernel/irq/Kconfig
> @@ -100,4 +100,7 @@ config SPARSE_IRQ
>  
>  	  If you don't know what to do here, say N.
>  
> +config IRQ_BYPASS_MANAGER
> +	tristate
> +
>  endmenu
> diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
> index d121235..a6cfec7 100644
> --- a/kernel/irq/Makefile
> +++ b/kernel/irq/Makefile
> @@ -7,3 +7,4 @@ obj-$(CONFIG_PROC_FS) += proc.o
>  obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
>  obj-$(CONFIG_PM_SLEEP) += pm.o
>  obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
> +obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
> diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c
> new file mode 100644
> index 0000000..3fd828d
> --- /dev/null
> +++ b/kernel/irq/irqbypass.c
> @@ -0,0 +1,206 @@
> +/*
> + * 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 can allow
> + * level triggered device interrupts to be de-asserted directly by the VM.
> + * 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 void __connect(struct irq_bypass_producer *prod,
> +		      struct irq_bypass_consumer *cons)
> +{
> +	if (prod->stop)
> +		prod->stop(prod);
> +	if (cons->stop)
> +		cons->stop(cons);
> +	if (prod->add_consumer)
> +		prod->add_consumer(prod, cons);
> +	if (cons->add_producer)
> +		cons->add_producer(cons, prod);
> +	if (cons->resume)
> +		cons->resume(cons);
> +	if (prod->resume)
> +		prod->resume(prod);
> +}
> +
> +/* @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);
> +	if (cons->del_producer)
> +		cons->del_producer(cons, prod);
> +	if (prod->del_consumer)
> +		prod->del_consumer(prod, cons);
> +	if (cons->resume)
> +		cons->resume(cons);
> +	if (prod->resume)
> +		prod->resume(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 tokens 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 -EINVAL;
> +		}
> +	}
> +
> +	list_add(&producer->node, &producers);
> +
> +	list_for_each_entry(consumer, &consumers, node) {
> +		if (consumer->token == producer->token) {
> +			__connect(producer, consumer);
> +			break;
> +		}
> +	}
> +
> +	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 disconnected from any connected IRQ consumers.
> + */
> +void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
> +{
> +	struct irq_bypass_consumer *consumer;
> +
> +	might_sleep();
> +
> +	mutex_lock(&lock);
> +
> +	list_for_each_entry(consumer, &consumers, node) {
> +		if (consumer->token == producer->token) {
> +			__disconnect(producer, consumer);
> +			break;
> +		}
> +	}
> +
> +	list_del(&producer->node);
> +
> +	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 tokens 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;
> +
> +	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 -EINVAL;
> +		}
> +	}
> +
> +	list_add(&consumer->node, &consumers);
> +
> +	list_for_each_entry(producer, &producers, node) {
> +		if (producer->token == consumer->token) {
> +			__connect(producer, consumer);
> +			break;
> +		}
> +	}
> +
> +	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 disconnected from any connected IRQ producers.
> + */
> +void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer)
> +{
> +	struct irq_bypass_producer *producer;
> +
> +	might_sleep();
> +
> +	mutex_lock(&lock);
> +
> +	list_for_each_entry(producer, &producers, node) {
> +		if (producer->token == consumer->token) {
> +			__disconnect(producer, consumer);
> +			break;
> +		}
> +	}
> +
> +	list_del(&consumer->node);
> +
> +	mutex_unlock(&lock);
> +	module_put(THIS_MODULE);
> +}
> +EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);
> 

--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Eric Auger July 13, 2015, 1:23 p.m. UTC | #5

Hi Alex,
On 07/08/2015 04:37 PM, Eric Auger wrote:
> Hi Alex,
> On 07/07/2015 11:40 PM, Alex Williamson wrote:
>> 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 the hypervisor to handle level
>> triggered device interrupts as edge interrupts, by giving the guest
>> control of de-asserting and unmasking the interrupt line.
>>
>> 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 <[e-mail]>
>> Cc: Eric Auger <[e-mail]>
>> ---
>>
>> This is the current draft of the IRQ bypass manager, I've made the
>> following changes:
>>
>>  - Incorporated Eric's extensions (I would welcome Sign-offs from all
>>    involved in the development, especially Eric - I've gone ahead and
>>    added Linaro copyright for the contributions so far)
> Signed-off-by: Eric Auger <[e-mail]>
Given the amount of code I wrote compared to you, I think you can simply
drop my Signed-off ;-)
>>  - Module support with module reference tracking
>>  - might_sleep() as suggested by Paolo
>>  - kerneldoc as suggested by Paolo
>>  - Renamed file s/bypass/irqbypass/ because a module named "bypass"
>>    is strange
>>
>> Issues:
> Currently, for IRQ forwarding, I use an active boolean on producer side
> - on connect, this "active" boolean is set by cons->add_consumer and
> used by prod->add_producer
> - conversely on destruction it is set by cons->del_producer and used by
> prod->del_consumer
> 
> For me this reflects the state of the IRQ. On connect, if the IRQ is
> active of VFIO masked it is unsafe to connect - I still don't know how
> to handle that case - . On disconnect, if the IRQ is active at interrupt
> controller level I need to mask at VFIO level.
> 
> I introduced this boolean in the IRQ forwarding series(irq: bypass:
> Extend skeleton for ARM forwarding control).
> 
> I know this is quite specific to IRQ forwarding stuff though.
> 
> Any suggestion of a more elegant implementation?

Would you accept to introduce this active boolean back? Any other
suggestion?

Best Regards

Eric
> 
>>  - The update() callback is defined but not used
> I let Feng comment
>>  - We can't have *all* the callbacks be optional.  I assume add/del
>>    are required
> yes to me add/del are mandated. Others are optional.
>>  - Naming consistency, stop is to start as suspend is to resume, not
>>    stop/resume
> let's use start/stop then
>>  - Callback descriptions including why we need separate stop/start
>>    hooks when it seems like the callee could reasonably assume such
>>    around the add/del callbacks
> why we need to separate start/top:
> on connect: I need to intertwine actions from producer/consumers for
> forwarding
> 1) producer: disable IRQ
> 2) consumer: halt guest
> 3) producer: compute active state, set non automasked handler
> 4) consumer: program gic/irqchip, normally depending on active state
> 5) consumer: start guest
> 6) producer: enable IRQ
> 
> each action is private to a consumer/producer
> action 3) only can be done after 1) and 2) to snapshot the active state
> 
> On disconnect, I need
> 1) producer: disable IRQ
> 2) consumer: halt guest
> 3) consumer: test active state, program gic/irqchip
> 4) producer: set automasked handled and mask the IRQ depending on active
> state
> 5) consumer: start guest
> 6) producer: enable IRQ
> 
> again action 3) can only be done after 1) and 2) to snapshot the active
> state
> So rationale behind having start/stop is that I need a more complex
> sequence than just 2 private functions. Then I thought that when setting
> up/tearing down the link it could be natural to have start/stop
> functions at source & sink.
> 
> start: start the IRQ consumption/production at sink/source
> stop: stop the IRQ consumption/production at sink/source
> 
>>  - Need functional prototypes for both PI and forwarding
> this is functional for forwarding. tested on calxeda midway but
> dependencies mostly are RFC's.
> 
> Best Regards
> 
> Eric
>>
>>  include/linux/irqbypass.h |   75 ++++++++++++++++
>>  kernel/irq/Kconfig        |    3 +
>>  kernel/irq/Makefile       |    1 
>>  kernel/irq/irqbypass.c    |  206 +++++++++++++++++++++++++++++++++++++++++++++
>>  4 files changed, 285 insertions(+)
>>  create mode 100644 include/linux/irqbypass.h
>>  create mode 100644 kernel/irq/irqbypass.c
>>
>> diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
>> new file mode 100644
>> index 0000000..cc7ce45
>> --- /dev/null
>> +++ b/include/linux/irqbypass.h
>> @@ -0,0 +1,75 @@
>> +/*
>> + * 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;
>> +
>> +/**
>> + * 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
>> + * @stop:
>> + * @resume:
>> + * @add_consumer:
>> + * @del_consumer:
>> + *
>> + * 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; /* linux irq */
>> +	void (*stop)(struct irq_bypass_producer *);
>> +	void (*resume)(struct irq_bypass_producer *);
>> +	void (*add_consumer)(struct irq_bypass_producer *,
>> +			     struct irq_bypass_consumer *);
>> +	void (*del_consumer)(struct irq_bypass_producer *,
>> +			     struct irq_bypass_consumer *);
>> +};
>> +
>> +/**
>> + * struct irq_bypass_consumer - IRQ bypass consumer definition
>> + * @node: IRQ bypass manager private list management
>> + * @token: opaque token to match between producer and consumer
>> + * @stop:
>> + * @resume:
>> + * @add_consumer:
>> + * @del_consumer:
>> + * @update:
>> + *
>> + * 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;
>> +	void (*stop)(struct irq_bypass_consumer *);
>> +	void (*resume)(struct irq_bypass_consumer *);
>> +	void (*add_producer)(struct irq_bypass_consumer *,
>> +			     struct irq_bypass_producer *);
>> +	void (*del_producer)(struct irq_bypass_consumer *,
>> +			     struct irq_bypass_producer *);
>> +	void (*update)(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/kernel/irq/Kconfig b/kernel/irq/Kconfig
>> index 9a76e3b..de5afe3 100644
>> --- a/kernel/irq/Kconfig
>> +++ b/kernel/irq/Kconfig
>> @@ -100,4 +100,7 @@ config SPARSE_IRQ
>>  
>>  	  If you don't know what to do here, say N.
>>  
>> +config IRQ_BYPASS_MANAGER
>> +	tristate
>> +
>>  endmenu
>> diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
>> index d121235..a6cfec7 100644
>> --- a/kernel/irq/Makefile
>> +++ b/kernel/irq/Makefile
>> @@ -7,3 +7,4 @@ obj-$(CONFIG_PROC_FS) += proc.o
>>  obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
>>  obj-$(CONFIG_PM_SLEEP) += pm.o
>>  obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
>> +obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
>> diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c
>> new file mode 100644
>> index 0000000..3fd828d
>> --- /dev/null
>> +++ b/kernel/irq/irqbypass.c
>> @@ -0,0 +1,206 @@
>> +/*
>> + * 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 can allow
>> + * level triggered device interrupts to be de-asserted directly by the VM.
>> + * 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 void __connect(struct irq_bypass_producer *prod,
>> +		      struct irq_bypass_consumer *cons)
>> +{
>> +	if (prod->stop)
>> +		prod->stop(prod);
>> +	if (cons->stop)
>> +		cons->stop(cons);
>> +	if (prod->add_consumer)
>> +		prod->add_consumer(prod, cons);
>> +	if (cons->add_producer)
>> +		cons->add_producer(cons, prod);
>> +	if (cons->resume)
>> +		cons->resume(cons);
>> +	if (prod->resume)
>> +		prod->resume(prod);
>> +}
>> +
>> +/* @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);
>> +	if (cons->del_producer)
>> +		cons->del_producer(cons, prod);
>> +	if (prod->del_consumer)
>> +		prod->del_consumer(prod, cons);
>> +	if (cons->resume)
>> +		cons->resume(cons);
>> +	if (prod->resume)
>> +		prod->resume(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 tokens 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 -EINVAL;
>> +		}
>> +	}
>> +
>> +	list_add(&producer->node, &producers);
>> +
>> +	list_for_each_entry(consumer, &consumers, node) {
>> +		if (consumer->token == producer->token) {
>> +			__connect(producer, consumer);
>> +			break;
>> +		}
>> +	}
>> +
>> +	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 disconnected from any connected IRQ consumers.
>> + */
>> +void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
>> +{
>> +	struct irq_bypass_consumer *consumer;
>> +
>> +	might_sleep();
>> +
>> +	mutex_lock(&lock);
>> +
>> +	list_for_each_entry(consumer, &consumers, node) {
>> +		if (consumer->token == producer->token) {
>> +			__disconnect(producer, consumer);
>> +			break;
>> +		}
>> +	}
>> +
>> +	list_del(&producer->node);
>> +
>> +	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 tokens 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;
>> +
>> +	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 -EINVAL;
>> +		}
>> +	}
>> +
>> +	list_add(&consumer->node, &consumers);
>> +
>> +	list_for_each_entry(producer, &producers, node) {
>> +		if (producer->token == consumer->token) {
>> +			__connect(producer, consumer);
>> +			break;
>> +		}
>> +	}
>> +
>> +	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 disconnected from any connected IRQ producers.
>> + */
>> +void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer)
>> +{
>> +	struct irq_bypass_producer *producer;
>> +
>> +	might_sleep();
>> +
>> +	mutex_lock(&lock);
>> +
>> +	list_for_each_entry(producer, &producers, node) {
>> +		if (producer->token == consumer->token) {
>> +			__disconnect(producer, consumer);
>> +			break;
>> +		}
>> +	}
>> +
>> +	list_del(&consumer->node);
>> +
>> +	mutex_unlock(&lock);
>> +	module_put(THIS_MODULE);
>> +}
>> +EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);
>>
> 

--
To unsubscribe from this list: send the line "unsubscribe kvm" in
the body of a message to [e-mail]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Patch

diff --git a/include/linux/irqbypass.h b/include/linux/irqbypass.h
new file mode 100644
index 0000000..cc7ce45
--- /dev/null
+++ b/include/linux/irqbypass.h
@@ -0,0 +1,75 @@ 
+/*
+ * 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;
+
+/**
+ * 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
+ * @stop:
+ * @resume:
+ * @add_consumer:
+ * @del_consumer:
+ *
+ * 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; /* linux irq */
+	void (*stop)(struct irq_bypass_producer *);
+	void (*resume)(struct irq_bypass_producer *);
+	void (*add_consumer)(struct irq_bypass_producer *,
+			     struct irq_bypass_consumer *);
+	void (*del_consumer)(struct irq_bypass_producer *,
+			     struct irq_bypass_consumer *);
+};
+
+/**
+ * struct irq_bypass_consumer - IRQ bypass consumer definition
+ * @node: IRQ bypass manager private list management
+ * @token: opaque token to match between producer and consumer
+ * @stop:
+ * @resume:
+ * @add_consumer:
+ * @del_consumer:
+ * @update:
+ *
+ * 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;
+	void (*stop)(struct irq_bypass_consumer *);
+	void (*resume)(struct irq_bypass_consumer *);
+	void (*add_producer)(struct irq_bypass_consumer *,
+			     struct irq_bypass_producer *);
+	void (*del_producer)(struct irq_bypass_consumer *,
+			     struct irq_bypass_producer *);
+	void (*update)(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/kernel/irq/Kconfig b/kernel/irq/Kconfig
index 9a76e3b..de5afe3 100644
--- a/kernel/irq/Kconfig
+++ b/kernel/irq/Kconfig
@@ -100,4 +100,7 @@  config SPARSE_IRQ
 
 	  If you don't know what to do here, say N.
 
+config IRQ_BYPASS_MANAGER
+	tristate
+
 endmenu
diff --git a/kernel/irq/Makefile b/kernel/irq/Makefile
index d121235..a6cfec7 100644
--- a/kernel/irq/Makefile
+++ b/kernel/irq/Makefile
@@ -7,3 +7,4 @@  obj-$(CONFIG_PROC_FS) += proc.o
 obj-$(CONFIG_GENERIC_PENDING_IRQ) += migration.o
 obj-$(CONFIG_PM_SLEEP) += pm.o
 obj-$(CONFIG_GENERIC_MSI_IRQ) += msi.o
+obj-$(CONFIG_IRQ_BYPASS_MANAGER) += irqbypass.o
diff --git a/kernel/irq/irqbypass.c b/kernel/irq/irqbypass.c
new file mode 100644
index 0000000..3fd828d
--- /dev/null
+++ b/kernel/irq/irqbypass.c
@@ -0,0 +1,206 @@ 
+/*
+ * 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 can allow
+ * level triggered device interrupts to be de-asserted directly by the VM.
+ * 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 void __connect(struct irq_bypass_producer *prod,
+		      struct irq_bypass_consumer *cons)
+{
+	if (prod->stop)
+		prod->stop(prod);
+	if (cons->stop)
+		cons->stop(cons);
+	if (prod->add_consumer)
+		prod->add_consumer(prod, cons);
+	if (cons->add_producer)
+		cons->add_producer(cons, prod);
+	if (cons->resume)
+		cons->resume(cons);
+	if (prod->resume)
+		prod->resume(prod);
+}
+
+/* @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);
+	if (cons->del_producer)
+		cons->del_producer(cons, prod);
+	if (prod->del_consumer)
+		prod->del_consumer(prod, cons);
+	if (cons->resume)
+		cons->resume(cons);
+	if (prod->resume)
+		prod->resume(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 tokens 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 -EINVAL;
+		}
+	}
+
+	list_add(&producer->node, &producers);
+
+	list_for_each_entry(consumer, &consumers, node) {
+		if (consumer->token == producer->token) {
+			__connect(producer, consumer);
+			break;
+		}
+	}
+
+	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 disconnected from any connected IRQ consumers.
+ */
+void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
+{
+	struct irq_bypass_consumer *consumer;
+
+	might_sleep();
+
+	mutex_lock(&lock);
+
+	list_for_each_entry(consumer, &consumers, node) {
+		if (consumer->token == producer->token) {
+			__disconnect(producer, consumer);
+			break;
+		}
+	}
+
+	list_del(&producer->node);
+
+	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 tokens 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;
+
+	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 -EINVAL;
+		}
+	}
+
+	list_add(&consumer->node, &consumers);
+
+	list_for_each_entry(producer, &producers, node) {
+		if (producer->token == consumer->token) {
+			__connect(producer, consumer);
+			break;
+		}
+	}
+
+	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 disconnected from any connected IRQ producers.
+ */
+void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer)
+{
+	struct irq_bypass_producer *producer;
+
+	might_sleep();
+
+	mutex_lock(&lock);
+
+	list_for_each_entry(producer, &producers, node) {
+		if (producer->token == consumer->token) {
+			__disconnect(producer, consumer);
+			break;
+		}
+	}
+
+	list_del(&consumer->node);
+
+	mutex_unlock(&lock);
+	module_put(THIS_MODULE);
+}
+EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);