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_all_timers(void);
  63 int qemu_alarm_pending(void);
  64 void configure_alarms(char const *opt);
  65 int qemu_calculate_timeout(void);
  66 void init_clocks(void);
  67 int init_timer_alarm(void);
  68
  69 int64_t cpu_get_ticks(void);
  70 void cpu_enable_ticks(void);
  71 void cpu_disable_ticks(void);
  72
  73 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
  74                                            void *opaque)
  75 {
  76     return qemu_new_timer(clock, SCALE_NS, cb, opaque);
  77 }
  78
  79 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
  80                                            void *opaque)
  81 {
  82     return qemu_new_timer(clock, SCALE_MS, cb, opaque);
  83 }
  84
  85 static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
  86 {
  87     return qemu_get_clock_ns(clock) / SCALE_MS;
  88 }
  89
  90 static inline int64_t get_ticks_per_sec(void)
  91 {
  92     return 1000000000LL;
  93 }
  94
  95 /* real time host monotonic timer */
  96 static inline int64_t get_clock_realtime(void)
  97 {
  98     struct timeval tv;
  99
 100     gettimeofday(&tv, NULL);
 101     return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
 102 }
 103
 104 /* Warning: don't insert tracepoints into these functions, they are
 105    also used by simpletrace backend and tracepoints would cause
 106    an infinite recursion! */
 107 #ifdef _WIN32
 108 extern int64_t clock_freq;
 109
 110 static inline int64_t get_clock(void)
 111 {
 112     LARGE_INTEGER ti;
 113     QueryPerformanceCounter(&ti);
 114     return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
 115 }
 116
 117 #else
 118
 119 extern int use_rt_clock;
 120
 121 static inline 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 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
 140 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
 141
 142 /* ptimer.c */
 143 typedef struct ptimer_state ptimer_state;
 144 typedef void (*ptimer_cb)(void *opaque);
 145
 146 ptimer_state *ptimer_init(QEMUBH *bh);
 147 void ptimer_set_period(ptimer_state *s, int64_t period);
 148 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
 149 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
 150 uint64_t ptimer_get_count(ptimer_state *s);
 151 void ptimer_set_count(ptimer_state *s, uint64_t count);
 152 void ptimer_run(ptimer_state *s, int oneshot);
 153 void ptimer_stop(ptimer_state *s);
 154
 155 /* icount */
 156 int64_t cpu_get_icount(void);
 157 int64_t cpu_get_clock(void);
 158
 159 /*******************************************/
 160 /* host CPU ticks (if available) */
 161
 162 #if defined(_ARCH_PPC)
 163
 164 static inline int64_t cpu_get_real_ticks(void)
 165 {
 166     int64_t retval;
 167 #ifdef _ARCH_PPC64
 168     /* This reads timebase in one 64bit go and includes Cell workaround from:
 169        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
 170     */
 171     __asm__ __volatile__ ("mftb    %0\n\t"
 172                           "cmpwi   %0,0\n\t"
 173                           "beq-    $-8"
 174                           : "=r" (retval));
 175 #else
 176     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
 177     unsigned long junk;
 178     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
 179                           "mfspr   %L0,268\n\t" /* mftb */
 180                           "mfspr   %0,269\n\t"  /* mftbu */
 181                           "cmpw    %0,%1\n\t"
 182                           "bne     $-16"
 183                           : "=r" (retval), "=r" (junk));
 184 #endif
 185     return retval;
 186 }
 187
 188 #elif defined(__i386__)
 189
 190 static inline int64_t cpu_get_real_ticks(void)
 191 {
 192     int64_t val;
 193     asm volatile ("rdtsc" : "=A" (val));
 194     return val;
 195 }
 196
 197 #elif defined(__x86_64__)
 198
 199 static inline int64_t cpu_get_real_ticks(void)
 200 {
 201     uint32_t low,high;
 202     int64_t val;
 203     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 204     val = high;
 205     val <<= 32;
 206     val |= low;
 207     return val;
 208 }
 209
 210 #elif defined(__hppa__)
 211
 212 static inline int64_t cpu_get_real_ticks(void)
 213 {
 214     int val;
 215     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
 216     return val;
 217 }
 218
 219 #elif defined(__ia64)
 220
 221 static inline int64_t cpu_get_real_ticks(void)
 222 {
 223     int64_t val;
 224     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 225     return val;
 226 }
 227
 228 #elif defined(__s390__)
 229
 230 static inline int64_t cpu_get_real_ticks(void)
 231 {
 232     int64_t val;
 233     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 234     return val;
 235 }
 236
 237 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
 238
 239 static inline int64_t cpu_get_real_ticks (void)
 240 {
 241 #if defined(_LP64)
 242     uint64_t        rval;
 243     asm volatile("rd %%tick,%0" : "=r"(rval));
 244     return rval;
 245 #else
 246     union {
 247         uint64_t i64;
 248         struct {
 249             uint32_t high;
 250             uint32_t low;
 251         }       i32;
 252     } rval;
 253     asm volatile("rd %%tick,%1; srlx %1,32,%0"
 254                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
 255     return rval.i64;
 256 #endif
 257 }
 258
 259 #elif defined(__mips__) && \
 260     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
 261 /*
 262  * binutils wants to use rdhwr only on mips32r2
 263  * but as linux kernel emulate it, it's fine
 264  * to use it.
 265  *
 266  */
 267 #define MIPS_RDHWR(rd, value) {                         \
 268         __asm__ __volatile__ (".set   push\n\t"         \
 269                               ".set mips32r2\n\t"       \
 270                               "rdhwr  %0, "rd"\n\t"     \
 271                               ".set   pop"              \
 272                               : "=r" (value));          \
 273     }
 274
 275 static inline int64_t cpu_get_real_ticks(void)
 276 {
 277     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
 278     uint32_t count;
 279     static uint32_t cyc_per_count = 0;
 280
 281     if (!cyc_per_count) {
 282         MIPS_RDHWR("$3", cyc_per_count);
 283     }
 284
 285     MIPS_RDHWR("$2", count);
 286     return (int64_t)(count * cyc_per_count);
 287 }
 288
 289 #elif defined(__alpha__)
 290
 291 static inline int64_t cpu_get_real_ticks(void)
 292 {
 293     uint64_t cc;
 294     uint32_t cur, ofs;
 295
 296     asm volatile("rpcc %0" : "=r"(cc));
 297     cur = cc;
 298     ofs = cc >> 32;
 299     return cur - ofs;
 300 }
 301
 302 #else
 303 /* The host CPU doesn't have an easily accessible cycle counter.
 304    Just return a monotonically increasing value.  This will be
 305    totally wrong, but hopefully better than nothing.  */
 306 static inline int64_t cpu_get_real_ticks (void)
 307 {
 308     static int64_t ticks = 0;
 309     return ticks++;
 310 }
 311 #endif
 312
 313 #ifdef CONFIG_PROFILER
 314 static inline int64_t profile_getclock(void)
 315 {
 316     return cpu_get_real_ticks();
 317 }
 318
 319 extern int64_t qemu_time, qemu_time_start;
 320 extern int64_t tlb_flush_time;
 321 extern int64_t dev_time;
 322 #endif
 323
 324 #endif