[qemu.git] / qemu-timer.h

#ifndef QEMU_TIMER_H
#define QEMU_TIMER_H

#include "qemu-common.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);
void qemu_clock_enable(QEMUClock *clock, int enabled);
void qemu_clock_warp(QEMUClock *clock);

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(QEMUTimer *ts, int64_t expire_time);
int qemu_timer_pending(QEMUTimer *ts);
int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);

void qemu_run_all_timers(void);
int qemu_alarm_pending(void);
int64_t qemu_next_icount_deadline(void);
void configure_alarms(char const *opt);
void configure_icount(const char *option);
int qemu_calculate_timeout(void);
void init_clocks(void);
int init_timer_alarm(void);
void quit_timers(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 qemu_icount_round(int64_t count);
extern int64_t qemu_icount;
extern int use_icount;
extern int icount_time_shift;
extern int64_t qemu_icount_bias;
int64_t cpu_get_icount(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 NEED_CPU_H
/* Deterministic execution requires that IO only be performed on the last
   instruction of a TB so that interrupts take effect immediately.  */
static inline int can_do_io(CPUState *env)
{
    if (!use_icount)
        return 1;

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

    return env->can_do_io != 0;
}
#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"
c57c846a BS	5	#include <time.h>
	6	#include <sys/time.h>
	7
	8	#ifdef _WIN32
	9	#include <windows.h>
c57c846a	10	#endif
29e922b6	11
87ecb68b PB	12	/* timers */
87ecb68b PB	13
0ce1b948 PB	14	#define SCALE_MS 1000000
	15	#define SCALE_US 1000
	16	#define SCALE_NS 1
	17
87ecb68b PB	18	typedef struct QEMUClock QEMUClock;
	19	typedef void QEMUTimerCB(void *opaque);
	20
	21	/* The real time clock should be used only for stuff which does not
	22	change the virtual machine state, as it is run even if the virtual
	23	machine is stopped. The real time clock has a frequency of 1000
	24	Hz. */
	25	extern QEMUClock *rt_clock;
	26
	27	/* The virtual clock is only run during the emulation. It is stopped
	28	when the virtual machine is stopped. Virtual timers use a high
	29	precision clock, usually cpu cycles (use ticks_per_sec). */
	30	extern QEMUClock *vm_clock;
	31
21d5d12b JK	32	/* The host clock should be use for device models that emulate accurate
	33	real time sources. It will continue to run when the virtual machine
	34	is suspended, and it will reflect system time changes the host may
	35	undergo (e.g. due to NTP). The host clock has the same precision as
	36	the virtual clock. */
	37	extern QEMUClock *host_clock;
	38
41c872b6	39	int64_t qemu_get_clock_ns(QEMUClock *clock);
db1a4972	40	void qemu_clock_enable(QEMUClock *clock, int enabled);
ab33fcda	41	void qemu_clock_warp(QEMUClock *clock);
87ecb68b	42
4a998740 PB	43	QEMUTimer qemu_new_timer(QEMUClock clock, int scale,
4a998740 PB	44	QEMUTimerCB cb, void opaque);
87ecb68b PB	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);
2430ffe4	49	int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
87ecb68b	50
db1a4972 PB	51	void qemu_run_all_timers(void);
db1a4972 PB	52	int qemu_alarm_pending(void);
cb842c90	53	int64_t qemu_next_icount_deadline(void);
db1a4972 PB	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
70c3b557 BS	61	int64_t cpu_get_ticks(void);
	62	void cpu_enable_ticks(void);
	63	void cpu_disable_ticks(void);
	64
0ce1b948 PB	65	static inline QEMUTimer qemu_new_timer_ns(QEMUClock clock, QEMUTimerCB *cb,
	66	void *opaque)
	67	{
4a998740	68	return qemu_new_timer(clock, SCALE_NS, cb, opaque);
0ce1b948 PB	69	}
	70
	71	static inline QEMUTimer qemu_new_timer_ms(QEMUClock clock, QEMUTimerCB *cb,
	72	void *opaque)
	73	{
4a998740	74	return qemu_new_timer(clock, SCALE_MS, cb, opaque);
0ce1b948 PB	75	}
	76
	77	static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
	78	{
	79	return qemu_get_clock_ns(clock) / SCALE_MS;
	80	}
	81
274dfed8 AL	82	static inline int64_t get_ticks_per_sec(void)
	83	{
	84	return 1000000000LL;
	85	}
87ecb68b	86
c57c846a BS	87	/* real time host monotonic timer */
	88	static inline int64_t get_clock_realtime(void)
	89	{
	90	struct timeval tv;
	91
	92	gettimeofday(&tv, NULL);
	93	return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
	94	}
	95
	96	/* Warning: don't insert tracepoints into these functions, they are
	97	also used by simpletrace backend and tracepoints would cause
	98	an infinite recursion! */
	99	#ifdef _WIN32
	100	extern int64_t clock_freq;
	101
	102	static inline int64_t get_clock(void)
	103	{
	104	LARGE_INTEGER ti;
	105	QueryPerformanceCounter(&ti);
	106	return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
	107	}
	108
	109	#else
	110
	111	extern int use_rt_clock;
	112
	113	static inline int64_t get_clock(void)
	114	{
	115	#if defined(__linux__) \|\| (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
	116	\|\| defined(__DragonFly__) \|\| defined(__FreeBSD_kernel__)
	117	if (use_rt_clock) {
	118	struct timespec ts;
	119	clock_gettime(CLOCK_MONOTONIC, &ts);
	120	return ts.tv_sec * 1000000000LL + ts.tv_nsec;
	121	} else
	122	#endif
	123	{
	124	/* XXX: using gettimeofday leads to problems if the date
	125	changes, so it should be avoided. */
	126	return get_clock_realtime();
	127	}
	128	}
	129	#endif
db1a4972	130
87ecb68b PB	131	void qemu_get_timer(QEMUFile f, QEMUTimer ts);
	132	void qemu_put_timer(QEMUFile f, QEMUTimer ts);
	133
	134	/* ptimer.c */
	135	typedef struct ptimer_state ptimer_state;
	136	typedef void (ptimer_cb)(void opaque);
	137
	138	ptimer_state ptimer_init(QEMUBH bh);
	139	void ptimer_set_period(ptimer_state *s, int64_t period);
	140	void ptimer_set_freq(ptimer_state *s, uint32_t freq);
	141	void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
	142	uint64_t ptimer_get_count(ptimer_state *s);
	143	void ptimer_set_count(ptimer_state *s, uint64_t count);
	144	void ptimer_run(ptimer_state *s, int oneshot);
	145	void ptimer_stop(ptimer_state *s);
87ecb68b	146
29e922b6 BS	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;
4a9590f3 AG	174	__asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
	175	"mfspr %L0,268\n\t" /* mftb */
	176	"mfspr %0,269\n\t" /* mftbu */
29e922b6 BS	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
14a6063a RH	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
29e922b6 BS	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
2d8ebcf9 RH	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
87ecb68b	336	#endif