blob: 8cd8f8368ad50c1802bf9b05a59f008370f54af3 [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"
Blue Swirlc57c8462010-10-23 15:24:07 +00005#include <time.h>
6#include <sys/time.h>
7
8#ifdef _WIN32
9#include <windows.h>
10#include <mmsystem.h>
11#endif
Blue Swirl29e922b2010-03-29 19:24:00 +000012
pbrook87ecb682007-11-17 17:14:51 +000013/* timers */
14
15typedef struct QEMUClock QEMUClock;
16typedef void QEMUTimerCB(void *opaque);
17
18/* The real time clock should be used only for stuff which does not
19 change the virtual machine state, as it is run even if the virtual
20 machine is stopped. The real time clock has a frequency of 1000
21 Hz. */
22extern QEMUClock *rt_clock;
23
24/* The virtual clock is only run during the emulation. It is stopped
25 when the virtual machine is stopped. Virtual timers use a high
26 precision clock, usually cpu cycles (use ticks_per_sec). */
27extern QEMUClock *vm_clock;
28
Jan Kiszka21d5d122009-09-15 13:36:04 +020029/* The host clock should be use for device models that emulate accurate
30 real time sources. It will continue to run when the virtual machine
31 is suspended, and it will reflect system time changes the host may
32 undergo (e.g. due to NTP). The host clock has the same precision as
33 the virtual clock. */
34extern QEMUClock *host_clock;
35
pbrook87ecb682007-11-17 17:14:51 +000036int64_t qemu_get_clock(QEMUClock *clock);
Paolo Bonzini41c872b2010-01-26 10:31:46 +020037int64_t qemu_get_clock_ns(QEMUClock *clock);
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010038void qemu_clock_enable(QEMUClock *clock, int enabled);
pbrook87ecb682007-11-17 17:14:51 +000039
40QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
41void qemu_free_timer(QEMUTimer *ts);
42void qemu_del_timer(QEMUTimer *ts);
43void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
44int qemu_timer_pending(QEMUTimer *ts);
Stefano Stabellini2430ffe2009-08-03 10:56:01 +010045int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
pbrook87ecb682007-11-17 17:14:51 +000046
Paolo Bonzinidb1a4972010-03-10 11:38:55 +010047void qemu_run_all_timers(void);
48int qemu_alarm_pending(void);
49int64_t qemu_next_deadline(void);
50void configure_alarms(char const *opt);
51void configure_icount(const char *option);
52int qemu_calculate_timeout(void);
53void init_clocks(void);
54int init_timer_alarm(void);
55void quit_timers(void);
56
Anthony Liguori274dfed2009-09-11 10:28:26 -050057static inline int64_t get_ticks_per_sec(void)
58{
59 return 1000000000LL;
60}
pbrook87ecb682007-11-17 17:14:51 +000061
Blue Swirlc57c8462010-10-23 15:24:07 +000062/* real time host monotonic timer */
63static inline int64_t get_clock_realtime(void)
64{
65 struct timeval tv;
66
67 gettimeofday(&tv, NULL);
68 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
69}
70
71/* Warning: don't insert tracepoints into these functions, they are
72 also used by simpletrace backend and tracepoints would cause
73 an infinite recursion! */
74#ifdef _WIN32
75extern int64_t clock_freq;
76
77static inline int64_t get_clock(void)
78{
79 LARGE_INTEGER ti;
80 QueryPerformanceCounter(&ti);
81 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
82}
83
84#else
85
86extern int use_rt_clock;
87
88static inline int64_t get_clock(void)
89{
90#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
91 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
92 if (use_rt_clock) {
93 struct timespec ts;
94 clock_gettime(CLOCK_MONOTONIC, &ts);
95 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
96 } else
97#endif
98 {
99 /* XXX: using gettimeofday leads to problems if the date
100 changes, so it should be avoided. */
101 return get_clock_realtime();
102 }
103}
104#endif
Paolo Bonzinidb1a4972010-03-10 11:38:55 +0100105
pbrook87ecb682007-11-17 17:14:51 +0000106void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
107void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
108
109/* ptimer.c */
110typedef struct ptimer_state ptimer_state;
111typedef void (*ptimer_cb)(void *opaque);
112
113ptimer_state *ptimer_init(QEMUBH *bh);
114void ptimer_set_period(ptimer_state *s, int64_t period);
115void ptimer_set_freq(ptimer_state *s, uint32_t freq);
116void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
117uint64_t ptimer_get_count(ptimer_state *s);
118void ptimer_set_count(ptimer_state *s, uint64_t count);
119void ptimer_run(ptimer_state *s, int oneshot);
120void ptimer_stop(ptimer_state *s);
121void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
122void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);
123
Blue Swirl29e922b2010-03-29 19:24:00 +0000124/* icount */
125int64_t qemu_icount_round(int64_t count);
126extern int64_t qemu_icount;
127extern int use_icount;
128extern int icount_time_shift;
129extern int64_t qemu_icount_bias;
130int64_t cpu_get_icount(void);
131
132/*******************************************/
133/* host CPU ticks (if available) */
134
135#if defined(_ARCH_PPC)
136
137static inline int64_t cpu_get_real_ticks(void)
138{
139 int64_t retval;
140#ifdef _ARCH_PPC64
141 /* This reads timebase in one 64bit go and includes Cell workaround from:
142 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
143 */
144 __asm__ __volatile__ ("mftb %0\n\t"
145 "cmpwi %0,0\n\t"
146 "beq- $-8"
147 : "=r" (retval));
148#else
149 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
150 unsigned long junk;
Alexander Graf4a9590f2010-04-03 11:37:26 +0200151 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
152 "mfspr %L0,268\n\t" /* mftb */
153 "mfspr %0,269\n\t" /* mftbu */
Blue Swirl29e922b2010-03-29 19:24:00 +0000154 "cmpw %0,%1\n\t"
155 "bne $-16"
156 : "=r" (retval), "=r" (junk));
157#endif
158 return retval;
159}
160
161#elif defined(__i386__)
162
163static inline int64_t cpu_get_real_ticks(void)
164{
165 int64_t val;
166 asm volatile ("rdtsc" : "=A" (val));
167 return val;
168}
169
170#elif defined(__x86_64__)
171
172static inline int64_t cpu_get_real_ticks(void)
173{
174 uint32_t low,high;
175 int64_t val;
176 asm volatile("rdtsc" : "=a" (low), "=d" (high));
177 val = high;
178 val <<= 32;
179 val |= low;
180 return val;
181}
182
183#elif defined(__hppa__)
184
185static inline int64_t cpu_get_real_ticks(void)
186{
187 int val;
188 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
189 return val;
190}
191
192#elif defined(__ia64)
193
194static inline int64_t cpu_get_real_ticks(void)
195{
196 int64_t val;
197 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
198 return val;
199}
200
201#elif defined(__s390__)
202
203static inline int64_t cpu_get_real_ticks(void)
204{
205 int64_t val;
206 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
207 return val;
208}
209
210#elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
211
212static inline int64_t cpu_get_real_ticks (void)
213{
214#if defined(_LP64)
215 uint64_t rval;
216 asm volatile("rd %%tick,%0" : "=r"(rval));
217 return rval;
218#else
219 union {
220 uint64_t i64;
221 struct {
222 uint32_t high;
223 uint32_t low;
224 } i32;
225 } rval;
226 asm volatile("rd %%tick,%1; srlx %1,32,%0"
227 : "=r"(rval.i32.high), "=r"(rval.i32.low));
228 return rval.i64;
229#endif
230}
231
232#elif defined(__mips__) && \
233 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
234/*
235 * binutils wants to use rdhwr only on mips32r2
236 * but as linux kernel emulate it, it's fine
237 * to use it.
238 *
239 */
240#define MIPS_RDHWR(rd, value) { \
241 __asm__ __volatile__ (".set push\n\t" \
242 ".set mips32r2\n\t" \
243 "rdhwr %0, "rd"\n\t" \
244 ".set pop" \
245 : "=r" (value)); \
246 }
247
248static inline int64_t cpu_get_real_ticks(void)
249{
250 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
251 uint32_t count;
252 static uint32_t cyc_per_count = 0;
253
254 if (!cyc_per_count) {
255 MIPS_RDHWR("$3", cyc_per_count);
256 }
257
258 MIPS_RDHWR("$2", count);
259 return (int64_t)(count * cyc_per_count);
260}
261
Richard Henderson14a60632010-04-12 16:19:26 -0700262#elif defined(__alpha__)
263
264static inline int64_t cpu_get_real_ticks(void)
265{
266 uint64_t cc;
267 uint32_t cur, ofs;
268
269 asm volatile("rpcc %0" : "=r"(cc));
270 cur = cc;
271 ofs = cc >> 32;
272 return cur - ofs;
273}
274
Blue Swirl29e922b2010-03-29 19:24:00 +0000275#else
276/* The host CPU doesn't have an easily accessible cycle counter.
277 Just return a monotonically increasing value. This will be
278 totally wrong, but hopefully better than nothing. */
279static inline int64_t cpu_get_real_ticks (void)
280{
281 static int64_t ticks = 0;
282 return ticks++;
283}
284#endif
285
286#ifdef NEED_CPU_H
287/* Deterministic execution requires that IO only be performed on the last
288 instruction of a TB so that interrupts take effect immediately. */
289static inline int can_do_io(CPUState *env)
290{
291 if (!use_icount)
292 return 1;
293
294 /* If not executing code then assume we are ok. */
295 if (!env->current_tb)
296 return 1;
297
298 return env->can_do_io != 0;
299}
300#endif
301
Richard Henderson2d8ebcf2010-04-17 16:25:10 +0000302#ifdef CONFIG_PROFILER
303static inline int64_t profile_getclock(void)
304{
305 return cpu_get_real_ticks();
306}
307
308extern int64_t qemu_time, qemu_time_start;
309extern int64_t tlb_flush_time;
310extern int64_t dev_time;
311#endif
312
pbrook87ecb682007-11-17 17:14:51 +0000313#endif