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