Annotation of qemu/qemu-timer.c, revision 1.1.1.3

1.1       root        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 "sysemu.h"
                     26: #include "net.h"
                     27: #include "monitor.h"
                     28: #include "console.h"
                     29: 
                     30: #include "hw/hw.h"
                     31: 
                     32: #include <unistd.h>
                     33: #include <fcntl.h>
                     34: #include <time.h>
                     35: #include <errno.h>
                     36: #include <sys/time.h>
                     37: #include <signal.h>
                     38: #ifdef __FreeBSD__
                     39: #include <sys/param.h>
                     40: #endif
                     41: 
                     42: #ifdef _WIN32
                     43: #include <windows.h>
                     44: #include <mmsystem.h>
                     45: #endif
                     46: 
                     47: #include "qemu-timer.h"
                     48: 
                     49: /* Conversion factor from emulated instructions to virtual clock ticks.  */
                     50: int icount_time_shift;
                     51: /* Arbitrarily pick 1MIPS as the minimum allowable speed.  */
                     52: #define MAX_ICOUNT_SHIFT 10
                     53: /* Compensate for varying guest execution speed.  */
                     54: int64_t qemu_icount_bias;
                     55: static QEMUTimer *icount_rt_timer;
                     56: static QEMUTimer *icount_vm_timer;
                     57: 
                     58: /***********************************************************/
                     59: /* guest cycle counter */
                     60: 
                     61: typedef struct TimersState {
                     62:     int64_t cpu_ticks_prev;
                     63:     int64_t cpu_ticks_offset;
                     64:     int64_t cpu_clock_offset;
                     65:     int32_t cpu_ticks_enabled;
                     66:     int64_t dummy;
                     67: } TimersState;
                     68: 
                     69: TimersState timers_state;
                     70: 
                     71: /* return the host CPU cycle counter and handle stop/restart */
                     72: int64_t cpu_get_ticks(void)
                     73: {
                     74:     if (use_icount) {
                     75:         return cpu_get_icount();
                     76:     }
                     77:     if (!timers_state.cpu_ticks_enabled) {
                     78:         return timers_state.cpu_ticks_offset;
                     79:     } else {
                     80:         int64_t ticks;
                     81:         ticks = cpu_get_real_ticks();
                     82:         if (timers_state.cpu_ticks_prev > ticks) {
                     83:             /* Note: non increasing ticks may happen if the host uses
                     84:                software suspend */
                     85:             timers_state.cpu_ticks_offset += timers_state.cpu_ticks_prev - ticks;
                     86:         }
                     87:         timers_state.cpu_ticks_prev = ticks;
                     88:         return ticks + timers_state.cpu_ticks_offset;
                     89:     }
                     90: }
                     91: 
                     92: /* return the host CPU monotonic timer and handle stop/restart */
                     93: static int64_t cpu_get_clock(void)
                     94: {
                     95:     int64_t ti;
                     96:     if (!timers_state.cpu_ticks_enabled) {
                     97:         return timers_state.cpu_clock_offset;
                     98:     } else {
                     99:         ti = get_clock();
                    100:         return ti + timers_state.cpu_clock_offset;
                    101:     }
                    102: }
                    103: 
1.1.1.3 ! root      104: #ifndef CONFIG_IOTHREAD
1.1       root      105: static int64_t qemu_icount_delta(void)
                    106: {
                    107:     if (!use_icount) {
                    108:         return 5000 * (int64_t) 1000000;
                    109:     } else if (use_icount == 1) {
                    110:         /* When not using an adaptive execution frequency
                    111:            we tend to get badly out of sync with real time,
                    112:            so just delay for a reasonable amount of time.  */
                    113:         return 0;
                    114:     } else {
                    115:         return cpu_get_icount() - cpu_get_clock();
                    116:     }
                    117: }
1.1.1.3 ! root      118: #endif
1.1       root      119: 
                    120: /* enable cpu_get_ticks() */
                    121: void cpu_enable_ticks(void)
                    122: {
                    123:     if (!timers_state.cpu_ticks_enabled) {
                    124:         timers_state.cpu_ticks_offset -= cpu_get_real_ticks();
                    125:         timers_state.cpu_clock_offset -= get_clock();
                    126:         timers_state.cpu_ticks_enabled = 1;
                    127:     }
                    128: }
                    129: 
                    130: /* disable cpu_get_ticks() : the clock is stopped. You must not call
                    131:    cpu_get_ticks() after that.  */
                    132: void cpu_disable_ticks(void)
                    133: {
                    134:     if (timers_state.cpu_ticks_enabled) {
                    135:         timers_state.cpu_ticks_offset = cpu_get_ticks();
                    136:         timers_state.cpu_clock_offset = cpu_get_clock();
                    137:         timers_state.cpu_ticks_enabled = 0;
                    138:     }
                    139: }
                    140: 
                    141: /***********************************************************/
                    142: /* timers */
                    143: 
                    144: #define QEMU_CLOCK_REALTIME 0
                    145: #define QEMU_CLOCK_VIRTUAL  1
                    146: #define QEMU_CLOCK_HOST     2
                    147: 
                    148: struct QEMUClock {
                    149:     int type;
                    150:     int enabled;
1.1.1.3 ! root      151: 
        !           152:     QEMUTimer *warp_timer;
        !           153: 
        !           154:     NotifierList reset_notifiers;
        !           155:     int64_t last;
1.1       root      156: };
                    157: 
                    158: struct QEMUTimer {
                    159:     QEMUClock *clock;
1.1.1.3 ! root      160:     int64_t expire_time;       /* in nanoseconds */
        !           161:     int scale;
1.1       root      162:     QEMUTimerCB *cb;
                    163:     void *opaque;
                    164:     struct QEMUTimer *next;
                    165: };
                    166: 
                    167: struct qemu_alarm_timer {
                    168:     char const *name;
                    169:     int (*start)(struct qemu_alarm_timer *t);
                    170:     void (*stop)(struct qemu_alarm_timer *t);
                    171:     void (*rearm)(struct qemu_alarm_timer *t);
1.1.1.3 ! root      172: #if defined(__linux__)
        !           173:     int fd;
        !           174:     timer_t timer;
        !           175: #elif defined(_WIN32)
        !           176:     HANDLE timer;
        !           177: #endif
1.1       root      178:     char expired;
                    179:     char pending;
                    180: };
                    181: 
                    182: static struct qemu_alarm_timer *alarm_timer;
                    183: 
