include/block/aio.h

   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
  67     /* GPollFDs for aio_poll() */
  68     GArray *pollfds;
  69
  70     /* Thread pool for performing work and receiving completion callbacks */
  71     struct ThreadPool *thread_pool;
  72 } AioContext;
  73
  74 /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
  75 typedef int (AioFlushEventNotifierHandler)(EventNotifier *e);
  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  */
 131 int aio_bh_poll(AioContext *ctx);
 132
 133 /**
 134  * qemu_bh_schedule: Schedule a bottom half.
 135  *
 136  * Scheduling a bottom half interrupts the main loop and causes the
 137  * execution of the callback that was passed to qemu_bh_new.
 138  *
 139  * Bottom halves that are scheduled from a bottom half handler are instantly
 140  * invoked.  This can create an infinite loop if a bottom half handler
 141  * schedules itself.
 142  *
 143  * @bh: The bottom half to be scheduled.
 144  */
 145 void qemu_bh_schedule(QEMUBH *bh);
 146
 147 /**
 148  * qemu_bh_cancel: Cancel execution of a bottom half.
 149  *
 150  * Canceling execution of a bottom half undoes the effect of calls to
 151  * qemu_bh_schedule without freeing its resources yet.  While cancellation
 152  * itself is also wait-free and thread-safe, it can of course race with the
 153  * loop that executes bottom halves unless you are holding the iothread
 154  * mutex.  This makes it mostly useless if you are not holding the mutex.
 155  *
 156  * @bh: The bottom half to be canceled.
 157  */
 158 void qemu_bh_cancel(QEMUBH *bh);
 159
 160 /**
 161  *qemu_bh_delete: Cancel execution of a bottom half and free its resources.
 162  *
 163  * Deleting a bottom half frees the memory that was allocated for it by
 164  * qemu_bh_new.  It also implies canceling the bottom half if it was
 165  * scheduled.
 166  *
 167  * @bh: The bottom half to be deleted.
 168  */
 169 void qemu_bh_delete(QEMUBH *bh);
 170
 171 /* Return whether there are any pending callbacks from the GSource
 172  * attached to the AioContext.
 173  *
 174  * This is used internally in the implementation of the GSource.
 175  */
 176 bool aio_pending(AioContext *ctx);
 177
 178 /* Progress in completing AIO work to occur.  This can issue new pending
 179  * aio as a result of executing I/O completion or bh callbacks.
 180  *
 181  * If there is no pending AIO operation or completion (bottom half),
 182  * return false.  If there are pending AIO operations of bottom halves,
 183  * return true.
 184  *
 185  * If there are no pending bottom halves, but there are pending AIO
 186  * operations, it may not be possible to make any progress without
 187  * blocking.  If @blocking is true, this function will wait until one
 188  * or more AIO events have completed, to ensure something has moved
 189  * before returning.
 190  */
 191 bool aio_poll(AioContext *ctx, bool blocking);
 192
 193 #ifdef CONFIG_POSIX
 194 /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
 195 typedef int (AioFlushHandler)(void *opaque);
 196
 197 /* Register a file descriptor and associated callbacks.  Behaves very similarly
 198  * to qemu_set_fd_handler2.  Unlike qemu_set_fd_handler2, these callbacks will
 199  * be invoked when using qemu_aio_wait().
 200  *
 201  * Code that invokes AIO completion functions should rely on this function
 202  * instead of qemu_set_fd_handler[2].
 203  */
 204 void aio_set_fd_handler(AioContext *ctx,
 205                         int fd,
 206                         IOHandler *io_read,
 207                         IOHandler *io_write,
 208                         AioFlushHandler *io_flush,
 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                             AioFlushEventNotifierHandler *io_flush);
 223
 224 /* Return a GSource that lets the main loop poll the file descriptors attached
 225  * to this AioContext.
 226  */
 227 GSource *aio_get_g_source(AioContext *ctx);
 228
 229 /* Return the ThreadPool bound to this AioContext */
 230 struct ThreadPool *aio_get_thread_pool(AioContext *ctx);
 231
 232 /* Functions to operate on the main QEMU AioContext.  */
 233
 234 bool qemu_aio_wait(void);
 235 void qemu_aio_set_event_notifier(EventNotifier *notifier,
 236                                  EventNotifierHandler *io_read,
 237                                  AioFlushEventNotifierHandler *io_flush);
 238
 239 #ifdef CONFIG_POSIX
 240 void qemu_aio_set_fd_handler(int fd,
 241                              IOHandler *io_read,
 242                              IOHandler *io_write,
 243                              AioFlushHandler *io_flush,
 244                              void *opaque);
 245 #endif
 246
 247 #endif