1 #ifndef QEMU_TIMER_H 2 #define QEMU_TIMER_H 3 4 #include "qemu-common.h" 5 #include "qemu/main-loop.h" 6 #include "qemu/notify.h" 7 8 /* timers */ 9 10 #define SCALE_MS 1000000 11 #define SCALE_US 1000 12 #define SCALE_NS 1 13 14 typedef struct QEMUClock QEMUClock; 15 typedef void QEMUTimerCB(void *opaque); 16 17 /* The real time clock should be used only for stuff which does not 18 change the virtual machine state, as it is run even if the virtual 19 machine is stopped. The real time clock has a frequency of 1000 20 Hz. */ 21 extern QEMUClock *rt_clock; 22 23 /* The virtual clock is only run during the emulation. It is stopped 24 when the virtual machine is stopped. Virtual timers use a high 25 precision clock, usually cpu cycles (use ticks_per_sec). */ 26 extern QEMUClock *vm_clock; 27 28 /* The host clock should be use for device models that emulate accurate 29 real time sources. It will continue to run when the virtual machine 30 is suspended, and it will reflect system time changes the host may 31 undergo (e.g. due to NTP). The host clock has the same precision as 32 the virtual clock. */ 33 extern QEMUClock *host_clock; 34 35 int64_t qemu_get_clock_ns(QEMUClock *clock); 36 int64_t qemu_clock_has_timers(QEMUClock *clock); 37 int64_t qemu_clock_expired(QEMUClock *clock); 38 int64_t qemu_clock_deadline(QEMUClock *clock); 39 void qemu_clock_enable(QEMUClock *clock, bool enabled); 40 void qemu_clock_warp(QEMUClock *clock); 41 42 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier); 43 void qemu_unregister_clock_reset_notifier(QEMUClock *clock, 44 Notifier *notifier); 45 46 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale, 47 QEMUTimerCB *cb, void *opaque); 48 void qemu_free_timer(QEMUTimer *ts); 49 void qemu_del_timer(QEMUTimer *ts); 50 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time); 51 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time); 52 bool qemu_timer_pending(QEMUTimer *ts); 53 bool qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time); 54 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts); 55 56 void qemu_run_timers(QEMUClock *clock); 57 void qemu_run_all_timers(void); 58 void configure_alarms(char const *opt); 59 void init_clocks(void); 60 int init_timer_alarm(void); 61 62 int64_t cpu_get_ticks(void); 63 void cpu_enable_ticks(void); 64 void cpu_disable_ticks(void); 65 66 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb, 67 void *opaque) 68 { 69 return qemu_new_timer(clock, SCALE_NS, cb, opaque); 70 } 71 72 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb, 73 void *opaque) 74 { 75 return qemu_new_timer(clock, SCALE_MS, cb, opaque); 76 } 77 78 static inline int64_t qemu_get_clock_ms(QEMUClock *clock) 79 { 80 return qemu_get_clock_ns(clock) / SCALE_MS; 81 } 82 83 static inline int64_t get_ticks_per_sec(void) 84 { 85 return 1000000000LL; 86 } 87 88 /* real time host monotonic timer */ 89 static inline int64_t get_clock_realtime(void) 90 { 91 struct timeval tv; 92 93 gettimeofday(&tv, NULL); 94 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000); 95 } 96 97 /* Warning: don't insert tracepoints into these functions, they are 98 also used by simpletrace backend and tracepoints would cause 99 an infinite recursion! */ 100 #ifdef _WIN32 101 extern int64_t clock_freq; 102 103 static inline int64_t get_clock(void) 104 { 105 LARGE_INTEGER ti; 106 QueryPerformanceCounter(&ti); 107 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq); 108 } 109 110 #else 111 112 extern int use_rt_clock; 113 114 static inline int64_t get_clock(void) 115 { 116 #ifdef CLOCK_MONOTONIC 117 if (use_rt_clock) { 118 struct timespec ts; 119 clock_gettime(CLOCK_MONOTONIC, &ts); 120 return ts.tv_sec * 1000000000LL + ts.tv_nsec; 121 } else 122 #endif 123 { 124 /* XXX: using gettimeofday leads to problems if the date 125 changes, so it should be avoided. */ 126 return get_clock_realtime(); 127 } 128 } 129 #endif 130 131 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts); 132 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts); 133 134 /* icount */ 135 int64_t cpu_get_icount(void); 136 int64_t cpu_get_clock(void); 137 138 /*******************************************/ 139 /* host CPU ticks (if available) */ 140 141 #if defined(_ARCH_PPC) 142 143 static inline int64_t cpu_get_real_ticks(void) 144 { 145 int64_t retval; 146 #ifdef _ARCH_PPC64 147 /* This reads timebase in one 64bit go and includes Cell workaround from: 148 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html 149 */ 150 __asm__ __volatile__ ("mftb %0\n\t" 151 "cmpwi %0,0\n\t" 152 "beq- $-8" 153 : "=r" (retval)); 154 #else 155 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */ 156 unsigned long junk; 157 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */ 158 "mfspr %L0,268\n\t" /* mftb */ 159 "mfspr %0,269\n\t" /* mftbu */ 160 "cmpw %0,%1\n\t" 161 "bne $-16" 162 : "=r" (retval), "=r" (junk)); 163 #endif 164 return retval; 165 } 166 167 #elif defined(__i386__) 168 169 static inline int64_t cpu_get_real_ticks(void) 170 { 171 int64_t val; 172 asm volatile ("rdtsc" : "=A" (val)); 173 return val; 174 } 175 176 #elif defined(__x86_64__) 177 178 static inline int64_t cpu_get_real_ticks(void) 179 { 180 uint32_t low,high; 181 int64_t val; 182 asm volatile("rdtsc" : "=a" (low), "=d" (high)); 183 val = high; 184 val <<= 32; 185 val |= low; 186 return val; 187 } 188 189 #elif defined(__hppa__) 190 191 static inline int64_t cpu_get_real_ticks(void) 192 { 193 int val; 194 asm volatile ("mfctl %%cr16, %0" : "=r"(val)); 195 return val; 196 } 197 198 #elif defined(__ia64) 199 200 static inline int64_t cpu_get_real_ticks(void) 201 { 202 int64_t val; 203 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory"); 204 return val; 205 } 206 207 #elif defined(__s390__) 208 209 static inline int64_t cpu_get_real_ticks(void) 210 { 211 int64_t val; 212 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc"); 213 return val; 214 } 215 216 #elif defined(__sparc__) 217 218 static inline int64_t cpu_get_real_ticks (void) 219 { 220 #if defined(_LP64) 221 uint64_t rval; 222 asm volatile("rd %%tick,%0" : "=r"(rval)); 223 return rval; 224 #else 225 /* We need an %o or %g register for this. For recent enough gcc 226 there is an "h" constraint for that. Don't bother with that. */ 227 union { 228 uint64_t i64; 229 struct { 230 uint32_t high; 231 uint32_t low; 232 } i32; 233 } rval; 234 asm volatile("rd %%tick,%%g1; srlx %%g1,32,%0; mov %%g1,%1" 235 : "=r"(rval.i32.high), "=r"(rval.i32.low) : : "g1"); 236 return rval.i64; 237 #endif 238 } 239 240 #elif defined(__mips__) && \ 241 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__)) 242 /* 243 * binutils wants to use rdhwr only on mips32r2 244 * but as linux kernel emulate it, it's fine 245 * to use it. 246 * 247 */ 248 #define MIPS_RDHWR(rd, value) { \ 249 __asm__ __volatile__ (".set push\n\t" \ 250 ".set mips32r2\n\t" \ 251 "rdhwr %0, "rd"\n\t" \ 252 ".set pop" \ 253 : "=r" (value)); \ 254 } 255 256 static inline int64_t cpu_get_real_ticks(void) 257 { 258 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */ 259 uint32_t count; 260 static uint32_t cyc_per_count = 0; 261 262 if (!cyc_per_count) { 263 MIPS_RDHWR("$3", cyc_per_count); 264 } 265 266 MIPS_RDHWR("$2", count); 267 return (int64_t)(count * cyc_per_count); 268 } 269 270 #elif defined(__alpha__) 271 272 static inline int64_t cpu_get_real_ticks(void) 273 { 274 uint64_t cc; 275 uint32_t cur, ofs; 276 277 asm volatile("rpcc %0" : "=r"(cc)); 278 cur = cc; 279 ofs = cc >> 32; 280 return cur - ofs; 281 } 282 283 #else 284 /* The host CPU doesn't have an easily accessible cycle counter. 285 Just return a monotonically increasing value. This will be 286 totally wrong, but hopefully better than nothing. */ 287 static inline int64_t cpu_get_real_ticks (void) 288 { 289 static int64_t ticks = 0; 290 return ticks++; 291 } 292 #endif 293 294 #ifdef CONFIG_PROFILER 295 static inline int64_t profile_getclock(void) 296 { 297 return cpu_get_real_ticks(); 298 } 299 300 extern int64_t qemu_time, qemu_time_start; 301 extern int64_t tlb_flush_time; 302 extern int64_t dev_time; 303 #endif 304 305 #endif 306