1.1.1.3 ! root      184: static bool qemu_timer_expired_ns(QEMUTimer *timer_head, int64_t current_time)
        !           185: {
        !           186:     return timer_head && (timer_head->expire_time <= current_time);
        !           187: }
        !           188: 
1.1       root      189: int qemu_alarm_pending(void)
                    190: {
                    191:     return alarm_timer->pending;
                    192: }
                    193: 
                    194: static inline int alarm_has_dynticks(struct qemu_alarm_timer *t)
                    195: {
                    196:     return !!t->rearm;
                    197: }
                    198: 
                    199: static void qemu_rearm_alarm_timer(struct qemu_alarm_timer *t)
                    200: {
                    201:     if (!alarm_has_dynticks(t))
                    202:         return;
                    203: 
                    204:     t->rearm(t);
                    205: }
                    206: 
1.1.1.2   root      207: /* TODO: MIN_TIMER_REARM_NS should be optimized */
                    208: #define MIN_TIMER_REARM_NS 250000
1.1       root      209: 
                    210: #ifdef _WIN32
                    211: 
1.1.1.3 ! root      212: static int mm_start_timer(struct qemu_alarm_timer *t);
        !           213: static void mm_stop_timer(struct qemu_alarm_timer *t);
        !           214: static void mm_rearm_timer(struct qemu_alarm_timer *t);
1.1       root      215: 
                    216: static int win32_start_timer(struct qemu_alarm_timer *t);
                    217: static void win32_stop_timer(struct qemu_alarm_timer *t);
                    218: static void win32_rearm_timer(struct qemu_alarm_timer *t);
                    219: 
                    220: #else
                    221: 
                    222: static int unix_start_timer(struct qemu_alarm_timer *t);
                    223: static void unix_stop_timer(struct qemu_alarm_timer *t);
