1 /* 2 * QEMU aio implementation 3 * 4 * Copyright IBM, Corp. 2008 5 * 6 * Authors: 7 * Anthony Liguori <aliguori@us.ibm.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2. See 10 * the COPYING file in the top-level directory. 11 * 12 */ 13 14 #ifndef QEMU_AIO_H 15 #define QEMU_AIO_H 16 17 #include "qemu-common.h" 18 #include "qemu/queue.h" 19 #include "qemu/event_notifier.h" 20 #include "qemu/thread.h" 21 22 typedef struct BlockDriverAIOCB BlockDriverAIOCB; 23 typedef void BlockDriverCompletionFunc(void *opaque, int ret); 24 25 typedef struct AIOCBInfo { 26 void (*cancel)(BlockDriverAIOCB *acb); 27 size_t aiocb_size; 28 } AIOCBInfo; 29 30 struct BlockDriverAIOCB { 31 const AIOCBInfo *aiocb_info; 32 BlockDriverState *bs; 33 BlockDriverCompletionFunc *cb; 34 void *opaque; 35 }; 36 37 void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs, 38 BlockDriverCompletionFunc *cb, void *opaque); 39 void qemu_aio_release(void *p); 40 41 typedef struct AioHandler AioHandler; 42 typedef void QEMUBHFunc(void *opaque); 43 typedef void IOHandler(void *opaque); 44 45 typedef struct AioContext { 46 GSource source; 47 48 /* The list of registered AIO handlers */ 49 QLIST_HEAD(, AioHandler) aio_handlers; 50 51 /* This is a simple lock used to protect the aio_handlers list. 52 * Specifically, it's used to ensure that no callbacks are removed while 53 * we're walking and dispatching callbacks. 54 */ 55 int walking_handlers; 56 57 /* lock to protect between bh's adders and deleter */ 58 QemuMutex bh_lock; 59 /* Anchor of the list of Bottom Halves belonging to the context */ 60 struct QEMUBH *first_bh; 61 62 /* A simple lock used to protect the first_bh list, and ensure that 63 * no callbacks are removed while we're walking and dispatching callbacks. 64 */ 65 int walking_bh; 66 67 /* Used for aio_notify. */ 68 EventNotifier notifier; 69 70 /* GPollFDs for aio_poll() */ 71 GArray *pollfds; 72 73 /* Thread pool for performing work and receiving completion callbacks */ 74 struct ThreadPool *thread_pool; 75 } AioContext; 76 77 /** 78 * aio_context_new: Allocate a new AioContext. 79 * 80 * AioContext provide a mini event-loop that can be waited on synchronously. 81 * They also provide bottom halves, a service to execute a piece of code 82 * as soon as possible. 83 */ 84 AioContext *aio_context_new(void); 85 86 /** 87 * aio_context_ref: 88 * @ctx: The AioContext to operate on. 89 * 90 * Add a reference to an AioContext. 91 */ 92 void aio_context_ref(AioContext *ctx); 93 94 /** 95 * aio_context_unref: 96 * @ctx: The AioContext to operate on. 97 * 98 * Drop a reference to an AioContext. 99 */ 100 void aio_context_unref(AioContext *ctx); 101 102 /** 103 * aio_bh_new: Allocate a new bottom half structure. 104 * 105 * Bottom halves are lightweight callbacks whose invocation is guaranteed 106 * to be wait-free, thread-safe and signal-safe. The #QEMUBH structure 107 * is opaque and must be allocated prior to its use. 108 */ 109 QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque); 110 111 /** 112 * aio_notify: Force processing of pending events. 113 * 114 * Similar to signaling a condition variable, aio_notify forces 115 * aio_wait to exit, so that the next call will re-examine pending events. 116 * The caller of aio_notify will usually call aio_wait again very soon, 117 * or go through another iteration of the GLib main loop. Hence, aio_notify 118 * also has the side effect of recalculating the sets of file descriptors 119 * that the main loop waits for. 120 * 121 * Calling aio_notify is rarely necessary, because for example scheduling 122 * a bottom half calls it already. 123 */ 124 void aio_notify(AioContext *ctx); 125 126 /** 127 * aio_bh_poll: Poll bottom halves for an AioContext. 128 * 129 * These are internal functions used by the QEMU main loop. 130 * And notice that multiple occurrences of aio_bh_poll cannot 131 * be called concurrently 132 */ 133 int aio_bh_poll(AioContext *ctx); 134 135 /** 136 * qemu_bh_schedule: Schedule a bottom half. 137 * 138 * Scheduling a bottom half interrupts the main loop and causes the 139 * execution of the callback that was passed to qemu_bh_new. 140 * 141 * Bottom halves that are scheduled from a bottom half handler are instantly 142 * invoked. This can create an infinite loop if a bottom half handler 143 * schedules itself. 144 * 145 * @bh: The bottom half to be scheduled. 146 */ 147 void qemu_bh_schedule(QEMUBH *bh); 148 149 /** 150 * qemu_bh_cancel: Cancel execution of a bottom half. 151 * 152 * Canceling execution of a bottom half undoes the effect of calls to 153 * qemu_bh_schedule without freeing its resources yet. While cancellation 154 * itself is also wait-free and thread-safe, it can of course race with the 155 * loop that executes bottom halves unless you are holding the iothread 156 * mutex. This makes it mostly useless if you are not holding the mutex. 157 * 158 * @bh: The bottom half to be canceled. 159 */ 160 void qemu_bh_cancel(QEMUBH *bh); 161 162 /** 163 *qemu_bh_delete: Cancel execution of a bottom half and free its resources. 164 * 165 * Deleting a bottom half frees the memory that was allocated for it by 166 * qemu_bh_new. It also implies canceling the bottom half if it was 167 * scheduled. 168 * This func is async. The bottom half will do the delete action at the finial 169 * end. 170 * 171 * @bh: The bottom half to be deleted. 172 */ 173 void qemu_bh_delete(QEMUBH *bh); 174 175 /* Return whether there are any pending callbacks from the GSource 176 * attached to the AioContext. 177 * 178 * This is used internally in the implementation of the GSource. 179 */ 180 bool aio_pending(AioContext *ctx); 181 182 /* Progress in completing AIO work to occur. This can issue new pending 183 * aio as a result of executing I/O completion or bh callbacks. 184 * 185 * If there is no pending AIO operation or completion (bottom half), 186 * return false. If there are pending AIO operations of bottom halves, 187 * return true. 188 * 189 * If there are no pending bottom halves, but there are pending AIO 190 * operations, it may not be possible to make any progress without 191 * blocking. If @blocking is true, this function will wait until one 192 * or more AIO events have completed, to ensure something has moved 193 * before returning. 194 */ 195 bool aio_poll(AioContext *ctx, bool blocking); 196 197 #ifdef CONFIG_POSIX 198 /* Register a file descriptor and associated callbacks. Behaves very similarly 199 * to qemu_set_fd_handler2. Unlike qemu_set_fd_handler2, these callbacks will 200 * be invoked when using qemu_aio_wait(). 201 * 202 * Code that invokes AIO completion functions should rely on this function 203 * instead of qemu_set_fd_handler[2]. 204 */ 205 void aio_set_fd_handler(AioContext *ctx, 206 int fd, 207 IOHandler *io_read, 208 IOHandler *io_write, 209 void *opaque); 210 #endif 211 212 /* Register an event notifier and associated callbacks. Behaves very similarly 213 * to event_notifier_set_handler. Unlike event_notifier_set_handler, these callbacks 214 * will be invoked when using qemu_aio_wait(). 215 * 216 * Code that invokes AIO completion functions should rely on this function 217 * instead of event_notifier_set_handler. 218 */ 219 void aio_set_event_notifier(AioContext *ctx, 220 EventNotifier *notifier, 221 EventNotifierHandler *io_read); 222 223 /* Return a GSource that lets the main loop poll the file descriptors attached 224 * to this AioContext. 225 */ 226 GSource *aio_get_g_source(AioContext *ctx); 227 228 /* Return the ThreadPool bound to this AioContext */ 229 struct ThreadPool *aio_get_thread_pool(AioContext *ctx); 230 231 /* Functions to operate on the main QEMU AioContext. */ 232 233 bool qemu_aio_wait(void); 234 void qemu_aio_set_event_notifier(EventNotifier *notifier, 235 EventNotifierHandler *io_read); 236 237 #ifdef CONFIG_POSIX 238 void qemu_aio_set_fd_handler(int fd, 239 IOHandler *io_read, 240 IOHandler *io_write, 241 void *opaque); 242 #endif 243 244 #endif 245