qemu-timer.h

   1 #ifndef QEMU_TIMER_H
   2 #define QEMU_TIMER_H
   3
   4 #include "qemu-common.h"
   5
   6 /* timers */
   7
   8 typedef struct QEMUClock QEMUClock;
   9 typedef void QEMUTimerCB(void *opaque);
  10
  11 /* The real time clock should be used only for stuff which does not
  12    change the virtual machine state, as it is run even if the virtual
  13    machine is stopped. The real time clock has a frequency of 1000
  14    Hz. */
  15 extern QEMUClock *rt_clock;
  16
  17 /* The virtual clock is only run during the emulation. It is stopped
  18    when the virtual machine is stopped. Virtual timers use a high
  19    precision clock, usually cpu cycles (use ticks_per_sec). */
  20 extern QEMUClock *vm_clock;
  21
  22 /* The host clock should be use for device models that emulate accurate
  23    real time sources. It will continue to run when the virtual machine
  24    is suspended, and it will reflect system time changes the host may
  25    undergo (e.g. due to NTP). The host clock has the same precision as
  26    the virtual clock. */
  27 extern QEMUClock *host_clock;
  28
  29 int64_t qemu_get_clock(QEMUClock *clock);
  30 int64_t qemu_get_clock_ns(QEMUClock *clock);
  31 void qemu_clock_enable(QEMUClock *clock, int enabled);
  32
  33 QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
  34 void qemu_free_timer(QEMUTimer *ts);
  35 void qemu_del_timer(QEMUTimer *ts);
  36 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
  37 int qemu_timer_pending(QEMUTimer *ts);
  38 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
  39
  40 void qemu_run_all_timers(void);
  41 int qemu_alarm_pending(void);
  42 int64_t qemu_next_deadline(void);
  43 void configure_alarms(char const *opt);
  44 void configure_icount(const char *option);
  45 int qemu_calculate_timeout(void);
  46 void init_clocks(void);
  47 int init_timer_alarm(void);
  48 void quit_timers(void);
  49
  50 static inline int64_t get_ticks_per_sec(void)
  51 {
  52     return 1000000000LL;
  53 }
  54
  55
  56 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
  57 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
  58
  59 /* ptimer.c */
  60 typedef struct ptimer_state ptimer_state;
  61 typedef void (*ptimer_cb)(void *opaque);
  62
  63 ptimer_state *ptimer_init(QEMUBH *bh);
  64 void ptimer_set_period(ptimer_state *s, int64_t period);
  65 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
  66 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
  67 uint64_t ptimer_get_count(ptimer_state *s);
  68 void ptimer_set_count(ptimer_state *s, uint64_t count);
  69 void ptimer_run(ptimer_state *s, int oneshot);
  70 void ptimer_stop(ptimer_state *s);
  71 void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
  72 void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);
  73
  74 /* icount */
  75 int64_t qemu_icount_round(int64_t count);
  76 extern int64_t qemu_icount;
  77 extern int use_icount;
  78 extern int icount_time_shift;
  79 extern int64_t qemu_icount_bias;
  80 int64_t cpu_get_icount(void);
  81
  82 /*******************************************/
  83 /* host CPU ticks (if available) */
  84
  85 #if defined(_ARCH_PPC)
  86
  87 static inline int64_t cpu_get_real_ticks(void)
  88 {
  89     int64_t retval;
  90 #ifdef _ARCH_PPC64
  91     /* This reads timebase in one 64bit go and includes Cell workaround from:
  92        http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
  93     */
  94     __asm__ __volatile__ ("mftb    %0\n\t"
  95                           "cmpwi   %0,0\n\t"
  96                           "beq-    $-8"
  97                           : "=r" (retval));
  98 #else
  99     /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
 100     unsigned long junk;
 101     __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
 102                           "mfspr   %L0,268\n\t" /* mftb */
 103                           "mfspr   %0,269\n\t"  /* mftbu */
 104                           "cmpw    %0,%1\n\t"
 105                           "bne     $-16"
 106                           : "=r" (retval), "=r" (junk));
 107 #endif
 108     return retval;
 109 }
 110
 111 #elif defined(__i386__)
 112
 113 static inline int64_t cpu_get_real_ticks(void)
 114 {
 115     int64_t val;
 116     asm volatile ("rdtsc" : "=A" (val));
 117     return val;
 118 }
 119
 120 #elif defined(__x86_64__)
 121
 122 static inline int64_t cpu_get_real_ticks(void)
 123 {
 124     uint32_t low,high;
 125     int64_t val;
 126     asm volatile("rdtsc" : "=a" (low), "=d" (high));
 127     val = high;
 128     val <<= 32;
 129     val |= low;
 130     return val;
 131 }
 132
 133 #elif defined(__hppa__)
 134
 135 static inline int64_t cpu_get_real_ticks(void)
 136 {
 137     int val;
 138     asm volatile ("mfctl %%cr16, %0" : "=r"(val));
 139     return val;
 140 }
 141
 142 #elif defined(__ia64)
 143
 144 static inline int64_t cpu_get_real_ticks(void)
 145 {
 146     int64_t val;
 147     asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
 148     return val;
 149 }
 150
 151 #elif defined(__s390__)
 152
 153 static inline int64_t cpu_get_real_ticks(void)
 154 {
 155     int64_t val;
 156     asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
 157     return val;
 158 }
 159
 160 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
 161
 162 static inline int64_t cpu_get_real_ticks (void)
 163 {
 164 #if defined(_LP64)
 165     uint64_t        rval;
 166     asm volatile("rd %%tick,%0" : "=r"(rval));
 167     return rval;
 168 #else
 169     union {
 170         uint64_t i64;
 171         struct {
 172             uint32_t high;
 173             uint32_t low;
 174         }       i32;
 175     } rval;
 176     asm volatile("rd %%tick,%1; srlx %1,32,%0"
 177                  : "=r"(rval.i32.high), "=r"(rval.i32.low));
 178     return rval.i64;
 179 #endif
 180 }
 181
 182 #elif defined(__mips__) && \
 183     ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
 184 /*
 185  * binutils wants to use rdhwr only on mips32r2
 186  * but as linux kernel emulate it, it's fine
 187  * to use it.
 188  *
 189  */
 190 #define MIPS_RDHWR(rd, value) {                         \
 191         __asm__ __volatile__ (".set   push\n\t"         \
 192                               ".set mips32r2\n\t"       \
 193                               "rdhwr  %0, "rd"\n\t"     \
 194                               ".set   pop"              \
 195                               : "=r" (value));          \
 196     }
 197
 198 static inline int64_t cpu_get_real_ticks(void)
 199 {
 200     /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
 201     uint32_t count;
 202     static uint32_t cyc_per_count = 0;
 203
 204     if (!cyc_per_count) {
 205         MIPS_RDHWR("$3", cyc_per_count);
 206     }
 207
 208     MIPS_RDHWR("$2", count);
 209     return (int64_t)(count * cyc_per_count);
 210 }
 211
 212 #elif defined(__alpha__)
 213
 214 static inline int64_t cpu_get_real_ticks(void)
 215 {
 216     uint64_t cc;
 217     uint32_t cur, ofs;
 218
 219     asm volatile("rpcc %0" : "=r"(cc));
 220     cur = cc;
 221     ofs = cc >> 32;
 222     return cur - ofs;
 223 }
 224
 225 #else
 226 /* The host CPU doesn't have an easily accessible cycle counter.
 227    Just return a monotonically increasing value.  This will be
 228    totally wrong, but hopefully better than nothing.  */
 229 static inline int64_t cpu_get_real_ticks (void)
 230 {
 231     static int64_t ticks = 0;
 232     return ticks++;
 233 }
 234 #endif
 235
 236 #ifdef NEED_CPU_H
 237 /* Deterministic execution requires that IO only be performed on the last
 238    instruction of a TB so that interrupts take effect immediately.  */
 239 static inline int can_do_io(CPUState *env)
 240 {
 241     if (!use_icount)
 242         return 1;
 243
 244     /* If not executing code then assume we are ok.  */
 245     if (!env->current_tb)
 246         return 1;
 247
 248     return env->can_do_io != 0;
 249 }
 250 #endif
 251
 252 #ifdef CONFIG_PROFILER
 253 static inline int64_t profile_getclock(void)
 254 {
 255     return cpu_get_real_ticks();
 256 }
 257
 258 extern int64_t qemu_time, qemu_time_start;
 259 extern int64_t tlb_flush_time;
 260 extern int64_t dev_time;
 261 #endif
 262
 263 #endif