1.1.1.3 ! root      224: static void unix_rearm_timer(struct qemu_alarm_timer *t);
1.1       root      225: 
                    226: #ifdef __linux__
                    227: 
                    228: static int dynticks_start_timer(struct qemu_alarm_timer *t);
                    229: static void dynticks_stop_timer(struct qemu_alarm_timer *t);
                    230: static void dynticks_rearm_timer(struct qemu_alarm_timer *t);
                    231: 
                    232: #endif /* __linux__ */
                    233: 
                    234: #endif /* _WIN32 */
                    235: 
                    236: /* Correlation between real and virtual time is always going to be
                    237:    fairly approximate, so ignore small variation.
                    238:    When the guest is idle real and virtual time will be aligned in
                    239:    the IO wait loop.  */
                    240: #define ICOUNT_WOBBLE (get_ticks_per_sec() / 10)
                    241: 
                    242: static void icount_adjust(void)
                    243: {
                    244:     int64_t cur_time;
                    245:     int64_t cur_icount;
                    246:     int64_t delta;
                    247:     static int64_t last_delta;
                    248:     /* If the VM is not running, then do nothing.  */
                    249:     if (!vm_running)
                    250:         return;
                    251: 
                    252:     cur_time = cpu_get_clock();
1.1.1.3 ! root      253:     cur_icount = qemu_get_clock_ns(vm_clock);
1.1       root      254:     delta = cur_icount - cur_time;
                    255:     /* FIXME: This is a very crude algorithm, somewhat prone to oscillation.  */
                    256:     if (delta > 0
                    257:         && last_delta + ICOUNT_WOBBLE < delta * 2
                    258:         && icount_time_shift > 0) {
                    259:         /* The guest is getting too far ahead.  Slow time down.  */
                    260:         icount_time_shift--;
                    261:     }
                    262:     if (delta < 0
                    263:         && last_delta - ICOUNT_WOBBLE > delta * 2
                    264:         && icount_time_shift < MAX_ICOUNT_SHIFT) {
                    265:         /* The guest is getting too far behind.  Speed time up.  */
                    266:         icount_time_shift++;
                    267:     }
                    268:     last_delta = delta;
                    269:     qemu_icount_bias = cur_icount - (qemu_icount << icount_time_shift);
                    270: }
                    271: 
                    272: static void icount_adjust_rt(void * opaque)
                    273: {
                    274:     qemu_mod_timer(icount_rt_timer,
1.1.1.3 ! root      275:                    qemu_get_clock_ms(rt_clock) + 1000);
1.1       root      276:     icount_adjust();
                    277: }
                    278: 
                    279: static void icount_adjust_vm(void * opaque)
                    280: {
                    281:     qemu_mod_timer(icount_vm_timer,
1.1.1.3 ! root      282:                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
1.1       root      283:     icount_adjust();
                    284: }
                    285: 
                    286: int64_t qemu_icount_round(int64_t count)
                    287: {
                    288:     return (count + (1 << icount_time_shift) - 1) >> icount_time_shift;
                    289: }
                    290: 
                    291: static struct qemu_alarm_timer alarm_timers[] = {
                    292: #ifndef _WIN32
                    293: #ifdef __linux__
                    294:     {"dynticks", dynticks_start_timer,
1.1.1.3 ! root      295:      dynticks_stop_timer, dynticks_rearm_timer},
1.1       root      296: #endif
1.1.1.3 ! root      297:     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
1.1       root      298: #else
1.1.1.3 ! root      299:     {"mmtimer", mm_start_timer, mm_stop_timer, NULL},
        !           300:     {"mmtimer2", mm_start_timer, mm_stop_timer, mm_rearm_timer},
        !           301:     {"dynticks", win32_start_timer, win32_stop_timer, win32_rearm_timer},
        !           302:     {"win32", win32_start_timer, win32_stop_timer, NULL},
1.1       root      303: #endif
                    304:     {NULL, }
                    305: };
                    306: 
                    307: static void show_available_alarms(void)
                    308: {
                    309:     int i;
                    310: 
                    311:     printf("Available alarm timers, in order of precedence:\n");
                    312:     for (i = 0; alarm_timers[i].name; i++)
                    313:         printf("%s\n", alarm_timers[i].name);
                    314: }
                    315: 
                    316: void configure_alarms(char const *opt)
                    317: {
                    318:     int i;
                    319:     int cur = 0;
                    320:     int count = ARRAY_SIZE(alarm_timers) - 1;
                    321:     char *arg;
                    322:     char *name;
                    323:     struct qemu_alarm_timer tmp;
                    324: 
                    325:     if (!strcmp(opt, "?")) {
                    326:         show_available_alarms();
                    327:         exit(0);
                    328:     }
                    329: 
                    330:     arg = qemu_strdup(opt);
                    331: 
                    332:     /* Reorder the array */
                    333:     name = strtok(arg, ",");
                    334:     while (name) {
                    335:         for (i = 0; i < count && alarm_timers[i].name; i++) {
                    336:             if (!strcmp(alarm_timers[i].name, name))
                    337:                 break;
                    338:         }
                    339: 
                    340:         if (i == count) {
                    341:             fprintf(stderr, "Unknown clock %s\n", name);
                    342:             goto next;
                    343:         }
                    344: 
                    345:         if (i < cur)
                    346:             /* Ignore */
                    347:             goto next;
                    348: 
                    349:        /* Swap */
                    350:         tmp = alarm_timers[i];
                    351:         alarm_timers[i] = alarm_timers[cur];
                    352:         alarm_timers[cur] = tmp;
                    353: 
                    354:         cur++;
                    355: next:
                    356:         name = strtok(NULL, ",");
                    357:     }
                    358: 
                    359:     qemu_free(arg);
                    360: 
                    361:     if (cur) {
                    362:         /* Disable remaining timers */
                    363:         for (i = cur; i < count; i++)
                    364:             alarm_timers[i].name = NULL;
                    365:     } else {
                    366:         show_available_alarms();
                    367:         exit(1);
                    368:     }
                    369: }
                    370: 
                    371: #define QEMU_NUM_CLOCKS 3
                    372: 
                    373: QEMUClock *rt_clock;
                    374: QEMUClock *vm_clock;
                    375: QEMUClock *host_clock;
                    376: 
                    377: static QEMUTimer *active_timers[QEMU_NUM_CLOCKS];
                    378: 
                    379: static QEMUClock *qemu_new_clock(int type)
                    380: {
                    381:     QEMUClock *clock;
1.1.1.3 ! root      382: 
1.1       root      383:     clock = qemu_mallocz(sizeof(QEMUClock));
                    384:     clock->type = type;
                    385:     clock->enabled = 1;
1.1.1.3 ! root      386:     notifier_list_init(&clock->reset_notifiers);
        !           387:     /* required to detect & report backward jumps */
        !           388:     if (type == QEMU_CLOCK_HOST) {
        !           389:         clock->last = get_clock_realtime();
        !           390:     }
1.1       root      391:     return clock;
                    392: }
                    393: 
                    394: void qemu_clock_enable(QEMUClock *clock, int enabled)
                    395: {
                    396:     clock->enabled = enabled;
                    397: }
                    398: 
1.1.1.3 ! root      399: static int64_t vm_clock_warp_start;
        !           400: 
        !           401: static void icount_warp_rt(void *opaque)
        !           402: {
        !           403:     if (vm_clock_warp_start == -1) {
        !           404:         return;
        !           405:     }
        !           406: 
        !           407:     if (vm_running) {
        !           408:         int64_t clock = qemu_get_clock_ns(rt_clock);
        !           409:         int64_t warp_delta = clock - vm_clock_warp_start;
        !           410:         if (use_icount == 1) {
        !           411:             qemu_icount_bias += warp_delta;
        !           412:         } else {
        !           413:             /*
        !           414:              * In adaptive mode, do not let the vm_clock run too
        !           415:              * far ahead of real time.
        !           416:              */
        !           417:             int64_t cur_time = cpu_get_clock();
        !           418:             int64_t cur_icount = qemu_get_clock_ns(vm_clock);
        !           419:             int64_t delta = cur_time - cur_icount;
        !           420:             qemu_icount_bias += MIN(warp_delta, delta);
        !           421:         }
        !           422:         if (qemu_timer_expired(active_timers[QEMU_CLOCK_VIRTUAL],
        !           423:                                qemu_get_clock_ns(vm_clock))) {
        !           424:             qemu_notify_event();
        !           425:         }
        !           426:     }
        !           427:     vm_clock_warp_start = -1;
        !           428: }
        !           429: 
        !           430: void qemu_clock_warp(QEMUClock *clock)
        !           431: {
        !           432:     int64_t deadline;
        !           433: 
        !           434:     if (!clock->warp_timer) {
        !           435:         return;
        !           436:     }
        !           437: 
        !           438:     /*
        !           439:      * There are too many global variables to make the "warp" behavior
        !           440:      * applicable to other clocks.  But a clock argument removes the
        !           441:      * need for if statements all over the place.
        !           442:      */
        !           443:     assert(clock == vm_clock);
        !           444: 
        !           445:     /*
        !           446:      * If the CPUs have been sleeping, advance the vm_clock timer now.  This
        !           447:      * ensures that the deadline for the timer is computed correctly below.
        !           448:      * This also makes sure that the insn counter is synchronized before the
        !           449:      * CPU starts running, in case the CPU is woken by an event other than
        !           450:      * the earliest vm_clock timer.
        !           451:      */
        !           452:     icount_warp_rt(NULL);
        !           453:     if (!all_cpu_threads_idle() || !active_timers[clock->type]) {
        !           454:         qemu_del_timer(clock->warp_timer);
        !           455:         return;
        !           456:     }
        !           457: 
        !           458:     vm_clock_warp_start = qemu_get_clock_ns(rt_clock);
        !           459:     deadline = qemu_next_icount_deadline();
        !           460:     if (deadline > 0) {
        !           461:         /*
        !           462:          * Ensure the vm_clock proceeds even when the virtual CPU goes to
        !           463:          * sleep.  Otherwise, the CPU might be waiting for a future timer
        !           464:          * interrupt to wake it up, but the interrupt never comes because
        !           465:          * the vCPU isn't running any insns and thus doesn't advance the
        !           466:          * vm_clock.
        !           467:          *
        !           468:          * An extreme solution for this problem would be to never let VCPUs
        !           469:          * sleep in icount mode if there is a pending vm_clock timer; rather
        !           470:          * time could just advance to the next vm_clock event.  Instead, we
        !           471:          * do stop VCPUs and only advance vm_clock after some "real" time,
        !           472:          * (related to the time left until the next event) has passed.  This
        !           473:          * rt_clock timer will do this.  This avoids that the warps are too
        !           474:          * visible externally---for example, you will not be sending network
        !           475:          * packets continously instead of every 100ms.
        !           476:          */
        !           477:         qemu_mod_timer(clock->warp_timer, vm_clock_warp_start + deadline);
        !           478:     } else {
        !           479:         qemu_notify_event();
        !           480:     }
        !           481: }
        !           482: 
        !           483: QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
        !           484:                           QEMUTimerCB *cb, void *opaque)
