blob: de17f3b1a1fc0c5ccd42a8ba6364abdbc8476edf [file] [log] [blame]
pbrook87ecb682007-11-17 17:14:51 +00001#ifndef QEMU_TIMER_H
2#define QEMU_TIMER_H
3
Blue Swirl29e922b2010-03-29 19:24:00 +00004#include "qemu-common.h"
Paolo Bonzini44a9b352011-09-12 16:44:30 +02005#include "main-loop.h"
Jan Kiszka691a0c92011-06-20 14:06:27 +02006#include "notify.h"
Blue Swirlc57c8462010-10-23 15:24:07 +00007#include <time.h>
8#include <sys/time.h>
9
10#ifdef _WIN32
11#include <windows.h>
Blue Swirlc57c8462010-10-23 15:24:07 +000012#endif
Blue Swirl29e922b2010-03-29 19:24:00 +000013
pbrook87ecb682007-11-17 17:14:51 +000014/* timers */
15
Paolo Bonzini0ce1b942011-03-11 16:46:02 +010016#define SCALE_MS 1000000
17#define SCALE_US 1000
18#define SCALE_NS 1
19
pbrook87ecb682007-11-17 17:14:51 +000020typedef struct QEMUClock QEMUClock;
21typedef void QEMUTimerCB(void *opaque);
22
23/* The real time clock should be used only for stuff which does not
24 change the virtual machine state, as it is run even if the virtual
25 machine is stopped. The real time clock has a frequency of 1000
26 Hz. */
27extern QEMUClock *rt_clock;
28
29/* The virtual clock is only run during the emulation. It is stopped
30 when the virtual machine is stopped. Virtual timers use a high
31 precision clock, usually cpu cycles (use ticks_per_sec). */
32extern QEMUClock *vm_clock;
33
Jan Kiszka21d5d122009-09-15 13:36:04 +020034/* The host clock should be use for device models that emulate accurate
35 real time sources. It will continue to run when the virtual machine
36 is suspended, and it will reflect system time changes the host may
37 undergo (e.g. due to NTP). The host clock has the same precision as
38 the virtual clock. */
39extern QEMUClock *host_clock;
40
Paolo Bonzini41c872b2010-01-26 10:31:46 +020041int64_t qemu_get_clock_ns(QEMUClock *clock);
Paolo Bonzinidc2dfcf2011-09-12 15:50:16 +020042int64_t qemu_clock_has_timers(QEMUClock *clock);
43int64_t qemu_clock_expired(QEMUClock *clock);
44int64_t qemu_clock_deadline(QEMUClock *clock);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010045void qemu_clock_enable(QEMUClock *clock, int enabled);
Paolo Bonziniab33fcd2011-04-13 10:03:44 +020046void qemu_clock_warp(QEMUClock *clock);
pbrook87ecb682007-11-17 17:14:51 +000047
Jan Kiszka691a0c92011-06-20 14:06:27 +020048void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
49void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
50 Notifier *notifier);
51
Paolo Bonzini4a998742011-03-11 16:33:58 +010052QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
53 QEMUTimerCB *cb, void *opaque);
pbrook87ecb682007-11-17 17:14:51 +000054void qemu_free_timer(QEMUTimer *ts);
55void qemu_del_timer(QEMUTimer *ts);
Paolo Bonzini2ff68d02011-09-12 16:21:44 +020056void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time);
pbrook87ecb682007-11-17 17:14:51 +000057void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
58int qemu_timer_pending(QEMUTimer *ts);
Stefano Stabellini2430ffe2009-08-03 10:56:01 +010059int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
Paolo Bonzini2ff68d02011-09-12 16:21:44 +020060uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts);
pbrook87ecb682007-11-17 17:14:51 +000061
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010062void qemu_run_all_timers(void);
63int qemu_alarm_pending(void);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010064void configure_alarms(char const *opt);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010065int qemu_calculate_timeout(void);
66void init_clocks(void);
67int init_timer_alarm(void);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010068
Blue Swirl70c3b552011-03-27 15:45:39 +000069int64_t cpu_get_ticks(void);
70void cpu_enable_ticks(void);
71void cpu_disable_ticks(void);
72
Paolo Bonzini0ce1b942011-03-11 16:46:02 +010073static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
74 void *opaque)
75{
Paolo Bonzini4a998742011-03-11 16:33:58 +010076 return qemu_new_timer(clock, SCALE_NS, cb, opaque);
Paolo Bonzini0ce1b942011-03-11 16:46:02 +010077}
78
79static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
80 void *opaque)
81{
Paolo Bonzini4a998742011-03-11 16:33:58 +010082 return qemu_new_timer(clock, SCALE_MS, cb, opaque);
Paolo Bonzini0ce1b942011-03-11 16:46:02 +010083}
84
85static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
86{
87 return qemu_get_clock_ns(clock) / SCALE_MS;
88}
89
Anthony Liguori274dfed2009-09-11 10:28:26 -050090static inline int64_t get_ticks_per_sec(void)
91{
92 return 1000000000LL;
93}
pbrook87ecb682007-11-17 17:14:51 +000094
Blue Swirlc57c8462010-10-23 15:24:07 +000095/* real time host monotonic timer */
96static 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
108extern int64_t clock_freq;
109
110static 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
119extern int use_rt_clock;
120
121static 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
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100138
pbrook87ecb682007-11-17 17:14:51 +0000139void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
140void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
141
Blue Swirl29e922b2010-03-29 19:24:00 +0000142/* icount */
Blue Swirl29e922b2010-03-29 19:24:00 +0000143int64_t cpu_get_icount(void);
Paolo Bonzini946fb272011-09-12 13:57:37 +0200144int64_t cpu_get_clock(void);
Blue Swirl29e922b2010-03-29 19:24:00 +0000145
146/*******************************************/
147/* host CPU ticks (if available) */
148
149#if defined(_ARCH_PPC)
150
151static inline int64_t cpu_get_real_ticks(void)
152{
153 int64_t retval;
154#ifdef _ARCH_PPC64
155 /* This reads timebase in one 64bit go and includes Cell workaround from:
156 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
157 */
158 __asm__ __volatile__ ("mftb %0\n\t"
159 "cmpwi %0,0\n\t"
160 "beq- $-8"
161 : "=r" (retval));
162#else
163 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
164 unsigned long junk;
Alexander Graf4a9590f2010-04-03 11:37:26 +0200165 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
166 "mfspr %L0,268\n\t" /* mftb */
167 "mfspr %0,269\n\t" /* mftbu */
Blue Swirl29e922b2010-03-29 19:24:00 +0000168 "cmpw %0,%1\n\t"
169 "bne $-16"
170 : "=r" (retval), "=r" (junk));
171#endif
172 return retval;
173}
174
175#elif defined(__i386__)
176
177static inline int64_t cpu_get_real_ticks(void)
178{
179 int64_t val;
180 asm volatile ("rdtsc" : "=A" (val));
181 return val;
182}
183
184#elif defined(__x86_64__)
185
186static inline int64_t cpu_get_real_ticks(void)
187{
188 uint32_t low,high;
189 int64_t val;
190 asm volatile("rdtsc" : "=a" (low), "=d" (high));
191 val = high;
192 val <<= 32;
193 val |= low;
194 return val;
195}
196
197#elif defined(__hppa__)
198
199static inline int64_t cpu_get_real_ticks(void)
200{
201 int val;
202 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
203 return val;
204}
205
206#elif defined(__ia64)
207
208static inline int64_t cpu_get_real_ticks(void)
209{
210 int64_t val;
211 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
212 return val;
213}
214
215#elif defined(__s390__)
216
217static inline int64_t cpu_get_real_ticks(void)
218{
219 int64_t val;
220 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
221 return val;
222}
223
224#elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
225
226static inline int64_t cpu_get_real_ticks (void)
227{
228#if defined(_LP64)
229 uint64_t rval;
230 asm volatile("rd %%tick,%0" : "=r"(rval));
231 return rval;
232#else
233 union {
234 uint64_t i64;
235 struct {
236 uint32_t high;
237 uint32_t low;
238 } i32;
239 } rval;
240 asm volatile("rd %%tick,%1; srlx %1,32,%0"
241 : "=r"(rval.i32.high), "=r"(rval.i32.low));
242 return rval.i64;
243#endif
244}
245
246#elif defined(__mips__) && \
247 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
248/*
249 * binutils wants to use rdhwr only on mips32r2
250 * but as linux kernel emulate it, it's fine
251 * to use it.
252 *
253 */
254#define MIPS_RDHWR(rd, value) { \
255 __asm__ __volatile__ (".set push\n\t" \
256 ".set mips32r2\n\t" \
257 "rdhwr %0, "rd"\n\t" \
258 ".set pop" \
259 : "=r" (value)); \
260 }
261
262static inline int64_t cpu_get_real_ticks(void)
263{
264 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
265 uint32_t count;
266 static uint32_t cyc_per_count = 0;
267
268 if (!cyc_per_count) {
269 MIPS_RDHWR("$3", cyc_per_count);
270 }
271
272 MIPS_RDHWR("$2", count);
273 return (int64_t)(count * cyc_per_count);
274}
275
Richard Henderson14a60632010-04-12 16:19:26 -0700276#elif defined(__alpha__)
277
278static inline int64_t cpu_get_real_ticks(void)
279{
280 uint64_t cc;
281 uint32_t cur, ofs;
282
283 asm volatile("rpcc %0" : "=r"(cc));
284 cur = cc;
285 ofs = cc >> 32;
286 return cur - ofs;
287}
288
Blue Swirl29e922b2010-03-29 19:24:00 +0000289#else
290/* The host CPU doesn't have an easily accessible cycle counter.
291 Just return a monotonically increasing value. This will be
292 totally wrong, but hopefully better than nothing. */
293static inline int64_t cpu_get_real_ticks (void)
294{
295 static int64_t ticks = 0;
296 return ticks++;
297}
298#endif
299
Richard Henderson2d8ebcf2010-04-17 16:25:10 +0000300#ifdef CONFIG_PROFILER
301static inline int64_t profile_getclock(void)
302{
303 return cpu_get_real_ticks();
304}
305
306extern int64_t qemu_time, qemu_time_start;
307extern int64_t tlb_flush_time;
308extern int64_t dev_time;
309#endif
310
pbrook87ecb682007-11-17 17:14:51 +0000311#endif