qemu-timer.h

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