1.1       root      485: {
                    486:     QEMUTimer *ts;
                    487: 
                    488:     ts = qemu_mallocz(sizeof(QEMUTimer));
                    489:     ts->clock = clock;
                    490:     ts->cb = cb;
                    491:     ts->opaque = opaque;
1.1.1.3 ! root      492:     ts->scale = scale;
1.1       root      493:     return ts;
                    494: }
                    495: 
                    496: void qemu_free_timer(QEMUTimer *ts)
                    497: {
                    498:     qemu_free(ts);
                    499: }
                    500: 
                    501: /* stop a timer, but do not dealloc it */
                    502: void qemu_del_timer(QEMUTimer *ts)
                    503: {
                    504:     QEMUTimer **pt, *t;
                    505: 
                    506:     /* NOTE: this code must be signal safe because
                    507:        qemu_timer_expired() can be called from a signal. */
                    508:     pt = &active_timers[ts->clock->type];
                    509:     for(;;) {
                    510:         t = *pt;
                    511:         if (!t)
                    512:             break;
                    513:         if (t == ts) {
                    514:             *pt = t->next;
                    515:             break;
                    516:         }
                    517:         pt = &t->next;
                    518:     }
                    519: }
                    520: 
                    521: /* modify the current timer so that it will be fired when current_time
                    522:    >= expire_time. The corresponding callback will be called. */
1.1.1.3 ! root      523: static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
1.1       root      524: {
                    525:     QEMUTimer **pt, *t;
                    526: 
                    527:     qemu_del_timer(ts);
                    528: 
                    529:     /* add the timer in the sorted list */
                    530:     /* NOTE: this code must be signal safe because
                    531:        qemu_timer_expired() can be called from a signal. */
                    532:     pt = &active_timers[ts->clock->type];
                    533:     for(;;) {
                    534:         t = *pt;
1.1.1.3 ! root      535:         if (!qemu_timer_expired_ns(t, expire_time)) {
1.1       root      536:             break;
1.1.1.3 ! root      537:         }
1.1       root      538:         pt = &t->next;
                    539:     }
                    540:     ts->expire_time = expire_time;
                    541:     ts->next = *pt;
                    542:     *pt = ts;
                    543: 
                    544:     /* Rearm if necessary  */
                    545:     if (pt == &active_timers[ts->clock->type]) {
                    546:         if (!alarm_timer->pending) {
                    547:             qemu_rearm_alarm_timer(alarm_timer);
                    548:         }
                    549:         /* Interrupt execution to force deadline recalculation.  */
1.1.1.3 ! root      550:         qemu_clock_warp(ts->clock);
        !           551:         if (use_icount) {
1.1       root      552:             qemu_notify_event();
1.1.1.3 ! root      553:         }
1.1       root      554:     }
                    555: }
                    556: 
1.1.1.3 ! root      557: /* modify the current timer so that it will be fired when current_time
        !           558:    >= expire_time. The corresponding callback will be called. */
        !           559: void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time)
        !           560: {
        !           561:     qemu_mod_timer_ns(ts, expire_time * ts->scale);
        !           562: }
        !           563: 
1.1       root      564: int qemu_timer_pending(QEMUTimer *ts)
                    565: {
                    566:     QEMUTimer *t;
                    567:     for(t = active_timers[ts->clock->type]; t != NULL; t = t->next) {
                    568:         if (t == ts)
                    569:             return 1;
                    570:     }
                    571:     return 0;
                    572: }
                    573: 
                    574: int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time)
                    575: {
1.1.1.3 ! root      576:     return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
1.1       root      577: }
                    578: 
                    579: static void qemu_run_timers(QEMUClock *clock)
                    580: {
                    581:     QEMUTimer **ptimer_head, *ts;
                    582:     int64_t current_time;
                    583:    
                    584:     if (!clock->enabled)
                    585:         return;
                    586: 
1.1.1.3 ! root      587:     current_time = qemu_get_clock_ns(clock);
1.1       root      588:     ptimer_head = &active_timers[clock->type];
                    589:     for(;;) {
                    590:         ts = *ptimer_head;
1.1.1.3 ! root      591:         if (!qemu_timer_expired_ns(ts, current_time)) {
1.1       root      592:             break;
1.1.1.3 ! root      593:         }
1.1       root      594:         /* remove timer from the list before calling the callback */
                    595:         *ptimer_head = ts->next;
                    596:         ts->next = NULL;
                    597: 
                    598:         /* run the callback (the timer list can be modified) */
                    599:         ts->cb(ts->opaque);
                    600:     }
                    601: }
                    602: 
1.1.1.3 ! root      603: int64_t qemu_get_clock_ns(QEMUClock *clock)
1.1       root      604: {
1.1.1.3 ! root      605:     int64_t now, last;
        !           606: 
1.1       root      607:     switch(clock->type) {
                    608:     case QEMU_CLOCK_REALTIME:
1.1.1.3 ! root      609:         return get_clock();
1.1       root      610:     default:
                    611:     case QEMU_CLOCK_VIRTUAL:
                    612:         if (use_icount) {
                    613:             return cpu_get_icount();
                    614:         } else {
                    615:             return cpu_get_clock();
                    616:         }
                    617:     case QEMU_CLOCK_HOST:
1.1.1.3 ! root      618:         now = get_clock_realtime();
        !           619:         last = clock->last;
        !           620:         clock->last = now;
        !           621:         if (now < last) {
        !           622:             notifier_list_notify(&clock->reset_notifiers, &now);
        !           623:         }
        !           624:         return now;
1.1       root      625:     }
                    626: }
                    627: 
