[qemu.git] / qemu-timer.h

#ifndef QEMU_TIMER_H
#define QEMU_TIMER_H

#include "qemu-common.h"
#include "main-loop.h"
#include "notify.h"
#include <time.h>
#include <sys/time.h>

#ifdef _WIN32
#include <windows.h>
#endif

/* timers */

#define SCALE_MS 1000000
#define SCALE_US 1000
#define SCALE_NS 1

typedef struct QEMUClock QEMUClock;
typedef void QEMUTimerCB(void *opaque);

/* The real time clock should be used only for stuff which does not
   change the virtual machine state, as it is run even if the virtual
   machine is stopped. The real time clock has a frequency of 1000
   Hz. */
extern QEMUClock *rt_clock;

/* The virtual clock is only run during the emulation. It is stopped
   when the virtual machine is stopped. Virtual timers use a high
   precision clock, usually cpu cycles (use ticks_per_sec). */
extern QEMUClock *vm_clock;

/* The host clock should be use for device models that emulate accurate
   real time sources. It will continue to run when the virtual machine
   is suspended, and it will reflect system time changes the host may
   undergo (e.g. due to NTP). The host clock has the same precision as
   the virtual clock. */
extern QEMUClock *host_clock;

int64_t qemu_get_clock_ns(QEMUClock *clock);
int64_t qemu_clock_has_timers(QEMUClock *clock);
int64_t qemu_clock_expired(QEMUClock *clock);
int64_t qemu_clock_deadline(QEMUClock *clock);
void qemu_clock_enable(QEMUClock *clock, int enabled);
void qemu_clock_warp(QEMUClock *clock);

void qemu_register_clock_reset_notifier(QEMUClock *clock, Notifier *notifier);
void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
                                          Notifier *notifier);

QEMUTimer *qemu_new_timer(QEMUClock *clock, int scale,
                          QEMUTimerCB *cb, void *opaque);
void qemu_free_timer(QEMUTimer *ts);
void qemu_del_timer(QEMUTimer *ts);
void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time);
void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
int qemu_timer_pending(QEMUTimer *ts);
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts);

void qemu_run_all_timers(void);
int qemu_alarm_pending(void);
void configure_alarms(char const *opt);
int qemu_calculate_timeout(void);
void init_clocks(void);
int init_timer_alarm(void);

int64_t cpu_get_ticks(void);
void cpu_enable_ticks(void);
void cpu_disable_ticks(void);

static inline QEMUTimer *qemu_new_timer_ns(QEMUClock *clock, QEMUTimerCB *cb,
                                           void *opaque)
{
    return qemu_new_timer(clock, SCALE_NS, cb, opaque);
}

static inline QEMUTimer *qemu_new_timer_ms(QEMUClock *clock, QEMUTimerCB *cb,
                                           void *opaque)
{
    return qemu_new_timer(clock, SCALE_MS, cb, opaque);
}

static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
{
    return qemu_get_clock_ns(clock) / SCALE_MS;
}

static inline int64_t get_ticks_per_sec(void)
{
    return 1000000000LL;
}

