async.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu-common.h"
  26 #include "qemu-aio.h"
  27 #include "main-loop.h"
  28
  29 /***********************************************************/
  30 /* bottom halves (can be seen as timers which expire ASAP) */
  31
  32 struct QEMUBH {
  33     QEMUBHFunc *cb;
  34     void *opaque;
  35     QEMUBH *next;
  36     bool scheduled;
  37     bool idle;
  38     bool deleted;
  39 };
  40
  41 QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
  42 {
  43     QEMUBH *bh;
  44     bh = g_malloc0(sizeof(QEMUBH));
  45     bh->cb = cb;
  46     bh->opaque = opaque;
  47     bh->next = ctx->first_bh;
  48     ctx->first_bh = bh;
  49     return bh;
  50 }
  51
  52 int aio_bh_poll(AioContext *ctx)
  53 {
  54     QEMUBH *bh, **bhp, *next;
  55     int ret;
  56
  57     ctx->walking_bh++;
  58
  59     ret = 0;
  60     for (bh = ctx->first_bh; bh; bh = next) {
  61         next = bh->next;
  62         if (!bh->deleted && bh->scheduled) {
  63             bh->scheduled = 0;
  64             if (!bh->idle)
  65                 ret = 1;
  66             bh->idle = 0;
  67             bh->cb(bh->opaque);
  68         }
  69     }
  70
  71     ctx->walking_bh--;
  72
  73     /* remove deleted bhs */
  74     if (!ctx->walking_bh) {
  75         bhp = &ctx->first_bh;
  76         while (*bhp) {
  77             bh = *bhp;
  78             if (bh->deleted) {
  79                 *bhp = bh->next;
  80                 g_free(bh);
  81             } else {
  82                 bhp = &bh->next;
  83             }
  84         }
  85     }
  86
  87     return ret;
  88 }
  89
  90 void qemu_bh_schedule_idle(QEMUBH *bh)
  91 {
  92     if (bh->scheduled)
  93         return;
  94     bh->scheduled = 1;
  95     bh->idle = 1;
  96 }
  97
  98 void qemu_bh_schedule(QEMUBH *bh)
  99 {
 100     if (bh->scheduled)
 101         return;
 102     bh->scheduled = 1;
 103     bh->idle = 0;
 104     /* stop the currently executing CPU to execute the BH ASAP */
 105     qemu_notify_event();
 106 }
 107
 108 void qemu_bh_cancel(QEMUBH *bh)
 109 {
 110     bh->scheduled = 0;
 111 }
 112
 113 void qemu_bh_delete(QEMUBH *bh)
 114 {
 115     bh->scheduled = 0;
 116     bh->deleted = 1;
 117 }
 118
 119 void aio_bh_update_timeout(AioContext *ctx, uint32_t *timeout)
 120 {
 121     QEMUBH *bh;
 122
 123     for (bh = ctx->first_bh; bh; bh = bh->next) {
 124         if (!bh->deleted && bh->scheduled) {
 125             if (bh->idle) {
 126                 /* idle bottom halves will be polled at least
 127                  * every 10ms */
 128                 *timeout = MIN(10, *timeout);
 129             } else {
 130                 /* non-idle bottom halves will be executed
 131                  * immediately */
 132                 *timeout = 0;
 133                 break;
 134             }
 135         }
 136     }
 137 }
 138
 139 static gboolean
 140 aio_ctx_prepare(GSource *source, gint    *timeout)
 141 {
 142     AioContext *ctx = (AioContext *) source;
 143     uint32_t wait = -1;
 144     aio_bh_update_timeout(ctx, &wait);
 145
 146     if (wait != -1) {
 147         *timeout = MIN(*timeout, wait);
 148         return wait == 0;
 149     }
 150
 151     return false;
 152 }
 153
 154 static gboolean
 155 aio_ctx_check(GSource *source)
 156 {
 157     AioContext *ctx = (AioContext *) source;
 158     QEMUBH *bh;
 159
 160     for (bh = ctx->first_bh; bh; bh = bh->next) {
 161         if (!bh->deleted && bh->scheduled) {
 162             return true;
 163         }
 164     }
 165     return aio_pending(ctx);
 166 }
 167
 168 static gboolean
 169 aio_ctx_dispatch(GSource     *source,
 170                  GSourceFunc  callback,
 171                  gpointer     user_data)
 172 {
 173     AioContext *ctx = (AioContext *) source;
 174
 175     assert(callback == NULL);
 176     aio_poll(ctx, false);
 177     return true;
 178 }
 179
 180 static GSourceFuncs aio_source_funcs = {
 181     aio_ctx_prepare,
 182     aio_ctx_check,
 183     aio_ctx_dispatch,
 184     NULL
 185 };
 186
 187 GSource *aio_get_g_source(AioContext *ctx)
 188 {
 189     g_source_ref(&ctx->source);
 190     return &ctx->source;
 191 }
 192
 193 AioContext *aio_context_new(void)
 194 {
 195     return (AioContext *) g_source_new(&aio_source_funcs, sizeof(AioContext));
 196 }
 197
 198 void aio_context_ref(AioContext *ctx)
 199 {
 200     g_source_ref(&ctx->source);
 201 }
 202
 203 void aio_context_unref(AioContext *ctx)
 204 {
 205     g_source_unref(&ctx->source);
 206 }
 207
 208 void aio_flush(AioContext *ctx)
 209 {
 210     while (aio_poll(ctx, true));
 211 }