File:  [Qemu by Fabrice Bellard] / qemu / qemu-timer.c
Revision 1.1.1.3 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 18:56:13 2018 UTC (2 years, 6 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu1000, qemu0151, HEAD
qemu 0.15.1

    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: 
  104: #ifndef CONFIG_IOTHREAD
  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: }
  118: #endif
  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;
  151: 
  152:     QEMUTimer *warp_timer;
  153: 
  154:     NotifierList reset_notifiers;
  155:     int64_t last;
  156: };
  157: 
  158: struct QEMUTimer {
  159:     QEMUClock *clock;
  160:     int64_t expire_time;	/* in nanoseconds */
  161:     int scale;
  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);
  172: #if defined(__linux__)
  173:     int fd;
  174:     timer_t timer;
  175: #elif defined(_WIN32)
  176:     HANDLE timer;
  177: #endif
  178:     char expired;
  179:     char pending;
  180: };
  181: 
  182: static struct qemu_alarm_timer *alarm_timer;
  183: 
  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: 
  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: 
  207: /* TODO: MIN_TIMER_REARM_NS should be optimized */
  208: #define MIN_TIMER_REARM_NS 250000
  209: 
  210: #ifdef _WIN32
  211: 
  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);
  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);
  224: static void unix_rearm_timer(struct qemu_alarm_timer *t);
  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();
  253:     cur_icount = qemu_get_clock_ns(vm_clock);
  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,
  275:                    qemu_get_clock_ms(rt_clock) + 1000);
  276:     icount_adjust();
  277: }
  278: 
  279: static void icount_adjust_vm(void * opaque)
  280: {
  281:     qemu_mod_timer(icount_vm_timer,
  282:                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
  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,
  295:      dynticks_stop_timer, dynticks_rearm_timer},
  296: #endif
  297:     {"unix", unix_start_timer, unix_stop_timer, unix_rearm_timer},
  298: #else
  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},
  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;
  382: 
  383:     clock = qemu_mallocz(sizeof(QEMUClock));
  384:     clock->type = type;
  385:     clock->enabled = 1;
  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:     }
  391:     return clock;
  392: }
  393: 
  394: void qemu_clock_enable(QEMUClock *clock, int enabled)
  395: {
  396:     clock->enabled = enabled;
  397: }
  398: 
  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)
  485: {
  486:     QEMUTimer *ts;
  487: 
  488:     ts = qemu_mallocz(sizeof(QEMUTimer));
  489:     ts->clock = clock;
  490:     ts->cb = cb;
  491:     ts->opaque = opaque;
  492:     ts->scale = scale;
  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. */
  523: static void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time)
  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;
  535:         if (!qemu_timer_expired_ns(t, expire_time)) {
  536:             break;
  537:         }
  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.  */
  550:         qemu_clock_warp(ts->clock);
  551:         if (use_icount) {
  552:             qemu_notify_event();
  553:         }
  554:     }
  555: }
  556: 
  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: 
  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: {
  576:     return qemu_timer_expired_ns(timer_head, current_time * timer_head->scale);
  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: 
  587:     current_time = qemu_get_clock_ns(clock);
  588:     ptimer_head = &active_timers[clock->type];
  589:     for(;;) {
  590:         ts = *ptimer_head;
  591:         if (!qemu_timer_expired_ns(ts, current_time)) {
  592:             break;
  593:         }
  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: 
  603: int64_t qemu_get_clock_ns(QEMUClock *clock)
  604: {
  605:     int64_t now, last;
  606: 
  607:     switch(clock->type) {
  608:     case QEMU_CLOCK_REALTIME:
  609:         return get_clock();
  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:
  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;
  625:     }
  626: }
  627: 
  628: void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier)
  629: {
  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);
  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) {
  666:         qemu_mod_timer_ns(ts, expire_time);
  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: 
  691: #ifdef CONFIG_IOTHREAD
  692:     vm_clock->warp_timer = qemu_new_timer_ns(rt_clock, icount_warp_rt, NULL);
  693: #endif
  694: 
  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.  */
  712:     icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
  713:     qemu_mod_timer(icount_rt_timer,
  714:                    qemu_get_clock_ms(rt_clock) + 1000);
  715:     icount_vm_timer = qemu_new_timer_ns(vm_clock, icount_adjust_vm, NULL);
  716:     qemu_mod_timer(icount_vm_timer,
  717:                    qemu_get_clock_ns(vm_clock) + get_ticks_per_sec() / 10);
  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: 
  739: static int64_t qemu_next_alarm_deadline(void);
  740: 
  741: #ifdef _WIN32
  742: static void CALLBACK host_alarm_handler(PVOID lpParam, BOOLEAN unused)
  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;
  757:         ti = qemu_get_clock_ns(vm_clock);
  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) ||
  781:         qemu_next_alarm_deadline () <= 0) {
  782:         t->expired = alarm_has_dynticks(t);
  783:         t->pending = 1;
  784:         qemu_notify_event();
  785:     }
  786: }
  787: 
  788: int64_t qemu_next_icount_deadline(void)
  789: {
  790:     /* To avoid problems with overflow limit this to 2^32.  */
  791:     int64_t delta = INT32_MAX;
  792: 
  793:     assert(use_icount);
  794:     if (active_timers[QEMU_CLOCK_VIRTUAL]) {
  795:         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
  796:                      qemu_get_clock_ns(vm_clock);
  797:     }
  798: 
  799:     if (delta < 0)
  800:         delta = 0;
  801: 
  802:     return delta;
  803: }
  804: 
  805: static int64_t qemu_next_alarm_deadline(void)
  806: {
  807:     int64_t delta;
  808:     int64_t rtdelta;
  809: 
  810:     if (!use_icount && active_timers[QEMU_CLOCK_VIRTUAL]) {
  811:         delta = active_timers[QEMU_CLOCK_VIRTUAL]->expire_time -
  812:                      qemu_get_clock_ns(vm_clock);
  813:     } else {
  814:         delta = INT32_MAX;
  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:     }
  822:     if (active_timers[QEMU_CLOCK_REALTIME]) {
  823:         rtdelta = (active_timers[QEMU_CLOCK_REALTIME]->expire_time -
  824:                  qemu_get_clock_ns(rt_clock));
  825:         if (rtdelta < delta)
  826:             delta = rtdelta;
  827:     }
  828: 
  829:     return delta;
  830: }
  831: 
  832: #if defined(__linux__)
  833: 
  834: #include "compatfd.h"
  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;
  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 */
  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: 
  872:     t->timer = host_timer;
  873: 
  874:     return 0;
  875: }
  876: 
  877: static void dynticks_stop_timer(struct qemu_alarm_timer *t)
  878: {
  879:     timer_t host_timer = t->timer;
  880: 
  881:     timer_delete(host_timer);
  882: }
  883: 
  884: static void dynticks_rearm_timer(struct qemu_alarm_timer *t)
  885: {
  886:     timer_t host_timer = t->timer;
  887:     struct itimerspec timeout;
  888:     int64_t nearest_delta_ns = INT64_MAX;
  889:     int64_t current_ns;
  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: 
  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;
  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:     }
  907:     current_ns = timeout.it_value.tv_sec * 1000000000LL + timeout.it_value.tv_nsec;
  908:     if (current_ns && current_ns <= nearest_delta_ns)
  909:         return;
  910: 
  911:     timeout.it_interval.tv_sec = 0;
  912:     timeout.it_interval.tv_nsec = 0; /* 0 for one-shot timer */
  913:     timeout.it_value.tv_sec =  nearest_delta_ns / 1000000000;
  914:     timeout.it_value.tv_nsec = nearest_delta_ns % 1000000000;
  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: 
  924: #if !defined(_WIN32)
  925: 
  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);
  936:     return 0;
  937: }
  938: 
  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;
  944: 
  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;
  950: 
  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:     }
  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: 
  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)
  999: {
 1000:     TIMECAPS tc;
 1001:     UINT flags;
 1002: 
 1003:     memset(&tc, 0, sizeof(tc));
 1004:     timeGetDevCaps(&tc, sizeof(tc));
 1005: 
 1006:     mm_period = tc.wPeriodMin;
 1007:     timeBeginPeriod(mm_period);
 1008: 
 1009:     flags = TIME_CALLBACK_FUNCTION;
 1010:     if (alarm_has_dynticks(t)) {
 1011:         flags |= TIME_ONESHOT;
 1012:     } else {
 1013:         flags |= TIME_PERIODIC;
 1014:     }
 1015: 
 1016:     mm_timer = timeSetEvent(1,                  /* interval (ms) */
 1017:                             mm_period,          /* resolution */
 1018:                             mm_alarm_handler,   /* function */
 1019:                             (DWORD_PTR)t,       /* parameter */
 1020:                             flags);
 1021: 
 1022:     if (!mm_timer) {
 1023:         fprintf(stderr, "Failed to initialize win32 alarm timer: %ld\n",
 1024:                 GetLastError());
 1025:         timeEndPeriod(mm_period);
 1026:         return -1;
 1027:     }
 1028: 
 1029:     return 0;
 1030: }
 1031: 
 1032: static void mm_stop_timer(struct qemu_alarm_timer *t)
 1033: {
 1034:     timeKillEvent(mm_timer);
 1035:     timeEndPeriod(mm_period);
 1036: }
 1037: 
 1038: static void mm_rearm_timer(struct qemu_alarm_timer *t)
 1039: {
 1040:     int nearest_delta_ms;
 1041: 
 1042:     assert(alarm_has_dynticks(t));
 1043:     if (!active_timers[QEMU_CLOCK_REALTIME] &&
 1044:         !active_timers[QEMU_CLOCK_VIRTUAL] &&
 1045:         !active_timers[QEMU_CLOCK_HOST]) {
 1046:         return;
 1047:     }
 1048: 
 1049:     timeKillEvent(mm_timer);
 1050: 
 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);
 1060: 
 1061:     if (!mm_timer) {
 1062:         fprintf(stderr, "Failed to re-arm win32 alarm timer %ld\n",
 1063:                 GetLastError());
 1064: 
 1065:         timeEndPeriod(mm_period);
 1066:         exit(1);
 1067:     }
 1068: }
 1069: 
 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: 
 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: {
 1181: #ifndef CONFIG_IOTHREAD
 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.  */
 1199:             add = qemu_next_icount_deadline();
 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;
 1214: #else /* CONFIG_IOTHREAD */
 1215:     return 1000;
 1216: #endif
 1217: }
 1218: 

unix.superglobalmegacorp.com