qemu-timer.h

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