Annotation of qemu/qemu-timer.h, revision 1.1.1.5

1.1       root        1: #ifndef QEMU_TIMER_H
                      2: #define QEMU_TIMER_H
                      3: 
1.1.1.3   root        4: #include "qemu-common.h"
1.1.1.5 ! root        5: #include "notify.h"
1.1.1.4   root        6: #include <time.h>
                      7: #include <sys/time.h>
                      8: 
                      9: #ifdef _WIN32
                     10: #include <windows.h>
                     11: #endif
1.1.1.3   root       12: 
1.1       root       13: /* timers */
                     14: 
1.1.1.5 ! root       15: #define SCALE_MS 1000000
        !            16: #define SCALE_US 1000
        !            17: #define SCALE_NS 1
        !            18: 
1.1       root       19: typedef struct QEMUClock QEMUClock;
                     20: typedef void QEMUTimerCB(void *opaque);
                     21: 
                     22: /* The real time clock should be used only for stuff which does not
                     23:    change the virtual machine state, as it is run even if the virtual
                     24:    machine is stopped. The real time clock has a frequency of 1000
                     25:    Hz. */
                     26: extern QEMUClock *rt_clock;
                     27: 
                     28: /* The virtual clock is only run during the emulation. It is stopped
                     29:    when the virtual machine is stopped. Virtual timers use a high
                     30:    precision clock, usually cpu cycles (use ticks_per_sec). */
                     31: extern QEMUClock *vm_clock;
                     32: 
1.1.1.2   root       33: /* The host clock should be use for device models that emulate accurate
                     34:    real time sources. It will continue to run when the virtual machine
                     35:    is suspended, and it will reflect system time changes the host may
                     36:    undergo (e.g. due to NTP). The host clock has the same precision as
                     37:    the virtual clock. */
                     38: extern QEMUClock *host_clock;
                     39: 
1.1.1.3   root       40: int64_t qemu_get_clock_ns(QEMUClock *clock);
                     41: void qemu_clock_enable(QEMUClock *clock, int enabled);
1.1.1.5 ! root       42: void qemu_clock_warp(QEMUClock *clock);
        !            43: 
        !            44: void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
        !            45: void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
        !            46:                                           Notifier *notifier);
1.1       root       47: 
1.1.1.5 ! root       48: QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
        !            49:                           QEMUTimerCB *cb, void *opaque);
1.1       root       50: void qemu_free_timer(QEMUTimer *ts);
                     51: void qemu_del_timer(QEMUTimer *ts);
                     52: void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
                     53: int qemu_timer_pending(QEMUTimer *ts);
1.1.1.2   root       54: int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
1.1       root       55: 
1.1.1.3   root       56: void qemu_run_all_timers(void);
                     57: int qemu_alarm_pending(void);
1.1.1.5 ! root       58: int64_t qemu_next_icount_deadline(void);
1.1.1.3   root       59: void configure_alarms(char const *opt);
                     60: void configure_icount(const char *option);
                     61: int qemu_calculate_timeout(void);
                     62: void init_clocks(void);
                     63: int init_timer_alarm(void);
                     64: void quit_timers(void);
                     65: 
1.1.1.5 ! root       66: int64_t cpu_get_ticks(void);
        !            67: void cpu_enable_ticks(void);
        !            68: void cpu_disable_ticks(void);
        !            69: 
        !            70: static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
        !            71:                                            void *opaque)
        !            72: {
        !            73:     return qemu_new_timer(clock, SCALE_NS, cb, opaque);
        !            74: }
        !            75: 
        !            76: static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
        !            77:                                            void *opaque)
        !            78: {
        !            79:     return qemu_new_timer(clock, SCALE_MS, cb, opaque);
        !            80: }
        !            81: 
        !            82: static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
        !            83: {
        !            84:     return qemu_get_clock_ns(clock) / SCALE_MS;
        !            85: }
        !            86: 
1.1.1.2   root       87: static inline int64_t get_ticks_per_sec(void)
                     88: {
                     89:     return 1000000000LL;
                     90: }
