vmdk: vmdk_read_cid returns garbage if p_name is NULL
[qemu/ar7.git] / qemu-timer.h
blob67ca72e045cec2bd1d23e3d62e583507143c8761
1 #ifndef QEMU_TIMER_H
2 #define QEMU_TIMER_H
4 #include "qemu-common.h"
5 #include "main-loop.h"
6 #include "notify.h"
7 #include <time.h>
8 #include <sys/time.h>
10 #ifdef _WIN32
11 #include <windows.h>
12 #endif
14 /* timers */
16 #define SCALE_MS 1000000
17 #define SCALE_US 1000
18 #define SCALE_NS 1
20 typedef struct QEMUClock QEMUClock;
21 typedef void QEMUTimerCB(void *opaque);
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. */
27 extern QEMUClock *rt_clock;
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). */
32 extern QEMUClock *vm_clock;
34 /* 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. */
39 extern QEMUClock *host_clock;
41 int64_t qemu_get_clock_ns(QEMUClock *clock);
42 int64_t qemu_clock_has_timers(QEMUClock *clock);
43 int64_t qemu_clock_expired(QEMUClock *clock);
44 int64_t qemu_clock_deadline(QEMUClock *clock);
45 void qemu_clock_enable(QEMUClock *clock, int enabled);
46 void qemu_clock_warp(QEMUClock *clock);
48 void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
49 void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
50 Notifier *notifier);
52 QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
53 QEMUTimerCB *cb, void *opaque);
54 void qemu_free_timer(QEMUTimer *ts);
55 void qemu_del_timer(QEMUTimer *ts);
56 void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time);
57 void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
58 int qemu_timer_pending(QEMUTimer *ts);
59 int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
60 uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts);
62 void qemu_run_all_timers(void);
63 int qemu_alarm_pending(void);
64 void configure_alarms(char const *opt);
65 int qemu_calculate_timeout(void);
66 void init_clocks(void);
67 int init_timer_alarm(void);
69 int64_t cpu_get_ticks(void);
70 void cpu_enable_ticks(void);
71 void cpu_disable_ticks(void);
73 static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
74 void *opaque)
76 return qemu_new_timer(clock, SCALE_NS, cb, opaque);
79 static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
80 void *opaque)
82 return qemu_new_timer(clock, SCALE_MS, cb, opaque);
85 static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
87 return qemu_get_clock_ns(clock) / SCALE_MS;
90 static inline int64_t get_ticks_per_sec(void)
92 return 1000000000LL;
95 /* real time host monotonic timer */
96 static inline int64_t get_clock_realtime(void)
98 struct timeval tv;
100 gettimeofday(&tv, NULL);
101 return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
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
108 extern int64_t clock_freq;
110 static inline int64_t get_clock(void)
112 LARGE_INTEGER ti;
113 QueryPerformanceCounter(&ti);
114 return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
117 #else
119 extern int use_rt_clock;
121 static inline int64_t get_clock(void)
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
132 /* XXX: using gettimeofday leads to problems if the date
133 changes, so it should be avoided. */
134 return get_clock_realtime();
137 #endif
139 void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
140 void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
142 /* ptimer.c */
143 typedef struct ptimer_state ptimer_state;
144 typedef void (*ptimer_cb)(void *opaque);
146 ptimer_state *ptimer_init(QEMUBH *bh);
147 void ptimer_set_period(ptimer_state *s, int64_t period);
148 void ptimer_set_freq(ptimer_state *s, uint32_t freq);
149 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
150 uint64_t ptimer_get_count(ptimer_state *s);
151 void ptimer_set_count(ptimer_state *s, uint64_t count);
152 void ptimer_run(ptimer_state *s, int oneshot);
153 void ptimer_stop(ptimer_state *s);
155 /* icount */
156 int64_t cpu_get_icount(void);
157 int64_t cpu_get_clock(void);
159 /*******************************************/
160 /* host CPU ticks (if available) */
162 #if defined(_ARCH_PPC)
164 static inline int64_t cpu_get_real_ticks(void)
166 int64_t retval;
167 #ifdef _ARCH_PPC64
168 /* This reads timebase in one 64bit go and includes Cell workaround from:
169 http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
171 __asm__ __volatile__ ("mftb %0\n\t"
172 "cmpwi %0,0\n\t"
173 "beq- $-8"
174 : "=r" (retval));
175 #else
176 /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
177 unsigned long junk;
178 __asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
179 "mfspr %L0,268\n\t" /* mftb */
180 "mfspr %0,269\n\t" /* mftbu */
181 "cmpw %0,%1\n\t"
182 "bne $-16"
183 : "=r" (retval), "=r" (junk));
184 #endif
185 return retval;
188 #elif defined(__i386__)
190 static inline int64_t cpu_get_real_ticks(void)
192 int64_t val;
193 asm volatile ("rdtsc" : "=A" (val));
194 return val;
197 #elif defined(__x86_64__)
199 static inline int64_t cpu_get_real_ticks(void)
201 uint32_t low,high;
202 int64_t val;
203 asm volatile("rdtsc" : "=a" (low), "=d" (high));
204 val = high;
205 val <<= 32;
206 val |= low;
207 return val;
210 #elif defined(__hppa__)
212 static inline int64_t cpu_get_real_ticks(void)
214 int val;
215 asm volatile ("mfctl %%cr16, %0" : "=r"(val));
216 return val;
219 #elif defined(__ia64)
221 static inline int64_t cpu_get_real_ticks(void)
223 int64_t val;
224 asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
225 return val;
228 #elif defined(__s390__)
230 static inline int64_t cpu_get_real_ticks(void)
232 int64_t val;
233 asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
234 return val;
237 #elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
239 static inline int64_t cpu_get_real_ticks (void)
241 #if defined(_LP64)
242 uint64_t rval;
243 asm volatile("rd %%tick,%0" : "=r"(rval));
244 return rval;
245 #else
246 union {
247 uint64_t i64;
248 struct {
249 uint32_t high;
250 uint32_t low;
251 } i32;
252 } rval;
253 asm volatile("rd %%tick,%1; srlx %1,32,%0"
254 : "=r"(rval.i32.high), "=r"(rval.i32.low));
255 return rval.i64;
256 #endif
259 #elif defined(__mips__) && \
260 ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
262 * binutils wants to use rdhwr only on mips32r2
263 * but as linux kernel emulate it, it's fine
264 * to use it.
267 #define MIPS_RDHWR(rd, value) { \
268 __asm__ __volatile__ (".set push\n\t" \
269 ".set mips32r2\n\t" \
270 "rdhwr %0, "rd"\n\t" \
271 ".set pop" \
272 : "=r" (value)); \
275 static inline int64_t cpu_get_real_ticks(void)
277 /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
278 uint32_t count;
279 static uint32_t cyc_per_count = 0;
281 if (!cyc_per_count) {
282 MIPS_RDHWR("$3", cyc_per_count);
285 MIPS_RDHWR("$2", count);
286 return (int64_t)(count * cyc_per_count);
289 #elif defined(__alpha__)
291 static inline int64_t cpu_get_real_ticks(void)
293 uint64_t cc;
294 uint32_t cur, ofs;
296 asm volatile("rpcc %0" : "=r"(cc));
297 cur = cc;
298 ofs = cc >> 32;
299 return cur - ofs;
302 #else
303 /* The host CPU doesn't have an easily accessible cycle counter.
304 Just return a monotonically increasing value. This will be
305 totally wrong, but hopefully better than nothing. */
306 static inline int64_t cpu_get_real_ticks (void)
308 static int64_t ticks = 0;
309 return ticks++;
311 #endif
313 #ifdef CONFIG_PROFILER
314 static inline int64_t profile_getclock(void)
316 return cpu_get_real_ticks();
319 extern int64_t qemu_time, qemu_time_start;
320 extern int64_t tlb_flush_time;
321 extern int64_t dev_time;
322 #endif
324 #endif