virt/lib/irqbypass.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * IRQ offload/bypass manager
   4  *
   5  * Copyright (C) 2015 Red Hat, Inc.
   6  * Copyright (c) 2015 Linaro Ltd.
   7  *
   8  * Various virtualization hardware acceleration techniques allow bypassing or
   9  * offloading interrupts received from devices around the host kernel.  Posted
  10  * Interrupts on Intel VT-d systems can allow interrupts to be received
  11  * directly by a virtual machine.  ARM IRQ Forwarding allows forwarded physical
  12  * interrupts to be directly deactivated by the guest.  This manager allows
  13  * interrupt producers and consumers to find each other to enable this sort of
  14  * bypass.
  15  */
  16
  17 #include <linux/irqbypass.h>
  18 #include <linux/list.h>
  19 #include <linux/module.h>
  20 #include <linux/mutex.h>
  21
  22 MODULE_LICENSE("GPL v2");
  23 MODULE_DESCRIPTION("IRQ bypass manager utility module");
  24
  25 static LIST_HEAD(producers);
  26 static LIST_HEAD(consumers);
  27 static DEFINE_MUTEX(lock);
  28
  29 /* @lock must be held when calling connect */
  30 static int __connect(struct irq_bypass_producer *prod,
  31                      struct irq_bypass_consumer *cons)
  32 {
  33         int ret = 0;
  34
  35         if (prod->stop)
  36                 prod->stop(prod);
  37         if (cons->stop)
  38                 cons->stop(cons);
  39
  40         if (prod->add_consumer)
  41                 ret = prod->add_consumer(prod, cons);
  42
  43         if (!ret) {
  44                 ret = cons->add_producer(cons, prod);
  45                 if (ret && prod->del_consumer)
  46                         prod->del_consumer(prod, cons);
  47         }
  48
  49         if (cons->start)
  50                 cons->start(cons);
  51         if (prod->start)
  52                 prod->start(prod);
  53
  54         return ret;
  55 }
  56
  57 /* @lock must be held when calling disconnect */
  58 static void __disconnect(struct irq_bypass_producer *prod,
  59                          struct irq_bypass_consumer *cons)
  60 {
  61         if (prod->stop)
  62                 prod->stop(prod);
  63         if (cons->stop)
  64                 cons->stop(cons);
  65
  66         cons->del_producer(cons, prod);
  67
  68         if (prod->del_consumer)
  69                 prod->del_consumer(prod, cons);
  70
  71         if (cons->start)
  72                 cons->start(cons);
  73         if (prod->start)
  74                 prod->start(prod);
  75 }
  76
  77 /**
  78  * irq_bypass_register_producer - register IRQ bypass producer
  79  * @producer: pointer to producer structure
  80  *
  81  * Add the provided IRQ producer to the list of producers and connect
  82  * with any matching token found on the IRQ consumers list.
  83  */
  84 int irq_bypass_register_producer(struct irq_bypass_producer *producer)
  85 {
  86         struct irq_bypass_producer *tmp;
  87         struct irq_bypass_consumer *consumer;
  88
  89         if (!producer->token)
  90                 return -EINVAL;
  91
  92         might_sleep();
  93
  94         if (!try_module_get(THIS_MODULE))
  95                 return -ENODEV;
  96
  97         mutex_lock(&lock);
  98
  99         list_for_each_entry(tmp, &producers, node) {
 100                 if (tmp->token == producer->token) {
 101                         mutex_unlock(&lock);
 102                         module_put(THIS_MODULE);
 103                         return -EBUSY;
 104                 }
 105         }
 106
 107         list_for_each_entry(consumer, &consumers, node) {
 108                 if (consumer->token == producer->token) {
 109                         int ret = __connect(producer, consumer);
 110                         if (ret) {
 111                                 mutex_unlock(&lock);
 112                                 module_put(THIS_MODULE);
 113                                 return ret;
 114                         }
 115                         break;
 116                 }
 117         }
 118
 119         list_add(&producer->node, &producers);
 120
 121         mutex_unlock(&lock);
 122
 123         return 0;
 124 }
 125 EXPORT_SYMBOL_GPL(irq_bypass_register_producer);
 126
 127 /**
 128  * irq_bypass_unregister_producer - unregister IRQ bypass producer
 129  * @producer: pointer to producer structure
 130  *
 131  * Remove a previously registered IRQ producer from the list of producers
 132  * and disconnect it from any connected IRQ consumer.
 133  */
 134 void irq_bypass_unregister_producer(struct irq_bypass_producer *producer)
 135 {
 136         struct irq_bypass_producer *tmp;
 137         struct irq_bypass_consumer *consumer;
 138
 139         if (!producer->token)
 140                 return;
 141
 142         might_sleep();
 143
 144         if (!try_module_get(THIS_MODULE))
 145                 return; /* nothing in the list anyway */
 146
 147         mutex_lock(&lock);
 148
 149         list_for_each_entry(tmp, &producers, node) {
 150                 if (tmp->token != producer->token)
 151                         continue;
 152
 153                 list_for_each_entry(consumer, &consumers, node) {
 154                         if (consumer->token == producer->token) {
 155                                 __disconnect(producer, consumer);
 156                                 break;
 157                         }
 158                 }
 159
 160                 list_del(&producer->node);
 161                 module_put(THIS_MODULE);
 162                 break;
 163         }
 164
 165         mutex_unlock(&lock);
 166
 167         module_put(THIS_MODULE);
 168 }
 169 EXPORT_SYMBOL_GPL(irq_bypass_unregister_producer);
 170
 171 /**
 172  * irq_bypass_register_consumer - register IRQ bypass consumer
 173  * @consumer: pointer to consumer structure
 174  *
 175  * Add the provided IRQ consumer to the list of consumers and connect
 176  * with any matching token found on the IRQ producer list.
 177  */
 178 int irq_bypass_register_consumer(struct irq_bypass_consumer *consumer)
 179 {
 180         struct irq_bypass_consumer *tmp;
 181         struct irq_bypass_producer *producer;
 182
 183         if (!consumer->token ||
 184             !consumer->add_producer || !consumer->del_producer)
 185                 return -EINVAL;
 186
 187         might_sleep();
 188
 189         if (!try_module_get(THIS_MODULE))
 190                 return -ENODEV;
 191
 192         mutex_lock(&lock);
 193
 194         list_for_each_entry(tmp, &consumers, node) {
 195                 if (tmp->token == consumer->token || tmp == consumer) {
 196                         mutex_unlock(&lock);
 197                         module_put(THIS_MODULE);
 198                         return -EBUSY;
 199                 }
 200         }
 201
 202         list_for_each_entry(producer, &producers, node) {
 203                 if (producer->token == consumer->token) {
 204                         int ret = __connect(producer, consumer);
 205                         if (ret) {
 206                                 mutex_unlock(&lock);
 207                                 module_put(THIS_MODULE);
 208                                 return ret;
 209                         }
 210                         break;
 211                 }
 212         }
 213
 214         list_add(&consumer->node, &consumers);
 215
 216         mutex_unlock(&lock);
 217
 218         return 0;
 219 }
 220 EXPORT_SYMBOL_GPL(irq_bypass_register_consumer);
 221
 222 /**
 223  * irq_bypass_unregister_consumer - unregister IRQ bypass consumer
 224  * @consumer: pointer to consumer structure
 225  *
 226  * Remove a previously registered IRQ consumer from the list of consumers
 227  * and disconnect it from any connected IRQ producer.
 228  */
 229 void irq_bypass_unregister_consumer(struct irq_bypass_consumer *consumer)
 230 {
 231         struct irq_bypass_consumer *tmp;
 232         struct irq_bypass_producer *producer;
 233
 234         if (!consumer->token)
 235                 return;
 236
 237         might_sleep();
 238
 239         if (!try_module_get(THIS_MODULE))
 240                 return; /* nothing in the list anyway */
 241
 242         mutex_lock(&lock);
 243
 244         list_for_each_entry(tmp, &consumers, node) {
 245                 if (tmp != consumer)
 246                         continue;
 247
 248                 list_for_each_entry(producer, &producers, node) {
 249                         if (producer->token == consumer->token) {
 250                                 __disconnect(producer, consumer);
 251                                 break;
 252                         }
 253                 }
 254
 255                 list_del(&consumer->node);
 256                 module_put(THIS_MODULE);
 257                 break;
 258         }
 259
 260         mutex_unlock(&lock);
 261
 262         module_put(THIS_MODULE);
 263 }
 264 EXPORT_SYMBOL_GPL(irq_bypass_unregister_consumer);