/* real time host monotonic timer */
static inline int64_t get_clock_realtime(void)
{
    struct timeval tv;

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

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

static inline int64_t get_clock(void)
{
    LARGE_INTEGER ti;
    QueryPerformanceCounter(&ti);
    return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
}

#else

extern int use_rt_clock;

static inline int64_t get_clock(void)
{
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
    || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
    if (use_rt_clock) {
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        return ts.tv_sec * 1000000000LL + ts.tv_nsec;
    } else
#endif
    {
        /* XXX: using gettimeofday leads to problems if the date
           changes, so it should be avoided. */
        return get_clock_realtime();
    }
}
#endif

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

/* ptimer.c */
typedef struct ptimer_state ptimer_state;
typedef void (*ptimer_cb)(void *opaque);

ptimer_state *ptimer_init(QEMUBH *bh);
void ptimer_set_period(ptimer_state *s, int64_t period);
void ptimer_set_freq(ptimer_state *s, uint32_t freq);
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
uint64_t ptimer_get_count(ptimer_state *s);
void ptimer_set_count(ptimer_state *s, uint64_t count);
void ptimer_run(ptimer_state *s, int oneshot);
void ptimer_stop(ptimer_state *s);

/* icount */
int64_t cpu_get_icount(void);
int64_t cpu_get_clock(void);

/*******************************************/
/* host CPU ticks (if available) */

#if defined(_ARCH_PPC)

static inline int64_t cpu_get_real_ticks(void)
{
    int64_t retval;
#ifdef _ARCH_PPC64
    /* This reads timebase in one 64bit go and includes Cell workaround from:
       http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
    */
    __asm__ __volatile__ ("mftb    %0\n\t"
                          "cmpwi   %0,0\n\t"
                          "beq-    $-8"
                          : "=r" (retval));
#else
    /* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
    unsigned long junk;
    __asm__ __volatile__ ("mfspr   %1,269\n\t"  /* mftbu */
                          "mfspr   %L0,268\n\t" /* mftb */
                          "mfspr   %0,269\n\t"  /* mftbu */
                          "cmpw    %0,%1\n\t"
                          "bne     $-16"
                          : "=r" (retval), "=r" (junk));
#endif
    return retval;
}

#elif defined(__i386__)

static inline int64_t cpu_get_real_ticks(void)
{
    int64_t val;
    asm volatile ("rdtsc" : "=A" (val));
    return val;
}

#elif defined(__x86_64__)

static inline int64_t cpu_get_real_ticks(void)
{
    uint32_t low,high;
    int64_t val;
    asm volatile("rdtsc" : "=a" (low), "=d" (high));
    val = high;
    val <<= 32;
    val |= low;
    return val;
}

#elif defined(__hppa__)

static inline int64_t cpu_get_real_ticks(void)
{
    int val;
    asm volatile ("mfctl %%cr16, %0" : "=r"(val));
    return val;
}

#elif defined(__ia64)

static inline int64_t cpu_get_real_ticks(void)
{
    int64_t val;
    asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
    return val;
}

#elif defined(__s390__)

static inline int64_t cpu_get_real_ticks(void)
{
    int64_t val;
    asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
    return val;
}

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

static inline int64_t cpu_get_real_ticks (void)
{
#if defined(_LP64)
    uint64_t        rval;
    asm volatile("rd %%tick,%0" : "=r"(rval));
    return rval;
#else
    union {
        uint64_t i64;
        struct {
            uint32_t high;
            uint32_t low;
        }       i32;
    } rval;
    asm volatile("rd %%tick,%1; srlx %1,32,%0"
                 : "=r"(rval.i32.high), "=r"(rval.i32.low));
    return rval.i64;
#endif
}

#elif defined(__mips__) && \
    ((defined(__mips_isa_rev) && __mips_isa_rev >= 2) || defined(__linux__))
/*
 * binutils wants to use rdhwr only on mips32r2
 * but as linux kernel emulate it, it's fine
 * to use it.
 *
 */
#define MIPS_RDHWR(rd, value) {                         \
        __asm__ __volatile__ (".set   push\n\t"         \
                              ".set mips32r2\n\t"       \
                              "rdhwr  %0, "rd"\n\t"     \
                              ".set   pop"              \
                              : "=r" (value));          \
    }

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

    if (!cyc_per_count) {
        MIPS_RDHWR("$3", cyc_per_count);
    }

    MIPS_RDHWR("$2", count);
    return (int64_t)(count * cyc_per_count);
}

#elif defined(__alpha__)

static inline int64_t cpu_get_real_ticks(void)
{
    uint64_t cc;
    uint32_t cur, ofs;

    asm volatile("rpcc %0" : "=r"(cc));
    cur = cc;
    ofs = cc >> 32;
    return cur - ofs;
}

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

#ifdef CONFIG_PROFILER
static inline int64_t profile_getclock(void)
{
    return cpu_get_real_ticks();
}

extern int64_t qemu_time, qemu_time_start;
extern int64_t tlb_flush_time;
extern int64_t dev_time;
#endif

#endif
Commit	Line	Data
87ecb68b PB	1	#ifndef QEMU_TIMER_H
	2	#define QEMU_TIMER_H
	3
