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 int64_t qemu_next_icount_deadline(void);
  62 void configure_alarms(char const *opt);
  63 void configure_icount(const char *option);
  64 int qemu_calculate_timeout(void);
  65 void init_clocks(void);
  66 int init_timer_alarm(void);
  67 void quit_timers(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 qemu_icount_round(int64_t count);
 157 extern int64_t qemu_icount;
 158 extern int use_icount;
 159 extern int icount_time_shift;
 160 extern int64_t qemu_icount_bias;
 161 int64_t cpu_get_icount(void);
 162
 163 /*******************************************/
 164 /* host CPU ticks (if available) */
 165
 166 #if defined(_ARCH_PPC)
 167
 168 static inline int64_t cpu_get_real_ticks(void)
 169 {
 170     int64_t retval;
 171 #ifdef _ARCH_PPC64
 172     /* This reads timebase in one 64bit go and includes Cell workaround from:
 173        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
 174     */
 175     __asm__ __volatile__ ("mftb    %0\n\t"
 176                           "cmpwi   %0,0\n\t"
 177                           "beq-    $-8"
 178                           : "=r" (retval));
 179 #else
 180     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
 181     unsigned long junk;
 182     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
 183                           "mfspr   %L0,268\n\t" /* mftb */
 184                           "mfspr   %0,269\n\t"  /* mftbu */
 185                           "cmpw    %0,%1\n\t"
 186                           "bne     $-16"
 187                           : "=r" (retval), "=r" (junk));
 188 #endif
 189     return retval;
 190 }
 191
 192 #elif defined(__i386__)
 193
 194 static inline int64_t cpu_get_real_ticks(void)
 195 {
 196     int64_t val;
 197     asm volatile ("rdtsc" : "=A" (val));
 198     return val;
 199 }
 200
 201 #elif defined(__x86_64__)
 202
 203 static inline int64_t cpu_get_real_ticks(void)
 204 {
 205     uint32_t low,high;
 206     int64_t val;
 207     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 208     val = high;
 209     val <<= 32;
 210     val |= low;
 211     return val;
 212 }
 213
 214 #elif defined(__hppa__)
 215
 216 static inline int64_t cpu_get_real_ticks(void)
 217 {
 218     int val;
 219     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
 220     return val;
 221 }
 222
 223 #elif defined(__ia64)
 224
 225 static inline int64_t cpu_get_real_ticks(void)
 226 {
 227     int64_t val;
 228     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 229     return val;
 230 }
 231
 232 #elif defined(__s390__)
 233
 234 static inline int64_t cpu_get_real_ticks(void)
 235 {
 236     int64_t val;
 237     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 238     return val;
 239 }
 240
 241 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
 242
 243 static inline int64_t cpu_get_real_ticks (void)
 244 {
 245 #if defined(_LP64)
 246     uint64_t        rval;
 247     asm volatile("rd %%tick,%0" : "=r"(rval));
 248     return rval;
 249 #else
 250     union {
 251         uint64_t i64;
 252         struct {
 253             uint32_t high;
 254             uint32_t low;
 255         }       i32;
 256     } rval;
 257     asm volatile("rd %%tick,%1; srlx %1,32,%0"
 258                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
 259     return rval.i64;
 260 #endif
 261 }
 262
 263 #elif defined(__mips__) && \
 264     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
 265 /*
 266  * binutils wants to use rdhwr only on mips32r2
 267  * but as linux kernel emulate it, it's fine
 268  * to use it.
 269  *
 270  */
 271 #define MIPS_RDHWR(rd, value) {                         \
 272         __asm__ __volatile__ (".set   push\n\t"         \
 273                               ".set mips32r2\n\t"       \
 274                               "rdhwr  %0, "rd"\n\t"     \
 275                               ".set   pop"              \
 276                               : "=r" (value));          \
 277     }
 278
 279 static inline int64_t cpu_get_real_ticks(void)
 280 {
 281     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
 282     uint32_t count;
 283     static uint32_t cyc_per_count = 0;
 284
 285     if (!cyc_per_count) {
 286         MIPS_RDHWR("$3", cyc_per_count);
 287     }
 288
 289     MIPS_RDHWR("$2", count);
 290     return (int64_t)(count * cyc_per_count);
 291 }
 292
 293 #elif defined(__alpha__)
 294
 295 static inline int64_t cpu_get_real_ticks(void)
 296 {
 297     uint64_t cc;
 298     uint32_t cur, ofs;
 299
 300     asm volatile("rpcc %0" : "=r"(cc));
 301     cur = cc;
 302     ofs = cc >> 32;
 303     return cur - ofs;
 304 }
 305
 306 #else
 307 /* The host CPU doesn't have an easily accessible cycle counter.
 308    Just return a monotonically increasing value.  This will be
 309    totally wrong, but hopefully better than nothing.  */
 310 static inline int64_t cpu_get_real_ticks (void)
 311 {
 312     static int64_t ticks = 0;
 313     return ticks++;
 314 }
 315 #endif
 316
 317 #ifdef NEED_CPU_H
 318 /* Deterministic execution requires that IO only be performed on the last
 319    instruction of a TB so that interrupts take effect immediately.  */
 320 static inline int can_do_io(CPUState *env)
 321 {
 322     if (!use_icount)
 323         return 1;
 324
 325     /* If not executing code then assume we are ok.  */
 326     if (!env->current_tb)
 327         return 1;
 328
 329     return env->can_do_io != 0;
 330 }
 331 #endif
 332
 333 #ifdef CONFIG_PROFILER
 334 static inline int64_t profile_getclock(void)
 335 {
 336     return cpu_get_real_ticks();
 337 }
 338
 339 extern int64_t qemu_time, qemu_time_start;
 340 extern int64_t tlb_flush_time;
 341 extern int64_t dev_time;
 342 #endif
 343
 344 #endif