Merge remote-tracking branch 'stefanha/trivial-patches' into staging
[qemu.git] / qemu-timer.h
blob0a434698475906e780eb5c27dcc0d7d51a724a44
1 #ifndef QEMU_TIMER_H
2 #define QEMU_TIMER_H
4 #include "qemu-common.h"
5 #include "notify.h"
6 #include <time.h>
7 #include <sys/time.h>
9 #ifdef _WIN32
10 #include <windows.h>
11 #endif
13 /* timers */
15 #define SCALE_MS 1000000
16 #define SCALE_US 1000
17 #define SCALE_NS 1
19 typedef struct QEMUClock QEMUClock;
20 typedef void QEMUTimerCB(void *opaque);
22 /* The real time clock should be used only for stuff which does not
23 change the virtual machine state, as it is run even if the virtual
24 machine is stopped. The real time clock has a frequency of 1000
25 Hz. */
26 extern QEMUClock *rt_clock;
28 /* The virtual clock is only run during the emulation. It is stopped
29 when the virtual machine is stopped. Virtual timers use a high
30 precision clock, usually cpu cycles (use ticks_per_sec). */
31 extern QEMUClock *vm_clock;
33 /* The host clock should be use for device models that emulate accurate
34 real time sources. It will continue to run when the virtual machine
35 is suspended, and it will reflect system time changes the host may
36 undergo (e.g. due to NTP). The host clock has the same precision as
37 the virtual clock. */
38 extern QEMUClock *host_clock;
40 int64_t qemu_get_clock_ns(QEMUClock *clock);
41 void qemu_clock_enable(QEMUClock *clock, int enabled);
42 void qemu_clock_warp(QEMUClock *clock);
44 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
45 void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
46 Notifier *notifier);
48 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
49 QEMUTimerCB *cb, void *opaque);
50 void qemu_free_timer(QEMUTimer *ts);
51 void qemu_del_timer(QEMUTimer *ts);
52 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
53 int qemu_timer_pending(QEMUTimer *ts);
54 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
56 void qemu_run_all_timers(void);
57 int qemu_alarm_pending(void);
58 int64_t qemu_next_icount_deadline(void);
59 void configure_alarms(char const *opt);
60 void configure_icount(const char *option);
61 int qemu_calculate_timeout(void);
62 void init_clocks(void);
63 int init_timer_alarm(void);
64 void quit_timers(void);
66 int64_t cpu_get_ticks(void);
67 void cpu_enable_ticks(void);
68 void cpu_disable_ticks(void);
70 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
71 void *opaque)
73 return qemu_new_timer(clock, SCALE_NS, cb, opaque);
76 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
77 void *opaque)
79 return qemu_new_timer(clock, SCALE_MS, cb, opaque);
82 static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
84 return qemu_get_clock_ns(clock) / SCALE_MS;
87 static inline int64_t get_ticks_per_sec(void)
89 return 1000000000LL;
92 /* real time host monotonic timer */
93 static inline int64_t get_clock_realtime(void)
95 struct timeval tv;
97 gettimeofday(&tv, NULL);
98 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
101 /* Warning: don't insert tracepoints into these functions, they are
102 also used by simpletrace backend and tracepoints would cause
103 an infinite recursion! */
104 #ifdef _WIN32
105 extern int64_t clock_freq;
107 static inline int64_t get_clock(void)
109 LARGE_INTEGER ti;
110 QueryPerformanceCounter(&ti);
111 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
114 #else
116 extern int use_rt_clock;
118 static inline int64_t get_clock(void)
120 #if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
121 || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
122 if (use_rt_clock) {
123 struct timespec ts;
124 clock_gettime(CLOCK_MONOTONIC, &ts);
125 return ts.tv_sec * 1000000000LL + ts.tv_nsec;
126 } else
127 #endif
129 /* XXX: using gettimeofday leads to problems if the date
130 changes, so it should be avoided. */
131 return get_clock_realtime();
134 #endif
136 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
137 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
139 /* ptimer.c */
140 typedef struct ptimer_state ptimer_state;
141 typedef void (*ptimer_cb)(void *opaque);
143 ptimer_state *ptimer_init(QEMUBH *bh);
144 void ptimer_set_period(ptimer_state *s, int64_t period);
145 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
146 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
147 uint64_t ptimer_get_count(ptimer_state *s);
148 void ptimer_set_count(ptimer_state *s, uint64_t count);
149 void ptimer_run(ptimer_state *s, int oneshot);
150 void ptimer_stop(ptimer_state *s);
152 /* icount */
153 int64_t qemu_icount_round(int64_t count);
154 extern int64_t qemu_icount;
155 extern int use_icount;
156 extern int icount_time_shift;
157 extern int64_t qemu_icount_bias;
158 int64_t cpu_get_icount(void);
160 /*******************************************/
161 /* host CPU ticks (if available) */
163 #if defined(_ARCH_PPC)
165 static inline int64_t cpu_get_real_ticks(void)
167 int64_t retval;
168 #ifdef _ARCH_PPC64
169 /* This reads timebase in one 64bit go and includes Cell workaround from:
170 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
172 __asm__ __volatile__ ("mftb %0\n\t"
173 "cmpwi %0,0\n\t"
174 "beq- $-8"
175 : "=r" (retval));
176 #else
177 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
178 unsigned long junk;
179 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
180 "mfspr %L0,268\n\t" /* mftb */
181 "mfspr %0,269\n\t" /* mftbu */
182 "cmpw %0,%1\n\t"
183 "bne $-16"
184 : "=r" (retval), "=r" (junk));
185 #endif
186 return retval;
189 #elif defined(__i386__)
191 static inline int64_t cpu_get_real_ticks(void)
193 int64_t val;
194 asm volatile ("rdtsc" : "=A" (val));
195 return val;
198 #elif defined(__x86_64__)
200 static inline int64_t cpu_get_real_ticks(void)
202 uint32_t low,high;
203 int64_t val;
204 asm volatile("rdtsc" : "=a" (low), "=d" (high));
205 val = high;
206 val <<= 32;
207 val |= low;
208 return val;
211 #elif defined(__hppa__)
213 static inline int64_t cpu_get_real_ticks(void)
215 int val;
216 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
217 return val;
220 #elif defined(__ia64)
222 static inline int64_t cpu_get_real_ticks(void)
224 int64_t val;
225 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
226 return val;
229 #elif defined(__s390__)
231 static inline int64_t cpu_get_real_ticks(void)
233 int64_t val;
234 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
235 return val;
238 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
240 static inline int64_t cpu_get_real_ticks (void)
242 #if defined(_LP64)
243 uint64_t rval;
244 asm volatile("rd %%tick,%0" : "=r"(rval));
245 return rval;
246 #else
247 union {
248 uint64_t i64;
249 struct {
250 uint32_t high;
251 uint32_t low;
252 } i32;
253 } rval;
254 asm volatile("rd %%tick,%1; srlx %1,32,%0"
255 : "=r"(rval.i32.high), "=r"(rval.i32.low));
256 return rval.i64;
257 #endif
260 #elif defined(__mips__) && \
261 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
263 * binutils wants to use rdhwr only on mips32r2
264 * but as linux kernel emulate it, it's fine
265 * to use it.
268 #define MIPS_RDHWR(rd, value) { \
269 __asm__ __volatile__ (".set push\n\t" \
270 ".set mips32r2\n\t" \
271 "rdhwr %0, "rd"\n\t" \
272 ".set pop" \
273 : "=r" (value)); \
276 static inline int64_t cpu_get_real_ticks(void)
278 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
279 uint32_t count;
280 static uint32_t cyc_per_count = 0;
282 if (!cyc_per_count) {
283 MIPS_RDHWR("$3", cyc_per_count);
286 MIPS_RDHWR("$2", count);
287 return (int64_t)(count * cyc_per_count);
290 #elif defined(__alpha__)
292 static inline int64_t cpu_get_real_ticks(void)
294 uint64_t cc;
295 uint32_t cur, ofs;
297 asm volatile("rpcc %0" : "=r"(cc));
298 cur = cc;
299 ofs = cc >> 32;
300 return cur - ofs;
303 #else
304 /* The host CPU doesn't have an easily accessible cycle counter.
305 Just return a monotonically increasing value. This will be
306 totally wrong, but hopefully better than nothing. */
307 static inline int64_t cpu_get_real_ticks (void)
309 static int64_t ticks = 0;
310 return ticks++;
312 #endif
314 #ifdef NEED_CPU_H
315 /* Deterministic execution requires that IO only be performed on the last
316 instruction of a TB so that interrupts take effect immediately. */
317 static inline int can_do_io(CPUState *env)
319 if (!use_icount)
320 return 1;
322 /* If not executing code then assume we are ok. */
323 if (!env->current_tb)
324 return 1;
326 return env->can_do_io != 0;
328 #endif
330 #ifdef CONFIG_PROFILER
331 static inline int64_t profile_getclock(void)
333 return cpu_get_real_ticks();
336 extern int64_t qemu_time, qemu_time_start;
337 extern int64_t tlb_flush_time;
338 extern int64_t dev_time;
339 #endif
341 #endif