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

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

unix.superglobalmegacorp.com