bonding: Always enable vlan tx offload
[muen/linux.git] / 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);