1.1       root       91: 
1.1.1.4   root       92: /* real time host monotonic timer */
                     93: static inline int64_t get_clock_realtime(void)
                     94: {
                     95:     struct timeval tv;
                     96: 
                     97:     gettimeofday(&tv, NULL);
                     98:     return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
                     99: }
                    100: 
                    101: /* Warning: don't insert tracepoints into these functions, they are
                    102:    also used by simpletrace backend and tracepoints would cause
                    103:    an infinite recursion! */
                    104: #ifdef _WIN32
                    105: extern int64_t clock_freq;
                    106: 
                    107: static inline int64_t get_clock(void)
                    108: {
                    109:     LARGE_INTEGER ti;
                    110:     QueryPerformanceCounter(&ti);
                    111:     return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
                    112: }
                    113: 
                    114: #else
                    115: 
                    116: extern int use_rt_clock;
                    117: 
                    118: static inline int64_t get_clock(void)
                    119: {
                    120: #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
                    121:     || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
                    122:     if (use_rt_clock) {
                    123:         struct timespec ts;
                    124:         clock_gettime(CLOCK_MONOTONIC, &ts);
                    125:         return ts.tv_sec * 1000000000LL + ts.tv_nsec;
                    126:     } else
                    127: #endif
                    128:     {
                    129:         /* XXX: using gettimeofday leads to problems if the date
                    130:            changes, so it should be avoided. */
                    131:         return get_clock_realtime();
                    132:     }
                    133: }
                    134: #endif
1.1.1.3   root      135: 
1.1       root      136: void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
                    137: void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
                    138: 
                    139: /* ptimer.c */
                    140: typedef struct ptimer_state ptimer_state;
                    141: typedef void (*ptimer_cb)(void *opaque);
                    142: 
                    143: ptimer_state *ptimer_init(QEMUBH *bh);
                    144: void ptimer_set_period(ptimer_state *s, int64_t period);
                    145: void ptimer_set_freq(ptimer_state *s, uint32_t freq);
                    146: void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
                    147: uint64_t ptimer_get_count(ptimer_state *s);
                    148: void ptimer_set_count(ptimer_state *s, uint64_t count);
                    149: void ptimer_run(ptimer_state *s, int oneshot);
                    150: void ptimer_stop(ptimer_state *s);
                    151: 
