qemu-timer.h

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