1.1.1.3 ! root      628: void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
1.1       root      629: {
1.1.1.3 ! root      630:     notifier_list_add(&clock->reset_notifiers, notifier);
        !           631: }
        !           632: 
        !           633: void qemu_unregister_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
        !           634: {
        !           635:     notifier_list_remove(&clock->reset_notifiers, notifier);
1.1       root      636: }
                    637: 
                    638: void init_clocks(void)
                    639: {
                    640:     rt_clock = qemu_new_clock(QEMU_CLOCK_REALTIME);
                    641:     vm_clock = qemu_new_clock(QEMU_CLOCK_VIRTUAL);
                    642:     host_clock = qemu_new_clock(QEMU_CLOCK_HOST);
                    643: 
                    644:     rtc_clock = host_clock;
                    645: }
                    646: 
                    647: /* save a timer */
                    648: void qemu_put_timer(QEMUFile *f, QEMUTimer *ts)
                    649: {
                    650:     uint64_t expire_time;
                    651: 
                    652:     if (qemu_timer_pending(ts)) {
                    653:         expire_time = ts->expire_time;
                    654:     } else {
                    655:         expire_time = -1;
                    656:     }
                    657:     qemu_put_be64(f, expire_time);
                    658: }
                    659: 
                    660: void qemu_get_timer(QEMUFile *f, QEMUTimer *ts)
                    661: {
                    662:     uint64_t expire_time;
                    663: 
                    664:     expire_time = qemu_get_be64(f);
                    665:     if (expire_time != -1) {
1.1.1.3 ! root      666:         qemu_mod_timer_ns(ts, expire_time);
1.1       root      667:     } else {
                    668:         qemu_del_timer(ts);
                    669:     }
                    670: }
                    671: 
                    672: static const VMStateDescription vmstate_timers = {
                    673:     .name = "timer",
                    674:     .version_id = 2,
                    675:     .minimum_version_id = 1,
                    676:     .minimum_version_id_old = 1,
                    677:     .fields      = (VMStateField []) {
                    678:         VMSTATE_INT64(cpu_ticks_offset, TimersState),
                    679:         VMSTATE_INT64(dummy, TimersState),
                    680:         VMSTATE_INT64_V(cpu_clock_offset, TimersState, 2),
                    681:         VMSTATE_END_OF_LIST()
                    682:     }
                    683: };
                    684: 
                    685: void configure_icount(const char *option)
                    686: {
                    687:     vmstate_register(NULL, 0, &vmstate_timers, &timers_state);
                    688:     if (!option)
                    689:         return;
                    690: 
1.1.1.3 ! root      691: #ifdef CONFIG_IOTHREAD
        !           692:     vm_clock->warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
        !           693: #endif
        !           694: 
1.1       root      695:     if (strcmp(option, "auto") != 0) {
                    696:         icount_time_shift = strtol(option, NULL, 0);
                    697:         use_icount = 1;
                    698:         return;
                    699:     }
                    700: 
                    701:     use_icount = 2;
                    702: 
                    703:     /* 125MIPS seems a reasonable initial guess at the guest speed.
                    704:        It will be corrected fairly quickly anyway.  */
                    705:     icount_time_shift = 3;
                    706: 
                    707:     /* Have both realtime and virtual time triggers for speed adjustment.
                    708:        The realtime trigger catches emulated time passing too slowly,
                    709:        the virtual time trigger catches emulated time passing too fast.
                    710:        Realtime triggers occur even when idle, so use them less frequently
                    711:        than VM triggers.  */
1.1.1.3 ! root      712:     icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
1.1       root      713:     qemu_mod_timer(icount_rt_timer,
1.1.1.3 ! root      714:                    qemu_get_clock_ms(rt_clock) + 1000);
        !           715:     icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
1.1       root      716:     qemu_mod_timer(icount_vm_timer,
1.1.1.3 ! root      717:                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
1.1       root      718: }
                    719: 
                    720: void qemu_run_all_timers(void)
                    721: {
                    722:     alarm_timer->pending = 0;
                    723: 
                    724:     /* rearm timer, if not periodic */
                    725:     if (alarm_timer->expired) {
                    726:         alarm_timer->expired = 0;
                    727:         qemu_rearm_alarm_timer(alarm_timer);
                    728:     }
                    729: 
                    730:     /* vm time timers */
                    731:     if (vm_running) {
                    732:         qemu_run_timers(vm_clock);
                    733:     }
                    734: 
                    735:     qemu_run_timers(rt_clock);
                    736:     qemu_run_timers(host_clock);
                    737: }
                    738: 
1.1.1.2   root      739: static int64_t qemu_next_alarm_deadline(void);
                    740: 
1.1       root      741: #ifdef _WIN32
1.1.1.3 ! root      742: static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
1.1       root      743: #else
                    744: static void host_alarm_handler(int host_signum)
                    745: #endif
                    746: {
                    747:     struct qemu_alarm_timer *t = alarm_timer;
                    748:     if (!t)
                    749:        return;
                    750: 
                    751: #if 0
                    752: #define DISP_FREQ 1000
                    753:     {
                    754:         static int64_t delta_min = INT64_MAX;
                    755:         static int64_t delta_max, delta_cum, last_clock, delta, ti;
                    756:         static int count;
1.1.1.3 ! root      757:         ti = qemu_get_clock_ns(vm_clock);
1.1       root      758:         if (last_clock != 0) {
                    759:             delta = ti - last_clock;
                    760:             if (delta < delta_min)
                    761:                 delta_min = delta;
                    762:             if (delta > delta_max)
                    763:                 delta_max = delta;
                    764:             delta_cum += delta;
                    765:             if (++count == DISP_FREQ) {
                    766:                 printf("timer: min=%" PRId64 " us max=%" PRId64 " us avg=%" PRId64 " us avg_freq=%0.3f Hz\n",
                    767:                        muldiv64(delta_min, 1000000, get_ticks_per_sec()),
                    768:                        muldiv64(delta_max, 1000000, get_ticks_per_sec()),
                    769:                        muldiv64(delta_cum, 1000000 / DISP_FREQ, get_ticks_per_sec()),
                    770:                        (double)get_ticks_per_sec() / ((double)delta_cum / DISP_FREQ));
                    771:                 count = 0;
                    772:                 delta_min = INT64_MAX;
                    773:                 delta_max = 0;
                    774:                 delta_cum = 0;
                    775:             }
                    776:         }
                    777:         last_clock = ti;
                    778:     }
                    779: #endif
                    780:     if (alarm_has_dynticks(t) ||
1.1.1.2   root      781:         qemu_next_alarm_deadline () <= 0) {
1.1       root      782:         t->expired = alarm_has_dynticks(t);
                    783:         t->pending = 1;
                    784:         qemu_notify_event();
                    785:     }
                    786: }
                    787: 
1.1.1.3 ! root      788: int64_t qemu_next_icount_deadline(void)
1.1       root      789: {
                    790:     /* To avoid problems with overflow limit this to 2^32.  */
                    791:     int64_t delta = INT32_MAX;
                    792: 
1.1.1.3 ! root      793:     assert(use_icount);
1.1       root      794:     if (active_timers[QEMU_CLOCK_VIRTUAL]) {
                    795:         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
1.1.1.2   root      796:                      qemu_get_clock_ns(vm_clock);
1.1       root      797:     }
                    798: 
                    799:     if (delta < 0)
                    800:         delta = 0;
                    801: 
                    802:     return delta;
                    803: }
                    804: 
1.1.1.2   root      805: static int64_t qemu_next_alarm_deadline(void)
1.1       root      806: {
                    807:     int64_t delta;
                    808:     int64_t rtdelta;
                    809: 
1.1.1.2   root      810:     if (!use_icount && active_timers[QEMU_CLOCK_VIRTUAL]) {
                    811:         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
1.1.1.3 ! root      812:                      qemu_get_clock_ns(vm_clock);
1.1.1.2   root      813:     } else {
1.1       root      814:         delta = INT32_MAX;
1.1.1.2   root      815:     }
                    816:     if (active_timers[QEMU_CLOCK_HOST]) {
                    817:         int64_t hdelta = active_timers[QEMU_CLOCK_HOST]->expire_time -
                    818:                  qemu_get_clock_ns(host_clock);
                    819:         if (hdelta < delta)
                    820:             delta = hdelta;
                    821:     }
1.1       root      822:     if (active_timers[QEMU_CLOCK_REALTIME]) {
1.1.1.3 ! root      823:         rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
1.1.1.2   root      824:                  qemu_get_clock_ns(rt_clock));
1.1       root      825:         if (rtdelta < delta)
                    826:             delta = rtdelta;
                    827:     }
                    828: 
                    829:     return delta;
                    830: }
                    831: 
