qemu-timer.h

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