Statistics
| Branch: | Revision:

root / qemu-timer.h @ c57c846a

History | View | Annotate | Download (8.7 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
typedef struct QEMUClock QEMUClock;
16
typedef 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. */
22
extern 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). */
27
extern QEMUClock *vm_clock;
28

    
29
/* 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. */
34
extern QEMUClock *host_clock;
35

    
36
int64_t qemu_get_clock(QEMUClock *clock);
37
int64_t qemu_get_clock_ns(QEMUClock *clock);
38
void qemu_clock_enable(QEMUClock *clock, int enabled);
39

    
40
QEMUTimer *qemu_new_timer(QEMUClock *clock, QEMUTimerCB *cb, void *opaque);
41
void qemu_free_timer(QEMUTimer *ts);
42
void qemu_del_timer(QEMUTimer *ts);
43
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
44
int qemu_timer_pending(QEMUTimer *ts);
45
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
46

    
47
void qemu_run_all_timers(void);
48
int qemu_alarm_pending(void);
49
int64_t qemu_next_deadline(void);
50
void configure_alarms(char const *opt);
51
void configure_icount(const char *option);
52
int qemu_calculate_timeout(void);
53
void init_clocks(void);
54
int init_timer_alarm(void);
55
void quit_timers(void);
56

    
57
static inline int64_t get_ticks_per_sec(void)
58
{
59
    return 1000000000LL;
60
}
61

    
62
/* compute with 96 bit intermediate result: (a*b)/c */
63
static inline uint64_t muldiv64(uint64_t a, uint32_t b, uint32_t c)
64
{
65
    union {
66
        uint64_t ll;
67
        struct {
68
#ifdef HOST_WORDS_BIGENDIAN
69
            uint32_t high, low;
70
#else
71
            uint32_t low, high;
72
#endif
73
        } l;
74
    } u, res;
75
    uint64_t rl, rh;
76

    
77
    u.ll = a;
78
    rl = (uint64_t)u.l.low * (uint64_t)b;
79
    rh = (uint64_t)u.l.high * (uint64_t)b;
80
    rh += (rl >> 32);
81
    res.l.high = rh / c;
82
    res.l.low = (((rh % c) << 32) + (rl & 0xffffffff)) / c;
83
    return res.ll;
84
}
85

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

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

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

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

    
108
#else
109

    
110
extern int use_rt_clock;
111

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

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

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

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

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

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

    
159
#if defined(_ARCH_PPC)
160

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

    
185
#elif defined(__i386__)
186

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

    
194
#elif defined(__x86_64__)
195

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

    
207
#elif defined(__hppa__)
208

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

    
216
#elif defined(__ia64)
217

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

    
225
#elif defined(__s390__)
226

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

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

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

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

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

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

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

    
286
#elif defined(__alpha__)
287

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

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

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

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

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

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

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

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

    
337
#endif