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
  28 /* Anchor of the list of Bottom Halves belonging to the context */
  29 static struct QEMUBH *first_bh;
  30
  31 /***********************************************************/
  32 /* bottom halves (can be seen as timers which expire ASAP) */
  33
  34 struct QEMUBH {
  35     QEMUBHFunc *cb;
  36     void *opaque;
  37     int scheduled;
  38     int idle;
  39     int deleted;
  40     QEMUBH *next;
  41 };
  42
  43 QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
  44 {
  45     QEMUBH *bh;
  46     bh = g_malloc0(sizeof(QEMUBH));
  47     bh->cb = cb;
  48     bh->opaque = opaque;
  49     bh->next = first_bh;
  50     first_bh = bh;
  51     return bh;
  52 }
  53
  54 int qemu_bh_poll(void)
  55 {
  56     QEMUBH *bh, **bhp, *next;
  57     int ret;
  58
  59     ret = 0;
  60     for (bh = 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     /* remove deleted bhs */
  72     bhp = &first_bh;
  73     while (*bhp) {
  74         bh = *bhp;
  75         if (bh->deleted) {
  76             *bhp = bh->next;
  77             g_free(bh);
  78         } else
  79             bhp = &bh->next;
  80     }
  81
  82     return ret;
  83 }
  84
  85 void qemu_bh_schedule_idle(QEMUBH *bh)
  86 {
  87     if (bh->scheduled)
  88         return;
  89     bh->scheduled = 1;
  90     bh->idle = 1;
  91 }
  92
  93 void qemu_bh_schedule(QEMUBH *bh)
  94 {
  95     if (bh->scheduled)
  96         return;
  97     bh->scheduled = 1;
  98     bh->idle = 0;
  99     /* stop the currently executing CPU to execute the BH ASAP */
 100     qemu_notify_event();
 101 }
 102
 103 void qemu_bh_cancel(QEMUBH *bh)
 104 {
 105     bh->scheduled = 0;
 106 }
 107
 108 void qemu_bh_delete(QEMUBH *bh)
 109 {
 110     bh->scheduled = 0;
 111     bh->deleted = 1;
 112 }
 113
 114 void qemu_bh_update_timeout(int *timeout)
 115 {
 116     QEMUBH *bh;
 117
 118     for (bh = first_bh; bh; bh = bh->next) {
 119         if (!bh->deleted && bh->scheduled) {
 120             if (bh->idle) {
 121                 /* idle bottom halves will be polled at least
 122                  * every 10ms */
 123                 *timeout = MIN(10, *timeout);
 124             } else {
 125                 /* non-idle bottom halves will be executed
 126                  * immediately */
 127                 *timeout = 0;
 128                 break;
 129             }
 130         }
 131     }
 132 }
 133