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