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> 16 #include <linux/module.h> 17 #include <linux/slab.h> 18 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 23 static struct workqueue_struct *vfio_irqfd_cleanup_wq; 24 static DEFINE_SPINLOCK(virqfd_lock); 25 26 static int __init vfio_virqfd_init(void) 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 36 static void __exit vfio_virqfd_exit(void) 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); 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); 227