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