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