29e922b6	4	#include "qemu-common.h"
44a9b356	5	#include "main-loop.h"
691a0c9c	6	#include "notify.h"
c57c846a BS	7	#include <time.h>
	8	#include <sys/time.h>
	9
	10	#ifdef _WIN32
	11	#include <windows.h>
c57c846a	12	#endif
29e922b6	13
87ecb68b PB	14	/* timers */
87ecb68b PB	15
0ce1b948 PB	16	#define SCALE_MS 1000000
	17	#define SCALE_US 1000
	18	#define SCALE_NS 1
	19
87ecb68b PB	20	typedef struct QEMUClock QEMUClock;
	21	typedef void QEMUTimerCB(void *opaque);
	22
	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;
	28
	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;
	33
21d5d12b JK	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;
	40
41c872b6	41	int64_t qemu_get_clock_ns(QEMUClock *clock);
dc2dfcf0 PB	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);
db1a4972	45	void qemu_clock_enable(QEMUClock *clock, int enabled);
ab33fcda	46	void qemu_clock_warp(QEMUClock *clock);
87ecb68b	47
691a0c9c JK	48	void qemu_register_clock_reset_notifier(QEMUClock clock, Notifier notifier);
	49	void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
	50	Notifier *notifier);
	51
4a998740 PB	52	QEMUTimer qemu_new_timer(QEMUClock clock, int scale,
4a998740 PB	53	QEMUTimerCB cb, void opaque);
87ecb68b PB	54	void qemu_free_timer(QEMUTimer *ts);
87ecb68b PB	55	void qemu_del_timer(QEMUTimer *ts);
2ff68d07	56	void qemu_mod_timer_ns(QEMUTimer *ts, int64_t expire_time);
87ecb68b PB	57	void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
87ecb68b PB	58	int qemu_timer_pending(QEMUTimer *ts);
2430ffe4	59	int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
2ff68d07	60	uint64_t qemu_timer_expire_time_ns(QEMUTimer *ts);
87ecb68b	61
db1a4972 PB	62	void qemu_run_all_timers(void);
db1a4972 PB	63	int qemu_alarm_pending(void);
db1a4972	64	void configure_alarms(char const *opt);
db1a4972 PB	65	int qemu_calculate_timeout(void);
	66	void init_clocks(void);
	67	int init_timer_alarm(void);
db1a4972	68
70c3b557 BS	69	int64_t cpu_get_ticks(void);
	70	void cpu_enable_ticks(void);
	71	void cpu_disable_ticks(void);
	72
0ce1b948 PB	73	static inline QEMUTimer qemu_new_timer_ns(QEMUClock clock, QEMUTimerCB *cb,
	74	void *opaque)
	75	{
4a998740	76	return qemu_new_timer(clock, SCALE_NS, cb, opaque);
0ce1b948 PB	77	}
	78
	79	static inline QEMUTimer qemu_new_timer_ms(QEMUClock clock, QEMUTimerCB *cb,
	80	void *opaque)
	81	{
4a998740	82	return qemu_new_timer(clock, SCALE_MS, cb, opaque);
0ce1b948 PB	83	}
	84
	85	static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
	86	{
	87	return qemu_get_clock_ns(clock) / SCALE_MS;
	88	}
	89
274dfed8 AL	90	static inline int64_t get_ticks_per_sec(void)
	91	{
	92	return 1000000000LL;
	93	}
87ecb68b	94
c57c846a BS	95	/* real time host monotonic timer */
	96	static inline int64_t get_clock_realtime(void)
	97	{
	98	struct timeval tv;
	99
	100	gettimeofday(&tv, NULL);
	101	return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
	102	}
	103
	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;
	109
	110	static inline int64_t get_clock(void)
	111	{
	112	LARGE_INTEGER ti;
	113	QueryPerformanceCounter(&ti);
	114	return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
	115	}
	116
	117	#else
	118
	119	extern int use_rt_clock;
	120
	121	static inline int64_t get_clock(void)
	122	{
	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
	131	{
	132	/* XXX: using gettimeofday leads to problems if the date
	133	changes, so it should be avoided. */
	134	return get_clock_realtime();
	135	}
	136	}
	137	#endif
