Statistics
| Branch: | Revision:

root / qemu-timer.h @ 0ce1b948

History | View | Annotate | Download (8.8 kB)

1
#ifndef QEMU_TIMER_H
2
#define QEMU_TIMER_H
3

    
4
#include "qemu-common.h"
5
#include <time.h>
6
#include <sys/time.h>
7

    
8
#ifdef _WIN32
9
#include <windows.h>
10
#include <mmsystem.h>
11
#endif
12

    
13
/* timers */
14

    
15
#define SCALE_MS 1000000
16
#define SCALE_US 1000
17
#define SCALE_NS 1
18

    
19
typedef struct QEMUClock QEMUClock;
20
typedef void QEMUTimerCB(void *opaque);
21

    
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;
27

    
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;
32

    
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;
39

    
40
int64_t qemu_get_clock(QEMUClock *clock);
41
int64_t qemu_get_clock_ns(QEMUClock *clock);
42
void qemu_clock_enable(QEMUClock *clock, int enabled);
43

    
44
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
45
void qemu_free_timer(QEMUTimer *ts);
46
void qemu_del_timer(QEMUTimer *ts);
47
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
48
int qemu_timer_pending(QEMUTimer *ts);
49
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
50

    
51
void qemu_run_all_timers(void);
52
int qemu_alarm_pending(void);
53
int64_t qemu_next_deadline(void);
54
void configure_alarms(char const *opt);
55
void configure_icount(const char *option);
56
int qemu_calculate_timeout(void);
57
void init_clocks(void);
58
int init_timer_alarm(void);
59
void quit_timers(void);
60

    
61
static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
62
                                           void *opaque)
63
{
64
    assert(clock != rt_clock);
65
    return qemu_new_timer(clock, cb, opaque);
66
}
67

    
68
static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
69
                                           void *opaque)
70
{
71
    assert(clock == rt_clock);
72
    return qemu_new_timer(clock, cb, opaque);
73
}
74

    
75
static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
76
{
77
    return qemu_get_clock_ns(clock) / SCALE_MS;
78
}
79

    
80
static inline int64_t get_ticks_per_sec(void)
81
{
82
    return 1000000000LL;
83
}
84

    
85
/* real time host monotonic timer */
86
static inline int64_t get_clock_realtime(void)
87
{
88
    struct timeval tv;
89

    
90
    gettimeofday(&tv, NULL);
91
    return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
92
}
93

    
94
/* Warning: don't insert tracepoints into these functions, they are
95
   also used by simpletrace backend and tracepoints would cause
96
   an infinite recursion! */
97
#ifdef _WIN32
98
extern int64_t clock_freq;
99

    
100
static inline int64_t get_clock(void)
101
{
102
    LARGE_INTEGER ti;
103
    QueryPerformanceCounter(&ti);
104
    return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
105
}
106

    
107
#else
108

    
109
extern int use_rt_clock;
110

    
111
static inline int64_t get_clock(void)
112
{
113
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
114
    || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
115
    if (use_rt_clock) {
116
        struct timespec ts;
117
        clock_gettime(CLOCK_MONOTONIC, &ts);
118
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
119
    } else
120
#endif
121
    {
122
        /* XXX: using gettimeofday leads to problems if the date
123
           changes, so it should be avoided. */
124
        return get_clock_realtime();
125
    }
126
}
127
#endif
128

    
129
void qemu_get_timer(QEMUFile *f, QEMUTimer *ts);
130
void qemu_put_timer(QEMUFile *f, QEMUTimer *ts);
131

    
132
/* ptimer.c */
133
typedef struct ptimer_state ptimer_state;
134
typedef void (*ptimer_cb)(void *opaque);
135

    
136
ptimer_state *ptimer_init(QEMUBH *bh);
137
void ptimer_set_period(ptimer_state *s, int64_t period);
138
void ptimer_set_freq(ptimer_state *s, uint32_t freq);
139
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
140
uint64_t ptimer_get_count(ptimer_state *s);
141
void ptimer_set_count(ptimer_state *s, uint64_t count);
142
void ptimer_run(ptimer_state *s, int oneshot);
143
void ptimer_stop(ptimer_state *s);
144
void qemu_put_ptimer(QEMUFile *f, ptimer_state *s);
145
void qemu_get_ptimer(QEMUFile *f, ptimer_state *s);
146

    
147
/* icount */
148
int64_t qemu_icount_round(int64_t count);
149
extern int64_t qemu_icount;
150
extern int use_icount;
151
extern int icount_time_shift;
152
extern int64_t qemu_icount_bias;
153
int64_t cpu_get_icount(void);
154

    
155
/*******************************************/
156
/* host CPU ticks (if available) */
157

    
158
#if defined(_ARCH_PPC)
159

    
160
static inline int64_t cpu_get_real_ticks(void)
161
{
162
    int64_t retval;
163
#ifdef _ARCH_PPC64
164
    /* This reads timebase in one 64bit go and includes Cell workaround from:
165
       http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
166
    */
167
    __asm__ __volatile__ ("mftb    %0\n\t"
168
                          "cmpwi   %0,0\n\t"
169
                          "beq-    $-8"
170
                          : "=r" (retval));
171
#else
172
    /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
173
    unsigned long junk;
174
    __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
175
                          "mfspr   %L0,268\n\t" /* mftb */
176
                          "mfspr   %0,269\n\t"  /* mftbu */
177
                          "cmpw    %0,%1\n\t"
178
                          "bne     $-16"
179
                          : "=r" (retval), "=r" (junk));
