[qemu.git] / qemu-timer.h

#ifndef QEMU_TIMER_H
#define QEMU_TIMER_H

#include "qemu-common.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);
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(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
	1	#ifndef QEMU_TIMER_H
	2	#define QEMU_TIMER_H
	3
	4	#include "qemu-common.h"
	5	#include "notify.h"
	6	#include <time.h>
	7	#include <sys/time.h>
	8
	9	#ifdef _WIN32
	10	#include <windows.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_ns(QEMUClock *clock);
	41	void qemu_clock_enable(QEMUClock *clock, int enabled);
	42	void qemu_clock_warp(QEMUClock *clock);
	43
	44	void qemu_register_clock_reset_notifier(QEMUClock clock, Notifier notifier);
	45	void qemu_unregister_clock_reset_notifier(QEMUClock *clock,
	46	Notifier *notifier);
	47
	48	QEMUTimer qemu_new_timer(QEMUClock clock, int scale,
	49	QEMUTimerCB cb, void opaque);
	50	void qemu_free_timer(QEMUTimer *ts);
	51	void qemu_del_timer(QEMUTimer *ts);
	52	void qemu_mod_timer(QEMUTimer *ts, int64_t expire_time);
	53	int qemu_timer_pending(QEMUTimer *ts);
	54	int qemu_timer_expired(QEMUTimer *timer_head, int64_t current_time);
	55
	56	void qemu_run_all_timers(void);
	57	int qemu_alarm_pending(void);
	58	int64_t qemu_next_icount_deadline(void);
	59	void configure_alarms(char const *opt);
	60	void configure_icount(const char *option);
	61	int qemu_calculate_timeout(void);
	62	void init_clocks(void);
	63	int init_timer_alarm(void);
	64	void quit_timers(void);
	65
	66	int64_t cpu_get_ticks(void);
	67	void cpu_enable_ticks(void);
	68	void cpu_disable_ticks(void);
	69
	70	static inline QEMUTimer qemu_new_timer_ns(QEMUClock clock, QEMUTimerCB *cb,
	71	void *opaque)
	72	{
	73	return qemu_new_timer(clock, SCALE_NS, cb, opaque);
	74	}
	75
	76	static inline QEMUTimer qemu_new_timer_ms(QEMUClock clock, QEMUTimerCB *cb,
	77	void *opaque)
	78	{
	79	return qemu_new_timer(clock, SCALE_MS, cb, opaque);
	80	}
	81
	82	static inline int64_t qemu_get_clock_ms(QEMUClock *clock)
	83	{
	84	return qemu_get_clock_ns(clock) / SCALE_MS;
	85	}
	86
	87	static inline int64_t get_ticks_per_sec(void)
	88	{
	89	return 1000000000LL;
	90	}
	91
	92	/* real time host monotonic timer */
	93	static inline int64_t get_clock_realtime(void)
	94	{
	95	struct timeval tv;
	96
	97	gettimeofday(&tv, NULL);
	98	return tv.tv_sec * 1000000000LL + (tv.tv_usec * 1000);
	99	}
	100
	101	/* Warning: don't insert tracepoints into these functions, they are
	102	also used by simpletrace backend and tracepoints would cause
	103	an infinite recursion! */
	104	#ifdef _WIN32
	105	extern int64_t clock_freq;
	106
	107	static inline int64_t get_clock(void)
	108	{
	109	LARGE_INTEGER ti;
	110	QueryPerformanceCounter(&ti);
	111	return muldiv64(ti.QuadPart, get_ticks_per_sec(), clock_freq);
	112	}
	113
	114	#else
	115
	116	extern int use_rt_clock;
	117
	118	static inline int64_t get_clock(void)
	119	{
	120	#if defined(__linux__) \|\| (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
	121	\|\| defined(__DragonFly__) \|\| defined(__FreeBSD_kernel__)
	122	if (use_rt_clock) {
	123	struct timespec ts;
	124	clock_gettime(CLOCK_MONOTONIC, &ts);
	125	return ts.tv_sec * 1000000000LL + ts.tv_nsec;
	126	} else
	127	#endif
	128	{
	129	/* XXX: using gettimeofday leads to problems if the date
	130	changes, so it should be avoided. */
	131	return get_clock_realtime();
	132	}
	133	}
	134	#endif
	135
	136	void qemu_get_timer(QEMUFile f, QEMUTimer ts);
	137	void qemu_put_timer(QEMUFile f, QEMUTimer ts);
	138
	139	/* ptimer.c */
	140	typedef struct ptimer_state ptimer_state;
	141	typedef void (ptimer_cb)(void opaque);
	142
	143	ptimer_state ptimer_init(QEMUBH bh);
	144	void ptimer_set_period(ptimer_state *s, int64_t period);
	145	void ptimer_set_freq(ptimer_state *s, uint32_t freq);
	146	void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
	147	uint64_t ptimer_get_count(ptimer_state *s);
	148	void ptimer_set_count(ptimer_state *s, uint64_t count);
	149	void ptimer_run(ptimer_state *s, int oneshot);
	150	void ptimer_stop(ptimer_state *s);
	151
	152	/* icount */
	153	int64_t qemu_icount_round(int64_t count);
	154	extern int64_t qemu_icount;
	155	extern int use_icount;
	156	extern int icount_time_shift;
	157	extern int64_t qemu_icount_bias;
	158	int64_t cpu_get_icount(void);
	159
	160	/*******************************************/
	161	/* host CPU ticks (if available) */
	162
	163	#if defined(_ARCH_PPC)
	164
	165	static inline int64_t cpu_get_real_ticks(void)
	166	{
	167	int64_t retval;
	168	#ifdef _ARCH_PPC64
	169	/* This reads timebase in one 64bit go and includes Cell workaround from:
	170	http://ozlabs.org/pipermail/linuxppc-dev/2006-October/027052.html
	171	*/
	172	__asm__ __volatile__ ("mftb %0\n\t"
	173	"cmpwi %0,0\n\t"
	174	"beq- $-8"
	175	: "=r" (retval));
	176	#else
	177	/* http://ozlabs.org/pipermail/linuxppc-dev/1999-October/003889.html */
	178	unsigned long junk;
	179	__asm__ __volatile__ ("mfspr %1,269\n\t" /* mftbu */
	180	"mfspr %L0,268\n\t" /* mftb */
	181	"mfspr %0,269\n\t" /* mftbu */
	182	"cmpw %0,%1\n\t"
	183	"bne $-16"
	184	: "=r" (retval), "=r" (junk));
	185	#endif
	186	return retval;
	187	}
	188
	189	#elif defined(__i386__)
	190
	191	static inline int64_t cpu_get_real_ticks(void)
	192	{
	193	int64_t val;
	194	asm volatile ("rdtsc" : "=A" (val));
	195	return val;
	196	}
	197
	198	#elif defined(__x86_64__)
	199
	200	static inline int64_t cpu_get_real_ticks(void)
	201	{
	202	uint32_t low,high;
	203	int64_t val;
	204	asm volatile("rdtsc" : "=a" (low), "=d" (high));
	205	val = high;
	206	val <<= 32;
	207	val \|= low;
	208	return val;
	209	}
	210
	211	#elif defined(__hppa__)
	212
	213	static inline int64_t cpu_get_real_ticks(void)
	214	{
	215	int val;
	216	asm volatile ("mfctl %%cr16, %0" : "=r"(val));
	217	return val;
	218	}
	219
	220	#elif defined(__ia64)
	221
	222	static inline int64_t cpu_get_real_ticks(void)
	223	{
	224	int64_t val;
	225	asm volatile ("mov %0 = ar.itc" : "=r"(val) :: "memory");
	226	return val;
	227	}
	228
	229	#elif defined(__s390__)
	230
	231	static inline int64_t cpu_get_real_ticks(void)
	232	{
	233	int64_t val;
	234	asm volatile("stck 0(%1)" : "=m" (val) : "a" (&val) : "cc");
	235	return val;
	236	}
	237
	238	#elif defined(__sparc_v8plus__) \|\| defined(__sparc_v8plusa__) \|\| defined(__sparc_v9__)
	239
	240	static inline int64_t cpu_get_real_ticks (void)
	241	{
	242	#if defined(_LP64)
	243	uint64_t rval;
	244	asm volatile("rd %%tick,%0" : "=r"(rval));
	245	return rval;
	246	#else
	247	union {
	248	uint64_t i64;
	249	struct {
	250	uint32_t high;
	251	uint32_t low;
	252	} i32;
	253	} rval;
	254	asm volatile("rd %%tick,%1; srlx %1,32,%0"
	255	: "=r"(rval.i32.high), "=r"(rval.i32.low));
	256	return rval.i64;
	257	#endif
	258	}
	259
	260	#elif defined(__mips__) && \
	261	((defined(__mips_isa_rev) && __mips_isa_rev >= 2) \|\| defined(__linux__))
	262	/*
	263	* binutils wants to use rdhwr only on mips32r2
	264	* but as linux kernel emulate it, it's fine
	265	* to use it.
	266	*
	267	*/
	268	#define MIPS_RDHWR(rd, value) { \
	269	__asm__ __volatile__ (".set push\n\t" \
	270	".set mips32r2\n\t" \
	271	"rdhwr %0, "rd"\n\t" \
	272	".set pop" \
	273	: "=r" (value)); \
	274	}
	275
	276	static inline int64_t cpu_get_real_ticks(void)
	277	{
	278	/* On kernels >= 2.6.25 rdhwr <reg>, $2 and $3 are emulated */
	279	uint32_t count;
	280	static uint32_t cyc_per_count = 0;
	281
	282	if (!cyc_per_count) {
	283	MIPS_RDHWR("$3", cyc_per_count);
	284	}
	285
	286	MIPS_RDHWR("$2", count);
	287	return (int64_t)(count * cyc_per_count);
	288	}
	289
	290	#elif defined(__alpha__)
	291
	292	static inline int64_t cpu_get_real_ticks(void)
	293	{
	294	uint64_t cc;
	295	uint32_t cur, ofs;
	296
	297	asm volatile("rpcc %0" : "=r"(cc));
	298	cur = cc;
	299	ofs = cc >> 32;
	300	return cur - ofs;
	301	}
	302
	303	#else
	304	/* The host CPU doesn't have an easily accessible cycle counter.
	305	Just return a monotonically increasing value. This will be
	306	totally wrong, but hopefully better than nothing. */
	307	static inline int64_t cpu_get_real_ticks (void)
	308	{
	309	static int64_t ticks = 0;
	310	return ticks++;
	311	}
	312	#endif
	313
	314	#ifdef NEED_CPU_H
	315	/* Deterministic execution requires that IO only be performed on the last
	316	instruction of a TB so that interrupts take effect immediately. */
	317	static inline int can_do_io(CPUState *env)
	318	{
	319	if (!use_icount)
	320	return 1;
	321
	322	/* If not executing code then assume we are ok. */
	323	if (!env->current_tb)
	324	return 1;
	325
	326	return env->can_do_io != 0;
	327	}
	328	#endif
	329
	330	#ifdef CONFIG_PROFILER
	331	static inline int64_t profile_getclock(void)
	332	{
	333	return cpu_get_real_ticks();
	334	}
	335
	336	extern int64_t qemu_time, qemu_time_start;
	337	extern int64_t tlb_flush_time;
	338	extern int64_t dev_time;
	339	#endif
	340
	341	#endif