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 #else
 213 /* The host CPU doesn't have an easily accessible cycle counter.
 214    Just return a monotonically increasing value.  This will be
 215    totally wrong, but hopefully better than nothing.  */
 216 static inline int64_t cpu_get_real_ticks (void)
 217 {
 218     static int64_t ticks = 0;
 219     return ticks++;
 220 }
 221 #endif
 222
 223 #ifdef NEED_CPU_H
 224 /* Deterministic execution requires that IO only be performed on the last
 225    instruction of a TB so that interrupts take effect immediately.  */
 226 static inline int can_do_io(CPUState *env)
 227 {
 228     if (!use_icount)
 229         return 1;
 230
 231     /* If not executing code then assume we are ok.  */
 232     if (!env->current_tb)
 233         return 1;
 234
 235     return env->can_do_io != 0;
 236 }
 237 #endif
 238
 239 #endif