180
#endif
181
    return retval;
182
}
183

    
184
#elif defined(__i386__)
185

    
186
static inline int64_t cpu_get_real_ticks(void)
187
{
188
    int64_t val;
189
    asm volatile ("rdtsc" : "=A" (val));
190
    return val;
191
}
192

    
193
#elif defined(__x86_64__)
194

    
195
static inline int64_t cpu_get_real_ticks(void)
196
{
197
    uint32_t low,high;
198
    int64_t val;
199
    asm volatile("rdtsc" : "=a" (low), "=d" (high));
200
    val = high;
201
    val <<= 32;
202
    val |= low;
203
    return val;
204
}
205

    
206
#elif defined(__hppa__)
207

    
208
static inline int64_t cpu_get_real_ticks(void)
209
{
210
    int val;
211
    asm volatile ("mfctl %%cr16, %0" : "=r"(val));
212
    return val;
213
}
214

    
215
#elif defined(__ia64)
216

    
217
static inline int64_t cpu_get_real_ticks(void)
218
{
219
    int64_t val;
220
    asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
221
    return val;
222
}
223

    
224
#elif defined(__s390__)
225

    
226
static inline int64_t cpu_get_real_ticks(void)
227
{
228
    int64_t val;
229
    asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
230
    return val;
231
}
232

    
233
#elif defined(__sparc_v8plus__) || defined(__sparc_v8plusa__) || defined(__sparc_v9__)
234

    
235
static inline int64_t cpu_get_real_ticks (void)
236
{
237
#if defined(_LP64)
238
    uint64_t        rval;
239
    asm volatile("rd %%tick,%0" : "=r"(rval));
240
    return rval;
241
#else
242
    union {
243
        uint64_t i64;
244
        struct {
245
            uint32_t high;
246
            uint32_t low;
247
        }       i32;
248
    } rval;
249
    asm volatile("rd %%tick,%1; srlx %1,32,%0"
250
                 : "=r"(rval.i32.high), "=r"(rval.i32.low));
251
    return rval.i64;
252
#endif
253
}
254

    
255
#elif defined(__mips__) && \
256
    ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
257
/*
258
 * binutils wants to use rdhwr only on mips32r2
259
 * but as linux kernel emulate it, it's fine
260
 * to use it.
261
 *
262
 */
263
#define MIPS_RDHWR(rd, value) {                         \
264
        __asm__ __volatile__ (".set   push\n\t"         \
265
                              ".set mips32r2\n\t"       \
266
                              "rdhwr  %0, "rd"\n\t"     \
267
                              ".set   pop"              \
268
                              : "=r" (value));          \
269
    }
270

    
271
static inline int64_t cpu_get_real_ticks(void)
272
{
273
    /* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
274
    uint32_t count;
275
    static uint32_t cyc_per_count = 0;
276

    
277
    if (!cyc_per_count) {
278
        MIPS_RDHWR("$3", cyc_per_count);
279
    }
280

    
281
    MIPS_RDHWR("$2", count);
282
    return (int64_t)(count * cyc_per_count);
283
}
284

    
285
#elif defined(__alpha__)
286

    
287
static inline int64_t cpu_get_real_ticks(void)
288
{
289
    uint64_t cc;
290
    uint32_t cur, ofs;
291

    
292
    asm volatile("rpcc %0" : "=r"(cc));
293
    cur = cc;
294
    ofs = cc >> 32;
295
    return cur - ofs;
296
}
297

    
298
#else
299
/* The host CPU doesn't have an easily accessible cycle counter.
300
   Just return a monotonically increasing value.  This will be
301
   totally wrong, but hopefully better than nothing.  */
302
static inline int64_t cpu_get_real_ticks (void)
303
{
304
    static int64_t ticks = 0;
305
    return ticks++;
306
}
307
#endif
308

    
309
#ifdef NEED_CPU_H
310
/* Deterministic execution requires that IO only be performed on the last
311
   instruction of a TB so that interrupts take effect immediately.  */
312
static inline int can_do_io(CPUState *env)
313
{
314
    if (!use_icount)
315
        return 1;
316

    
317
    /* If not executing code then assume we are ok.  */
318
    if (!env->current_tb)
319
        return 1;
320

    
321
    return env->can_do_io != 0;
322
}
323
#endif
324

    
325
#ifdef CONFIG_PROFILER
326
static inline int64_t profile_getclock(void)
327
{
328
    return cpu_get_real_ticks();
329
}
330

    
331
extern int64_t qemu_time, qemu_time_start;
332
extern int64_t tlb_flush_time;
333
extern int64_t dev_time;
334
#endif
335

    
336
#endif