1.1.1.3   root      152: /* icount */
                    153: int64_t qemu_icount_round(int64_t count);
                    154: extern int64_t qemu_icount;
                    155: extern int use_icount;
                    156: extern int icount_time_shift;
                    157: extern int64_t qemu_icount_bias;
                    158: int64_t cpu_get_icount(void);
                    159: 
                    160: /*******************************************/
                    161: /* host CPU ticks (if available) */
                    162: 
                    163: #if defined(_ARCH_PPC)
                    164: 
                    165: static inline int64_t cpu_get_real_ticks(void)
                    166: {
                    167:     int64_t retval;
                    168: #ifdef _ARCH_PPC64
                    169:     /* This reads timebase in one 64bit go and includes Cell workaround from:
                    170:        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
                    171:     */
                    172:     __asm__ __volatile__ ("mftb    %0\n\t"
                    173:                           "cmpwi   %0,0\n\t"
                    174:                           "beq-    $-8"
                    175:                           : "=r" (retval));
                    176: #else
                    177:     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
                    178:     unsigned long junk;
                    179:     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
                    180:                           "mfspr   %L0,268\n\t" /* mftb */
                    181:                           "mfspr   %0,269\n\t"  /* mftbu */
                    182:                           "cmpw    %0,%1\n\t"
                    183:                           "bne     $-16"
                    184:                           : "=r" (retval), "=r" (junk));
                    185: #endif
                    186:     return retval;
                    187: }
                    188: 
                    189: #elif defined(__i386__)
                    190: 
                    191: static inline int64_t cpu_get_real_ticks(void)
                    192: {
                    193:     int64_t val;
                    194:     asm volatile ("rdtsc" : "=A" (val));
                    195:     return val;
                    196: }
                    197: 
                    198: #elif defined(__x86_64__)
                    199: 
                    200: static inline int64_t cpu_get_real_ticks(void)
                    201: {
                    202:     uint32_t low,high;
                    203:     int64_t val;
                    204:     asm volatile("rdtsc" : "=a" (low), "=d" (high));
                    205:     val = high;
                    206:     val <<= 32;
                    207:     val |= low;
                    208:     return val;
                    209: }
                    210: 
                    211: #elif defined(__hppa__)
                    212: 
                    213: static inline int64_t cpu_get_real_ticks(void)
                    214: {
                    215:     int val;
                    216:     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
                    217:     return val;
                    218: }
                    219: 
                    220: #elif defined(__ia64)
                    221: 
                    222: static inline int64_t cpu_get_real_ticks(void)
                    223: {
                    224:     int64_t val;
                    225:     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
                    226:     return val;
                    227: }
                    228: 
                    229: #elif defined(__s390__)
                    230: 
                    231: static inline int64_t cpu_get_real_ticks(void)
                    232: {
                    233:     int64_t val;
                    234:     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
                    235:     return val;
                    236: }
                    237: 
                    238: #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
                    239: 
                    240: static inline int64_t cpu_get_real_ticks (void)
                    241: {
                    242: #if defined(_LP64)
                    243:     uint64_t        rval;
                    244:     asm volatile("rd %%tick,%0" : "=r"(rval));
                    245:     return rval;
                    246: #else
                    247:     union {
                    248:         uint64_t i64;
                    249:         struct {
                    250:             uint32_t high;
                    251:             uint32_t low;
                    252:         }       i32;
                    253:     } rval;
                    254:     asm volatile("rd %%tick,%1; srlx %1,32,%0"
                    255:                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
                    256:     return rval.i64;
                    257: #endif
                    258: }
                    259: 
                    260: #elif defined(__mips__) && \
                    261:     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
                    262: /*
                    263:  * binutils wants to use rdhwr only on mips32r2
                    264:  * but as linux kernel emulate it, it's fine
                    265:  * to use it.
                    266:  *
                    267:  */
                    268: #define MIPS_RDHWR(rd, value) {                         \
                    269:         __asm__ __volatile__ (".set   push\n\t"         \
                    270:                               ".set mips32r2\n\t"       \
                    271:                               "rdhwr  %0, "rd"\n\t"     \
                    272:                               ".set   pop"              \
                    273:                               : "=r" (value));          \
                    274:     }
                    275: 
                    276: static inline int64_t cpu_get_real_ticks(void)
                    277: {
                    278:     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
                    279:     uint32_t count;
                    280:     static uint32_t cyc_per_count = 0;
                    281: 
                    282:     if (!cyc_per_count) {
                    283:         MIPS_RDHWR("$3", cyc_per_count);
                    284:     }
                    285: 
                    286:     MIPS_RDHWR("$2", count);
                    287:     return (int64_t)(count * cyc_per_count);
                    288: }
                    289: 
                    290: #elif defined(__alpha__)
                    291: 
                    292: static inline int64_t cpu_get_real_ticks(void)
                    293: {
                    294:     uint64_t cc;
                    295:     uint32_t cur, ofs;
                    296: 
                    297:     asm volatile("rpcc %0" : "=r"(cc));
                    298:     cur = cc;
                    299:     ofs = cc >> 32;
                    300:     return cur - ofs;
                    301: }
                    302: 
                    303: #else
                    304: /* The host CPU doesn't have an easily accessible cycle counter.
                    305:    Just return a monotonically increasing value.  This will be
                    306:    totally wrong, but hopefully better than nothing.  */
                    307: static inline int64_t cpu_get_real_ticks (void)
                    308: {
                    309:     static int64_t ticks = 0;
                    310:     return ticks++;
                    311: }
                    312: #endif
                    313: 
                    314: #ifdef NEED_CPU_H
                    315: /* Deterministic execution requires that IO only be performed on the last
                    316:    instruction of a TB so that interrupts take effect immediately.  */
                    317: static inline int can_do_io(CPUState *env)
                    318: {
                    319:     if (!use_icount)
                    320:         return 1;
                    321: 
                    322:     /* If not executing code then assume we are ok.  */
                    323:     if (!env->current_tb)
                    324:         return 1;
                    325: 
                    326:     return env->can_do_io != 0;
                    327: }
                    328: #endif
                    329: 
                    330: #ifdef CONFIG_PROFILER
                    331: static inline int64_t profile_getclock(void)
                    332: {
                    333:     return cpu_get_real_ticks();
                    334: }
                    335: 
                    336: extern int64_t qemu_time, qemu_time_start;
                    337: extern int64_t tlb_flush_time;
                    338: extern int64_t dev_time;
                    339: #endif
                    340: 
1.1       root      341: #endif

unix.superglobalmegacorp.com