1.1.1.2   root      832: #if defined(__linux__)
                    833: 
1.1.1.3 ! root      834: #include "compatfd.h"
1.1       root      835: 
                    836: static int dynticks_start_timer(struct qemu_alarm_timer *t)
                    837: {
                    838:     struct sigevent ev;
                    839:     timer_t host_timer;
                    840:     struct sigaction act;
                    841: 
                    842:     sigfillset(&act.sa_mask);
                    843:     act.sa_flags = 0;
                    844:     act.sa_handler = host_alarm_handler;
                    845: 
                    846:     sigaction(SIGALRM, &act, NULL);
                    847: 
                    848:     /* 
                    849:      * Initialize ev struct to 0 to avoid valgrind complaining
                    850:      * about uninitialized data in timer_create call
                    851:      */
                    852:     memset(&ev, 0, sizeof(ev));
                    853:     ev.sigev_value.sival_int = 0;
                    854:     ev.sigev_notify = SIGEV_SIGNAL;
1.1.1.3 ! root      855: #ifdef SIGEV_THREAD_ID
        !           856:     if (qemu_signalfd_available()) {
        !           857:         ev.sigev_notify = SIGEV_THREAD_ID;
        !           858:         ev._sigev_un._tid = qemu_get_thread_id();
        !           859:     }
        !           860: #endif /* SIGEV_THREAD_ID */
1.1       root      861:     ev.sigev_signo = SIGALRM;
                    862: 
                    863:     if (timer_create(CLOCK_REALTIME, &ev, &host_timer)) {
                    864:         perror("timer_create");
                    865: 
                    866:         /* disable dynticks */
                    867:         fprintf(stderr, "Dynamic Ticks disabled\n");
                    868: 
                    869:         return -1;
                    870:     }
                    871: 
1.1.1.3 ! root      872:     t->timer = host_timer;
1.1       root      873: 
                    874:     return 0;
                    875: }
                    876: 
                    877: static void dynticks_stop_timer(struct qemu_alarm_timer *t)
                    878: {
1.1.1.3 ! root      879:     timer_t host_timer = t->timer;
1.1       root      880: 
                    881:     timer_delete(host_timer);
                    882: }
                    883: 
                    884: static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
                    885: {
1.1.1.3 ! root      886:     timer_t host_timer = t->timer;
1.1       root      887:     struct itimerspec timeout;
1.1.1.2   root      888:     int64_t nearest_delta_ns = INT64_MAX;
                    889:     int64_t current_ns;
1.1       root      890: 
                    891:     assert(alarm_has_dynticks(t));
                    892:     if (!active_timers[QEMU_CLOCK_REALTIME] &&
                    893:         !active_timers[QEMU_CLOCK_VIRTUAL] &&
                    894:         !active_timers[QEMU_CLOCK_HOST])
                    895:         return;
                    896: 
1.1.1.2   root      897:     nearest_delta_ns = qemu_next_alarm_deadline();
                    898:     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
                    899:         nearest_delta_ns = MIN_TIMER_REARM_NS;
1.1       root      900: 
                    901:     /* check whether a timer is already running */
                    902:     if (timer_gettime(host_timer, &timeout)) {
                    903:         perror("gettime");
                    904:         fprintf(stderr, "Internal timer error: aborting\n");
                    905:         exit(1);
                    906:     }
1.1.1.2   root      907:     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
                    908:     if (current_ns && current_ns <= nearest_delta_ns)
1.1       root      909:         return;
                    910: 
                    911:     timeout.it_interval.tv_sec = 0;
                    912:     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
1.1.1.2   root      913:     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
                    914:     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
1.1       root      915:     if (timer_settime(host_timer, 0 /* RELATIVE */, &timeout, NULL)) {
                    916:         perror("settime");
                    917:         fprintf(stderr, "Internal timer error: aborting\n");
                    918:         exit(1);
                    919:     }
                    920: }
                    921: 
                    922: #endif /* defined(__linux__) */
                    923: 
1.1.1.2   root      924: #if !defined(_WIN32)
                    925: 
1.1       root      926: static int unix_start_timer(struct qemu_alarm_timer *t)
                    927: {
                    928:     struct sigaction act;
                    929: 
                    930:     /* timer signal */
                    931:     sigfillset(&act.sa_mask);
                    932:     act.sa_flags = 0;
                    933:     act.sa_handler = host_alarm_handler;
                    934: 
                    935:     sigaction(SIGALRM, &act, NULL);
1.1.1.3 ! root      936:     return 0;
        !           937: }
