qemu-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 "event_notifier.h"
  20
  21 typedef struct BlockDriverAIOCB BlockDriverAIOCB;
  22 typedef void BlockDriverCompletionFunc(void *opaque, int ret);
  23
  24 typedef struct AIOPool {
  25     void (*cancel)(BlockDriverAIOCB *acb);
  26     int aiocb_size;
  27     BlockDriverAIOCB *free_aiocb;
  28 } AIOPool;
  29
  30 struct BlockDriverAIOCB {
  31     AIOPool *pool;
  32     BlockDriverState *bs;
  33     BlockDriverCompletionFunc *cb;
  34     void *opaque;
  35     BlockDriverAIOCB *next;
  36 };
  37
  38 void *qemu_aio_get(AIOPool *pool, BlockDriverState *bs,
  39                    BlockDriverCompletionFunc *cb, void *opaque);
  40 void qemu_aio_release(void *p);
  41
  42 typedef struct AioHandler AioHandler;
  43 typedef void QEMUBHFunc(void *opaque);
  44 typedef void IOHandler(void *opaque);
  45
  46 typedef struct AioContext {
  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 } AioContext;
  64
  65 /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
  66 typedef int (AioFlushEventNotifierHandler)(EventNotifier *e);
  67
  68 /**
  69  * aio_context_new: Allocate a new AioContext.
  70  *
  71  * AioContext provide a mini event-loop that can be waited on synchronously.
  72  * They also provide bottom halves, a service to execute a piece of code
  73  * as soon as possible.
  74  */
  75 AioContext *aio_context_new(void);
  76
  77 /**
  78  * aio_bh_new: Allocate a new bottom half structure.
  79  *
  80  * Bottom halves are lightweight callbacks whose invocation is guaranteed
  81  * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
  82  * is opaque and must be allocated prior to its use.
  83  */
  84 QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
  85
  86 /**
  87  * aio_bh_poll: Poll bottom halves for an AioContext.
  88  *
  89  * These are internal functions used by the QEMU main loop.
  90  */
  91 int aio_bh_poll(AioContext *ctx);
  92 void aio_bh_update_timeout(AioContext *ctx, uint32_t *timeout);
  93
  94 /**
  95  * qemu_bh_schedule: Schedule a bottom half.
  96  *
  97  * Scheduling a bottom half interrupts the main loop and causes the
  98  * execution of the callback that was passed to qemu_bh_new.
  99  *
 100  * Bottom halves that are scheduled from a bottom half handler are instantly
 101  * invoked.  This can create an infinite loop if a bottom half handler
 102  * schedules itself.
 103  *
 104  * @bh: The bottom half to be scheduled.
 105  */
 106 void qemu_bh_schedule(QEMUBH *bh);
 107
 108 /**
 109  * qemu_bh_cancel: Cancel execution of a bottom half.
 110  *
 111  * Canceling execution of a bottom half undoes the effect of calls to
 112  * qemu_bh_schedule without freeing its resources yet.  While cancellation
 113  * itself is also wait-free and thread-safe, it can of course race with the
 114  * loop that executes bottom halves unless you are holding the iothread
 115  * mutex.  This makes it mostly useless if you are not holding the mutex.
 116  *
 117  * @bh: The bottom half to be canceled.
 118  */
 119 void qemu_bh_cancel(QEMUBH *bh);
 120
 121 /**
 122  *qemu_bh_delete: Cancel execution of a bottom half and free its resources.
 123  *
 124  * Deleting a bottom half frees the memory that was allocated for it by
 125  * qemu_bh_new.  It also implies canceling the bottom half if it was
 126  * scheduled.
 127  *
 128  * @bh: The bottom half to be deleted.
 129  */
 130 void qemu_bh_delete(QEMUBH *bh);
 131
 132 /* Flush any pending AIO operation. This function will block until all
 133  * outstanding AIO operations have been completed or cancelled. */
 134 void aio_flush(AioContext *ctx);
 135
 136 /* Progress in completing AIO work to occur.  This can issue new pending
 137  * aio as a result of executing I/O completion or bh callbacks.
 138  *
 139  * If there is no pending AIO operation or completion (bottom half),
 140  * return false.  If there are pending bottom halves, return true.
 141  *
 142  * If there are no pending bottom halves, but there are pending AIO
 143  * operations, it may not be possible to make any progress without
 144  * blocking.  If @blocking is true, this function will wait until one
 145  * or more AIO events have completed, to ensure something has moved
 146  * before returning.
 147  *
 148  * If @blocking is false, this function will also return false if the
 149  * function cannot make any progress without blocking.
 150  */
 151 bool aio_poll(AioContext *ctx, bool blocking);
 152
 153 #ifdef CONFIG_POSIX
 154 /* Returns 1 if there are still outstanding AIO requests; 0 otherwise */
 155 typedef int (AioFlushHandler)(void *opaque);
 156
 157 /* Register a file descriptor and associated callbacks.  Behaves very similarly
 158  * to qemu_set_fd_handler2.  Unlike qemu_set_fd_handler2, these callbacks will
 159  * be invoked when using either qemu_aio_wait() or qemu_aio_flush().
 160  *
 161  * Code that invokes AIO completion functions should rely on this function
 162  * instead of qemu_set_fd_handler[2].
 163  */
 164 void aio_set_fd_handler(AioContext *ctx,
 165                         int fd,
 166                         IOHandler *io_read,
 167                         IOHandler *io_write,
 168                         AioFlushHandler *io_flush,
 169                         void *opaque);
 170 #endif
 171
 172 /* Register an event notifier and associated callbacks.  Behaves very similarly
 173  * to event_notifier_set_handler.  Unlike event_notifier_set_handler, these callbacks
 174  * will be invoked when using either qemu_aio_wait() or qemu_aio_flush().
 175  *
 176  * Code that invokes AIO completion functions should rely on this function
 177  * instead of event_notifier_set_handler.
 178  */
 179 void aio_set_event_notifier(AioContext *ctx,
 180                             EventNotifier *notifier,
 181                             EventNotifierHandler *io_read,
 182                             AioFlushEventNotifierHandler *io_flush);
 183
 184 /* Functions to operate on the main QEMU AioContext.  */
 185
 186 void qemu_aio_flush(void);
 187 bool qemu_aio_wait(void);
 188 void qemu_aio_set_event_notifier(EventNotifier *notifier,
 189                                  EventNotifierHandler *io_read,
 190                                  AioFlushEventNotifierHandler *io_flush);
 191
 192 #ifdef CONFIG_POSIX
 193 void qemu_aio_set_fd_handler(int fd,
 194                              IOHandler *io_read,
 195                              IOHandler *io_write,
 196                              AioFlushHandler *io_flush,
 197                              void *opaque);
 198 #endif
 199
 200 #endif