Commit | Line | Data |
---|---|---|
7e992d69 AM |
1 | /* |
2 | * VFIO generic eventfd code for IRQFD support. | |
3 | * Derived from drivers/vfio/pci/vfio_pci_intrs.c | |
4 | * | |
5 | * Copyright (C) 2012 Red Hat, Inc. All rights reserved. | |
6 | * Author: Alex Williamson <alex.williamson@redhat.com> | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or modify | |
9 | * it under the terms of the GNU General Public License version 2 as | |
10 | * published by the Free Software Foundation. | |
11 | */ | |
12 | ||
13 | #include <linux/vfio.h> | |
14 | #include <linux/eventfd.h> | |
15 | #include <linux/file.h> | |
71be3423 | 16 | #include <linux/module.h> |
7e992d69 AM |
17 | #include <linux/slab.h> |
18 | ||
71be3423 AW |
19 | #define DRIVER_VERSION "0.1" |
20 | #define DRIVER_AUTHOR "Alex Williamson <alex.williamson@redhat.com>" | |
21 | #define DRIVER_DESC "IRQFD support for VFIO bus drivers" | |
22 | ||
7e992d69 | 23 | static struct workqueue_struct *vfio_irqfd_cleanup_wq; |
66fdc052 | 24 | static DEFINE_SPINLOCK(virqfd_lock); |
7e992d69 | 25 | |
71be3423 | 26 | static int __init vfio_virqfd_init(void) |
7e992d69 AM |
27 | { |
28 | vfio_irqfd_cleanup_wq = | |
29 | create_singlethread_workqueue("vfio-irqfd-cleanup"); | |
30 | if (!vfio_irqfd_cleanup_wq) | |
31 | return -ENOMEM; | |
32 | ||
33 | return 0; | |
34 | } | |
35 | ||
71be3423 | 36 | static void __exit vfio_virqfd_exit(void) |
7e992d69 AM |
37 | { |
38 | destroy_workqueue(vfio_irqfd_cleanup_wq); | |
39 | } | |
40 | ||
41 | static void virqfd_deactivate(struct virqfd *virqfd) | |
42 | { | |
43 | queue_work(vfio_irqfd_cleanup_wq, &virqfd->shutdown); | |
44 | } | |
45 | ||
46 | static int virqfd_wakeup(wait_queue_t *wait, unsigned mode, int sync, void *key) | |
47 | { | |
48 | struct virqfd *virqfd = container_of(wait, struct virqfd, wait); | |
49 | unsigned long flags = (unsigned long)key; | |
50 | ||
51 | if (flags & POLLIN) { | |
52 | /* An event has been signaled, call function */ | |
53 | if ((!virqfd->handler || | |
54 | virqfd->handler(virqfd->opaque, virqfd->data)) && | |
55 | virqfd->thread) | |
56 | schedule_work(&virqfd->inject); | |
57 | } | |
58 | ||
59 | if (flags & POLLHUP) { | |
60 | unsigned long flags; | |
61 | spin_lock_irqsave(&virqfd_lock, flags); | |
62 | ||
63 | /* | |
64 | * The eventfd is closing, if the virqfd has not yet been | |
65 | * queued for release, as determined by testing whether the | |
66 | * virqfd pointer to it is still valid, queue it now. As | |
67 | * with kvm irqfds, we know we won't race against the virqfd | |
68 | * going away because we hold the lock to get here. | |
69 | */ | |
70 | if (*(virqfd->pvirqfd) == virqfd) { | |
71 | *(virqfd->pvirqfd) = NULL; | |
72 | virqfd_deactivate(virqfd); | |
73 | } | |
74 | ||
75 | spin_unlock_irqrestore(&virqfd_lock, flags); | |
76 | } | |
77 | ||
78 | return 0; | |
79 | } | |
80 | ||
81 | static void virqfd_ptable_queue_proc(struct file *file, | |
82 | wait_queue_head_t *wqh, poll_table *pt) | |
83 | { | |
84 | struct virqfd *virqfd = container_of(pt, struct virqfd, pt); | |
85 | add_wait_queue(wqh, &virqfd->wait); | |
86 | } | |
87 | ||
88 | static void virqfd_shutdown(struct work_struct *work) | |
89 | { | |
90 | struct virqfd *virqfd = container_of(work, struct virqfd, shutdown); | |
91 | u64 cnt; | |
92 | ||
93 | eventfd_ctx_remove_wait_queue(virqfd->eventfd, &virqfd->wait, &cnt); | |
94 | flush_work(&virqfd->inject); | |
95 | eventfd_ctx_put(virqfd->eventfd); | |
96 | ||
97 | kfree(virqfd); | |
98 | } | |
99 | ||
100 | static void virqfd_inject(struct work_struct *work) | |
101 | { | |
102 | struct virqfd *virqfd = container_of(work, struct virqfd, inject); | |
103 | if (virqfd->thread) | |
104 | virqfd->thread(virqfd->opaque, virqfd->data); | |
105 | } | |
106 | ||
107 | int vfio_virqfd_enable(void *opaque, | |
108 | int (*handler)(void *, void *), | |
109 | void (*thread)(void *, void *), | |
110 | void *data, struct virqfd **pvirqfd, int fd) | |
111 | { | |
112 | struct fd irqfd; | |
113 | struct eventfd_ctx *ctx; | |
114 | struct virqfd *virqfd; | |
115 | int ret = 0; | |
116 | unsigned int events; | |
117 | ||
118 | virqfd = kzalloc(sizeof(*virqfd), GFP_KERNEL); | |
119 | if (!virqfd) | |
120 | return -ENOMEM; | |
121 | ||
122 | virqfd->pvirqfd = pvirqfd; | |
123 | virqfd->opaque = opaque; | |
124 | virqfd->handler = handler; | |
125 | virqfd->thread = thread; | |
126 | virqfd->data = data; | |
127 | ||
128 | INIT_WORK(&virqfd->shutdown, virqfd_shutdown); | |
129 | INIT_WORK(&virqfd->inject, virqfd_inject); | |
130 | ||
131 | irqfd = fdget(fd); | |
132 | if (!irqfd.file) { | |
133 | ret = -EBADF; | |
134 | goto err_fd; | |
135 | } | |
136 | ||
137 | ctx = eventfd_ctx_fileget(irqfd.file); | |
138 | if (IS_ERR(ctx)) { | |
139 | ret = PTR_ERR(ctx); | |
140 | goto err_ctx; | |
141 | } | |
142 | ||
143 | virqfd->eventfd = ctx; | |
144 | ||
145 | /* | |
146 | * virqfds can be released by closing the eventfd or directly | |
147 | * through ioctl. These are both done through a workqueue, so | |
148 | * we update the pointer to the virqfd under lock to avoid | |
149 | * pushing multiple jobs to release the same virqfd. | |
150 | */ | |
151 | spin_lock_irq(&virqfd_lock); | |
152 | ||
153 | if (*pvirqfd) { | |
154 | spin_unlock_irq(&virqfd_lock); | |
155 | ret = -EBUSY; | |
156 | goto err_busy; | |
157 | } | |
158 | *pvirqfd = virqfd; | |
159 | ||
160 | spin_unlock_irq(&virqfd_lock); | |
161 | ||
162 | /* | |
163 | * Install our own custom wake-up handling so we are notified via | |
164 | * a callback whenever someone signals the underlying eventfd. | |
165 | */ | |
166 | init_waitqueue_func_entry(&virqfd->wait, virqfd_wakeup); | |
167 | init_poll_funcptr(&virqfd->pt, virqfd_ptable_queue_proc); | |
168 | ||
169 | events = irqfd.file->f_op->poll(irqfd.file, &virqfd->pt); | |
170 | ||
171 | /* | |
172 | * Check if there was an event already pending on the eventfd | |
173 | * before we registered and trigger it as if we didn't miss it. | |
174 | */ | |
175 | if (events & POLLIN) { | |
176 | if ((!handler || handler(opaque, data)) && thread) | |
177 | schedule_work(&virqfd->inject); | |
178 | } | |
179 | ||
180 | /* | |
181 | * Do not drop the file until the irqfd is fully initialized, | |
182 | * otherwise we might race against the POLLHUP. | |
183 | */ | |
184 | fdput(irqfd); | |
185 | ||
186 | return 0; | |
187 | err_busy: | |
188 | eventfd_ctx_put(ctx); | |
189 | err_ctx: | |
190 | fdput(irqfd); | |
191 | err_fd: | |
192 | kfree(virqfd); | |
193 | ||
194 | return ret; | |
195 | } | |
196 | EXPORT_SYMBOL_GPL(vfio_virqfd_enable); | |
197 | ||
198 | void vfio_virqfd_disable(struct virqfd **pvirqfd) | |
199 | { | |
200 | unsigned long flags; | |
201 | ||
202 | spin_lock_irqsave(&virqfd_lock, flags); | |
203 | ||
204 | if (*pvirqfd) { | |
205 | virqfd_deactivate(*pvirqfd); | |
206 | *pvirqfd = NULL; | |
207 | } | |
208 | ||
209 | spin_unlock_irqrestore(&virqfd_lock, flags); | |
210 | ||
211 | /* | |
212 | * Block until we know all outstanding shutdown jobs have completed. | |
213 | * Even if we don't queue the job, flush the wq to be sure it's | |
214 | * been released. | |
215 | */ | |
216 | flush_workqueue(vfio_irqfd_cleanup_wq); | |
217 | } | |
218 | EXPORT_SYMBOL_GPL(vfio_virqfd_disable); | |
71be3423 AW |
219 | |
220 | module_init(vfio_virqfd_init); | |
221 | module_exit(vfio_virqfd_exit); | |
222 | ||
223 | MODULE_VERSION(DRIVER_VERSION); | |
224 | MODULE_LICENSE("GPL v2"); | |
225 | MODULE_AUTHOR(DRIVER_AUTHOR); | |
226 | MODULE_DESCRIPTION(DRIVER_DESC); |