1.1       root      938: 
1.1.1.3 ! root      939: static void unix_rearm_timer(struct qemu_alarm_timer *t)
        !           940: {
        !           941:     struct itimerval itv;
        !           942:     int64_t nearest_delta_ns = INT64_MAX;
        !           943:     int err;
1.1       root      944: 
1.1.1.3 ! root      945:     assert(alarm_has_dynticks(t));
        !           946:     if (!active_timers[QEMU_CLOCK_REALTIME] &&
        !           947:         !active_timers[QEMU_CLOCK_VIRTUAL] &&
        !           948:         !active_timers[QEMU_CLOCK_HOST])
        !           949:         return;
1.1       root      950: 
1.1.1.3 ! root      951:     nearest_delta_ns = qemu_next_alarm_deadline();
        !           952:     if (nearest_delta_ns < MIN_TIMER_REARM_NS)
        !           953:         nearest_delta_ns = MIN_TIMER_REARM_NS;
        !           954: 
        !           955:     itv.it_interval.tv_sec = 0;
        !           956:     itv.it_interval.tv_usec = 0; /* 0 for one-shot timer */
        !           957:     itv.it_value.tv_sec =  nearest_delta_ns / 1000000000;
        !           958:     itv.it_value.tv_usec = (nearest_delta_ns % 1000000000) / 1000;
        !           959:     err = setitimer(ITIMER_REAL, &itv, NULL);
        !           960:     if (err) {
        !           961:         perror("setitimer");
        !           962:         fprintf(stderr, "Internal timer error: aborting\n");
        !           963:         exit(1);
        !           964:     }
1.1       root      965: }
                    966: 
                    967: static void unix_stop_timer(struct qemu_alarm_timer *t)
                    968: {
                    969:     struct itimerval itv;
                    970: 
                    971:     memset(&itv, 0, sizeof(itv));
                    972:     setitimer(ITIMER_REAL, &itv, NULL);
                    973: }
                    974: 
                    975: #endif /* !defined(_WIN32) */
                    976: 
                    977: 
                    978: #ifdef _WIN32
                    979: 
1.1.1.3 ! root      980: static MMRESULT mm_timer;
        !           981: static unsigned mm_period;
        !           982: 
        !           983: static void CALLBACK mm_alarm_handler(UINT uTimerID, UINT uMsg,
        !           984:                                       DWORD_PTR dwUser, DWORD_PTR dw1,
        !           985:                                       DWORD_PTR dw2)
        !           986: {
        !           987:     struct qemu_alarm_timer *t = alarm_timer;
        !           988:     if (!t) {
        !           989:         return;
        !           990:     }
        !           991:     if (alarm_has_dynticks(t) || qemu_next_alarm_deadline() <= 0) {
        !           992:         t->expired = alarm_has_dynticks(t);
        !           993:         t->pending = 1;
        !           994:         qemu_notify_event();
        !           995:     }
        !           996: }
        !           997: 
        !           998: static int mm_start_timer(struct qemu_alarm_timer *t)
1.1       root      999: {
                   1000:     TIMECAPS tc;
                   1001:     UINT flags;
                   1002: 
                   1003:     memset(&tc, 0, sizeof(tc));
                   1004:     timeGetDevCaps(&tc, sizeof(tc));
                   1005: 
1.1.1.3 ! root     1006:     mm_period = tc.wPeriodMin;
        !          1007:     timeBeginPeriod(mm_period);
1.1       root     1008: 
                   1009:     flags = TIME_CALLBACK_FUNCTION;
1.1.1.3 ! root     1010:     if (alarm_has_dynticks(t)) {
1.1       root     1011:         flags |= TIME_ONESHOT;
1.1.1.3 ! root     1012:     } else {
1.1       root     1013:         flags |= TIME_PERIODIC;
1.1.1.3 ! root     1014:     }
1.1       root     1015: 
1.1.1.3 ! root     1016:     mm_timer = timeSetEvent(1,                  /* interval (ms) */
        !          1017:                             mm_period,          /* resolution */
        !          1018:                             mm_alarm_handler,   /* function */
        !          1019:                             (DWORD_PTR)t,       /* parameter */
        !          1020:                             flags);
1.1       root     1021: 
1.1.1.3 ! root     1022:     if (!mm_timer) {
1.1       root     1023:         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
                   1024:                 GetLastError());
1.1.1.3 ! root     1025:         timeEndPeriod(mm_period);
1.1       root     1026:         return -1;
                   1027:     }
                   1028: 
                   1029:     return 0;
                   1030: }
                   1031: 
1.1.1.3 ! root     1032: static void mm_stop_timer(struct qemu_alarm_timer *t)
1.1       root     1033: {
1.1.1.3 ! root     1034:     timeKillEvent(mm_timer);
        !          1035:     timeEndPeriod(mm_period);
1.1       root     1036: }
                   1037: 
1.1.1.3 ! root     1038: static void mm_rearm_timer(struct qemu_alarm_timer *t)
1.1       root     1039: {
1.1.1.3 ! root     1040:     int nearest_delta_ms;
1.1       root     1041: 
                   1042:     assert(alarm_has_dynticks(t));
                   1043:     if (!active_timers[QEMU_CLOCK_REALTIME] &&
                   1044:         !active_timers[QEMU_CLOCK_VIRTUAL] &&
1.1.1.3 ! root     1045:         !active_timers[QEMU_CLOCK_HOST]) {
1.1       root     1046:         return;
1.1.1.3 ! root     1047:     }
1.1       root     1048: 
1.1.1.3 ! root     1049:     timeKillEvent(mm_timer);
1.1       root     1050: 
1.1.1.3 ! root     1051:     nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;
        !          1052:     if (nearest_delta_ms < 1) {
        !          1053:         nearest_delta_ms = 1;
        !          1054:     }
        !          1055:     mm_timer = timeSetEvent(nearest_delta_ms,
        !          1056:                             mm_period,
        !          1057:                             mm_alarm_handler,
        !          1058:                             (DWORD_PTR)t,
        !          1059:                             TIME_ONESHOT | TIME_CALLBACK_FUNCTION);
1.1       root     1060: 
1.1.1.3 ! root     1061:     if (!mm_timer) {
1.1       root     1062:         fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
                   1063:                 GetLastError());
                   1064: 
1.1.1.3 ! root     1065:         timeEndPeriod(mm_period);
1.1       root     1066:         exit(1);
                   1067:     }
                   1068: }
                   1069: 