db1a4972	138
87ecb68b PB	139	void qemu_get_timer(QEMUFile f, QEMUTimer ts);
	140	void qemu_put_timer(QEMUFile f, QEMUTimer ts);
	141
	142	/* ptimer.c */
	143	typedef struct ptimer_state ptimer_state;
	144	typedef void (ptimer_cb)(void opaque);
	145
	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);
87ecb68b	154
29e922b6	155	/* icount */
29e922b6	156	int64_t cpu_get_icount(void);
946fb27c	157	int64_t cpu_get_clock(void);
29e922b6 BS	158
	159	/*******************************************/
	160	/* host CPU ticks (if available) */
	161
	162	#if defined(_ARCH_PPC)
	163
	164	static inline int64_t cpu_get_real_ticks(void)
	165	{
	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
	170	*/
	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;
4a9590f3 AG	178	__asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
	179	"mfspr %L0,268\n\t" /* mftb */
	180	"mfspr %0,269\n\t" /* mftbu */
29e922b6 BS	181	"cmpw %0,%1\n\t"
	182	"bne $-16"
	183	: "=r" (retval), "=r" (junk));
	184	#endif
	185	return retval;
	186	}
	187
	188	#elif defined(__i386__)
	189
	190	static inline int64_t cpu_get_real_ticks(void)
	191	{
	192	int64_t val;
	193	asm volatile ("rdtsc" : "=A" (val));
	194	return val;
	195	}
	196
	197	#elif defined(__x86_64__)
	198
	199	static inline int64_t cpu_get_real_ticks(void)
	200	{
	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;
	208	}
	209
	210	#elif defined(__hppa__)
	211
	212	static inline int64_t cpu_get_real_ticks(void)
	213	{
	214	int val;
	215	asm volatile ("mfctl %%cr16, %0" : "=r"(val));
	216	return val;
	217	}
	218
	219	#elif defined(__ia64)
	220
	221	static inline int64_t cpu_get_real_ticks(void)
	222	{
	223	int64_t val;
	224	asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
	225	return val;
	226	}
	227
	228	#elif defined(__s390__)
	229
	230	static inline int64_t cpu_get_real_ticks(void)
	231	{
	232	int64_t val;
	233	asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
	234	return val;
	235	}
	236
	237	#elif defined(__sparc_v8plus__) \|\| defined(__sparc_v8plusa__) \|\| defined(__sparc_v9__)
	238
	239	static inline int64_t cpu_get_real_ticks (void)
	240	{
	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
257	}
258
259	#elif defined(__mips__) && \
260	((defined(__mips_isa_rev) && __mips_isa_rev >= 2) \|\| defined(__linux__))
261	/*
262	* binutils wants to use rdhwr only on mips32r2
263	* but as linux kernel emulate it, it's fine
264	* to use it.
265	*
266	*/
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)); \
273	}
274
275	static inline int64_t cpu_get_real_ticks(void)
276	{
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;
280
281	if (!cyc_per_count) {
282	MIPS_RDHWR("$3", cyc_per_count);
283	}
284
285	MIPS_RDHWR("$2", count);
286	return (int64_t)(count * cyc_per_count);
287	}
288
14a6063a RH	289	#elif defined(__alpha__)
	290
	291	static inline int64_t cpu_get_real_ticks(void)
	292	{
	293	uint64_t cc;
	294	uint32_t cur, ofs;
	295
	296	asm volatile("rpcc %0" : "=r"(cc));
	297	cur = cc;
	298	ofs = cc >> 32;
	299	return cur - ofs;
	300	}
	301
29e922b6 BS	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)
	307	{
	308	static int64_t ticks = 0;
	309	return ticks++;
	310	}
	311	#endif
	312
2d8ebcf9 RH	313	#ifdef CONFIG_PROFILER
	314	static inline int64_t profile_getclock(void)
	315	{
	316	return cpu_get_real_ticks();
	317	}
	318
	319	extern int64_t qemu_time, qemu_time_start;
	320	extern int64_t tlb_flush_time;
	321	extern int64_t dev_time;
	322	#endif
	323
87ecb68b	324	#endif