1.1.1.3 ! root     1070: static int win32_start_timer(struct qemu_alarm_timer *t)
        !          1071: {
        !          1072:     HANDLE hTimer;
        !          1073:     BOOLEAN success;
        !          1074: 
        !          1075:     /* If you call ChangeTimerQueueTimer on a one-shot timer (its period
        !          1076:        is zero) that has already expired, the timer is not updated.  Since
        !          1077:        creating a new timer is relatively expensive, set a bogus one-hour
        !          1078:        interval in the dynticks case.  */
        !          1079:     success = CreateTimerQueueTimer(&hTimer,
        !          1080:                           NULL,
        !          1081:                           host_alarm_handler,
        !          1082:                           t,
        !          1083:                           1,
        !          1084:                           alarm_has_dynticks(t) ? 3600000 : 1,
        !          1085:                           WT_EXECUTEINTIMERTHREAD);
        !          1086: 
        !          1087:     if (!success) {
        !          1088:         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
        !          1089:                 GetLastError());
        !          1090:         return -1;
        !          1091:     }
        !          1092: 
        !          1093:     t->timer = hTimer;
        !          1094:     return 0;
        !          1095: }
        !          1096: 
        !          1097: static void win32_stop_timer(struct qemu_alarm_timer *t)
        !          1098: {
        !          1099:     HANDLE hTimer = t->timer;
        !          1100: 
        !          1101:     if (hTimer) {
        !          1102:         DeleteTimerQueueTimer(NULL, hTimer, NULL);
        !          1103:     }
        !          1104: }
        !          1105: 
        !          1106: static void win32_rearm_timer(struct qemu_alarm_timer *t)
        !          1107: {
        !          1108:     HANDLE hTimer = t->timer;
        !          1109:     int nearest_delta_ms;
        !          1110:     BOOLEAN success;
        !          1111: 
        !          1112:     assert(alarm_has_dynticks(t));
        !          1113:     if (!active_timers[QEMU_CLOCK_REALTIME] &&
        !          1114:         !active_timers[QEMU_CLOCK_VIRTUAL] &&
        !          1115:         !active_timers[QEMU_CLOCK_HOST])
        !          1116:         return;
        !          1117: 
        !          1118:     nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;
        !          1119:     if (nearest_delta_ms < 1) {
        !          1120:         nearest_delta_ms = 1;
        !          1121:     }
        !          1122:     success = ChangeTimerQueueTimer(NULL,
        !          1123:                                     hTimer,
        !          1124:                                     nearest_delta_ms,
        !          1125:                                     3600000);
        !          1126: 
        !          1127:     if (!success) {
        !          1128:         fprintf(stderr, "Failed to rearm win32 alarm timer: %ld\n",
        !          1129:                 GetLastError());
        !          1130:         exit(-1);
        !          1131:     }
        !          1132: 
        !          1133: }
        !          1134: 
1.1       root     1135: #endif /* _WIN32 */
                   1136: 
                   1137: static void alarm_timer_on_change_state_rearm(void *opaque, int running, int reason)
                   1138: {
                   1139:     if (running)
                   1140:         qemu_rearm_alarm_timer((struct qemu_alarm_timer *) opaque);
                   1141: }
                   1142: 
                   1143: int init_timer_alarm(void)
                   1144: {
                   1145:     struct qemu_alarm_timer *t = NULL;
                   1146:     int i, err = -1;
                   1147: 
                   1148:     for (i = 0; alarm_timers[i].name; i++) {
                   1149:         t = &alarm_timers[i];
                   1150: 
                   1151:         err = t->start(t);
                   1152:         if (!err)
                   1153:             break;
                   1154:     }
                   1155: 
                   1156:     if (err) {
                   1157:         err = -ENOENT;
                   1158:         goto fail;
                   1159:     }
                   1160: 
                   1161:     /* first event is at time 0 */
                   1162:     t->pending = 1;
                   1163:     alarm_timer = t;
                   1164:     qemu_add_vm_change_state_handler(alarm_timer_on_change_state_rearm, t);
                   1165: 
                   1166:     return 0;
                   1167: 
                   1168: fail:
                   1169:     return err;
                   1170: }
                   1171: 
                   1172: void quit_timers(void)
                   1173: {
                   1174:     struct qemu_alarm_timer *t = alarm_timer;
                   1175:     alarm_timer = NULL;
                   1176:     t->stop(t);
                   1177: }
                   1178: 
                   1179: int qemu_calculate_timeout(void)
                   1180: {
1.1.1.3 ! root     1181: #ifndef CONFIG_IOTHREAD
1.1       root     1182:     int timeout;
                   1183: 
                   1184:     if (!vm_running)
                   1185:         timeout = 5000;
                   1186:     else {
                   1187:      /* XXX: use timeout computed from timers */
                   1188:         int64_t add;
                   1189:         int64_t delta;
                   1190:         /* Advance virtual time to the next event.  */
                   1191:        delta = qemu_icount_delta();
                   1192:         if (delta > 0) {
                   1193:             /* If virtual time is ahead of real time then just
                   1194:                wait for IO.  */
                   1195:             timeout = (delta + 999999) / 1000000;
                   1196:         } else {
                   1197:             /* Wait for either IO to occur or the next
                   1198:                timer event.  */
1.1.1.3 ! root     1199:             add = qemu_next_icount_deadline();
1.1       root     1200:             /* We advance the timer before checking for IO.
                   1201:                Limit the amount we advance so that early IO
                   1202:                activity won't get the guest too far ahead.  */
                   1203:             if (add > 10000000)
                   1204:                 add = 10000000;
                   1205:             delta += add;
                   1206:             qemu_icount += qemu_icount_round (add);
                   1207:             timeout = delta / 1000000;
                   1208:             if (timeout < 0)
                   1209:                 timeout = 0;
                   1210:         }
                   1211:     }
                   1212: 
                   1213:     return timeout;
1.1.1.3 ! root     1214: #else /* CONFIG_IOTHREAD */
        !          1215:     return 1000;
        !          1216: #endif
1.1       root     1217: }
                   1218: 

unix.superglobalmegacorp.com