mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change all rt_clock references to use millisecond resolution accessors

Browse Source 
This was done with:

    sed -i '/get_clock\>.*rt_clock/s/get_clock\>/get_clock_ms/' \
        $(git grep -l 'get_clock\>.*rt_clock' )
    sed -i '/new_timer\>.*rt_clock/s/new_timer\>/new_timer_ms/' \
        $(git grep -l 'new_timer\>.*rt_clock' )

after checking that get_clock and new_timer never occur twice
on the same line.  There were no missed occurrences; however, even
if there had been, they would have been caught by the compiler.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2011-03-11 16:47:48 +01:00
parent 0ce1b9480e
commit 7bd427d801
14 changed files with 55 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
buffered_file.c
View File

@ -238,7 +238,7 @@ static void buffered_rate_tick(void *opaque)
return; return;
} }
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100); qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);
if (s->freeze_output) if (s->freeze_output)
return; return;
@ -274,9 +274,9 @@ QEMUFile *qemu_fopen_ops_buffered(void *opaque,
buffered_set_rate_limit, buffered_set_rate_limit,
buffered_get_rate_limit); buffered_get_rate_limit);
s->timer = qemu_new_timer(rt_clock, buffered_rate_tick, s); s->timer = qemu_new_timer_ms(rt_clock, buffered_rate_tick, s);
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 100); qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 100);
return s->file; return s->file;
} }

4
console.c
View File

@ -1135,7 +1135,7 @@ static void kbd_send_chars(void *opaque)
/* characters are pending: we send them a bit later (XXX: /* characters are pending: we send them a bit later (XXX:
horrible, should change char device API) */ horrible, should change char device API) */
if (s->out_fifo.count > 0) { if (s->out_fifo.count > 0) {
qemu_mod_timer(s->kbd_timer, qemu_get_clock(rt_clock) + 1); qemu_mod_timer(s->kbd_timer, qemu_get_clock_ms(rt_clock) + 1);
} }
} }
@ -1457,7 +1457,7 @@ static void text_console_do_init(CharDriverState *chr, DisplayState *ds)
s->out_fifo.buf = s->out_fifo_buf; s->out_fifo.buf = s->out_fifo_buf;
s->out_fifo.buf_size = sizeof(s->out_fifo_buf); s->out_fifo.buf_size = sizeof(s->out_fifo_buf);
s->kbd_timer = qemu_new_timer(rt_clock, kbd_send_chars, s); s->kbd_timer = qemu_new_timer_ms(rt_clock, kbd_send_chars, s);
s->ds = ds; s->ds = ds;
if (!color_inited) { if (!color_inited) {

10
hw/omap1.c
View File

@ -2802,7 +2802,7 @@ static void omap_rtc_reset(struct omap_rtc_s *s)
s->pm_am = 0; s->pm_am = 0;
s->auto_comp = 0; s->auto_comp = 0;
s->round = 0; s->round = 0;
s->tick = qemu_get_clock(rt_clock); s->tick = qemu_get_clock_ms(rt_clock);
memset(&s->alarm_tm, 0, sizeof(s->alarm_tm)); memset(&s->alarm_tm, 0, sizeof(s->alarm_tm));
s->alarm_tm.tm_mday = 0x01; s->alarm_tm.tm_mday = 0x01;
s->status = 1 << 7; s->status = 1 << 7;
@ -2822,7 +2822,7 @@ static struct omap_rtc_s *omap_rtc_init(target_phys_addr_t base,
s->irq = irq[0]; s->irq = irq[0];
s->alarm = irq[1]; s->alarm = irq[1];
s->clk = qemu_new_timer(rt_clock, omap_rtc_tick, s); s->clk = qemu_new_timer_ms(rt_clock, omap_rtc_tick, s);
omap_rtc_reset(s); omap_rtc_reset(s);
@ -3399,9 +3399,9 @@ static void omap_lpg_tick(void *opaque)
struct omap_lpg_s *s = opaque; struct omap_lpg_s *s = opaque;
if (s->cycle) if (s->cycle)
qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->period - s->on); qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->period - s->on);
else else
qemu_mod_timer(s->tm, qemu_get_clock(rt_clock) + s->on); qemu_mod_timer(s->tm, qemu_get_clock_ms(rt_clock) + s->on);
s->cycle = !s->cycle; s->cycle = !s->cycle;
printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off"); printf("%s: LED is %s\n", __FUNCTION__, s->cycle ? "on" : "off");
@ -3516,7 +3516,7 @@ static struct omap_lpg_s *omap_lpg_init(target_phys_addr_t base, omap_clk clk)
struct omap_lpg_s *s = (struct omap_lpg_s *) struct omap_lpg_s *s = (struct omap_lpg_s *)
qemu_mallocz(sizeof(struct omap_lpg_s)); qemu_mallocz(sizeof(struct omap_lpg_s));
s->tm = qemu_new_timer(rt_clock, omap_lpg_tick, s); s->tm = qemu_new_timer_ms(rt_clock, omap_lpg_tick, s);
omap_lpg_reset(s); omap_lpg_reset(s);

26
hw/pxa2xx.c
View File

@ -921,7 +921,7 @@ static inline void pxa2xx_rtc_int_update(PXA2xxRTCState *s)
static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s) static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
{ {
int64_t rt = qemu_get_clock(rt_clock); int64_t rt = qemu_get_clock_ms(rt_clock);
s->last_rcnr += ((rt - s->last_hz) << 15) / s->last_rcnr += ((rt - s->last_hz) << 15) /
(1000 * ((s->rttr & 0xffff) + 1)); (1000 * ((s->rttr & 0xffff) + 1));
s->last_rdcr += ((rt - s->last_hz) << 15) / s->last_rdcr += ((rt - s->last_hz) << 15) /
@ -931,7 +931,7 @@ static void pxa2xx_rtc_hzupdate(PXA2xxRTCState *s)
static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s) static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
{ {
int64_t rt = qemu_get_clock(rt_clock); int64_t rt = qemu_get_clock_ms(rt_clock);
if (s->rtsr & (1 << 12)) if (s->rtsr & (1 << 12))
s->last_swcr += (rt - s->last_sw) / 10; s->last_swcr += (rt - s->last_sw) / 10;
s->last_sw = rt; s->last_sw = rt;
@ -939,7 +939,7 @@ static void pxa2xx_rtc_swupdate(PXA2xxRTCState *s)
static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s) static void pxa2xx_rtc_piupdate(PXA2xxRTCState *s)
{ {
int64_t rt = qemu_get_clock(rt_clock); int64_t rt = qemu_get_clock_ms(rt_clock);
if (s->rtsr & (1 << 15)) if (s->rtsr & (1 << 15))
s->last_swcr += rt - s->last_pi; s->last_swcr += rt - s->last_pi;
s->last_pi = rt; s->last_pi = rt;
@ -1064,16 +1064,16 @@ static uint32_t pxa2xx_rtc_read(void *opaque, target_phys_addr_t addr)
case PIAR: case PIAR:
return s->piar; return s->piar;
case RCNR: case RCNR:
return s->last_rcnr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) / return s->last_rcnr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
(1000 * ((s->rttr & 0xffff) + 1)); (1000 * ((s->rttr & 0xffff) + 1));
case RDCR: case RDCR:
return s->last_rdcr + ((qemu_get_clock(rt_clock) - s->last_hz) << 15) / return s->last_rdcr + ((qemu_get_clock_ms(rt_clock) - s->last_hz) << 15) /
(1000 * ((s->rttr & 0xffff) + 1)); (1000 * ((s->rttr & 0xffff) + 1));
case RYCR: case RYCR:
return s->last_rycr; return s->last_rycr;
case SWCR: case SWCR:
if (s->rtsr & (1 << 12)) if (s->rtsr & (1 << 12))
return s->last_swcr + (qemu_get_clock(rt_clock) - s->last_sw) / 10; return s->last_swcr + (qemu_get_clock_ms(rt_clock) - s->last_sw) / 10;
else else
return s->last_swcr; return s->last_swcr;
default: default:
@ -1219,14 +1219,14 @@ static int pxa2xx_rtc_init(SysBusDevice *dev)
s->last_swcr = (tm.tm_hour << 19) | s->last_swcr = (tm.tm_hour << 19) |
(tm.tm_min << 13) | (tm.tm_sec << 7); (tm.tm_min << 13) | (tm.tm_sec << 7);
s->last_rtcpicr = 0; s->last_rtcpicr = 0;
s->last_hz = s->last_sw = s->last_pi = qemu_get_clock(rt_clock); s->last_hz = s->last_sw = s->last_pi = qemu_get_clock_ms(rt_clock);
s->rtc_hz = qemu_new_timer(rt_clock, pxa2xx_rtc_hz_tick, s); s->rtc_hz = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_hz_tick, s);
s->rtc_rdal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal1_tick, s); s->rtc_rdal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal1_tick, s);
s->rtc_rdal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_rdal2_tick, s); s->rtc_rdal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_rdal2_tick, s);
s->rtc_swal1 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal1_tick, s); s->rtc_swal1 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal1_tick, s);
s->rtc_swal2 = qemu_new_timer(rt_clock, pxa2xx_rtc_swal2_tick, s); s->rtc_swal2 = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_swal2_tick, s);
s->rtc_pi = qemu_new_timer(rt_clock, pxa2xx_rtc_pi_tick, s); s->rtc_pi = qemu_new_timer_ms(rt_clock, pxa2xx_rtc_pi_tick, s);
sysbus_init_irq(dev, &s->rtc_irq); sysbus_init_irq(dev, &s->rtc_irq);

8
hw/twl92230.c
View File

@ -74,14 +74,14 @@ static inline void menelaus_update(MenelausState *s)
static inline void menelaus_rtc_start(MenelausState *s) static inline void menelaus_rtc_start(MenelausState *s)
{ {
s->rtc.next += qemu_get_clock(rt_clock); s->rtc.next += qemu_get_clock_ms(rt_clock);
qemu_mod_timer(s->rtc.hz_tm, s->rtc.next); qemu_mod_timer(s->rtc.hz_tm, s->rtc.next);
} }
static inline void menelaus_rtc_stop(MenelausState *s) static inline void menelaus_rtc_stop(MenelausState *s)
{ {
qemu_del_timer(s->rtc.hz_tm); qemu_del_timer(s->rtc.hz_tm);
s->rtc.next -= qemu_get_clock(rt_clock); s->rtc.next -= qemu_get_clock_ms(rt_clock);
if (s->rtc.next < 1) if (s->rtc.next < 1)
s->rtc.next = 1; s->rtc.next = 1;
} }
@ -786,7 +786,7 @@ static void menelaus_pre_save(void *opaque)
{ {
MenelausState *s = opaque; MenelausState *s = opaque;
/* Should be <= 1000 */ /* Should be <= 1000 */
s->rtc_next_vmstate = s->rtc.next - qemu_get_clock(rt_clock); s->rtc_next_vmstate = s->rtc.next - qemu_get_clock_ms(rt_clock);
} }
static int menelaus_post_load(void *opaque, int version_id) static int menelaus_post_load(void *opaque, int version_id)
@ -847,7 +847,7 @@ static int twl92230_init(i2c_slave *i2c)
{ {
MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c); MenelausState *s = FROM_I2C_SLAVE(MenelausState, i2c);
s->rtc.hz_tm = qemu_new_timer(rt_clock, menelaus_rtc_hz, s); s->rtc.hz_tm = qemu_new_timer_ms(rt_clock, menelaus_rtc_hz, s);
/* Three output pins plus one interrupt pin. */ /* Three output pins plus one interrupt pin. */
qdev_init_gpio_out(&i2c->qdev, s->out, 4); qdev_init_gpio_out(&i2c->qdev, s->out, 4);
qdev_init_gpio_in(&i2c->qdev, menelaus_gpio_set, 3); qdev_init_gpio_in(&i2c->qdev, menelaus_gpio_set, 3);

6
hw/xen_domainbuild.c
View File

@ -149,7 +149,7 @@ static void xen_domain_poll(void *opaque)
goto quit; goto quit;
} }
qemu_mod_timer(xen_poll, qemu_get_clock(rt_clock) + 1000); qemu_mod_timer(xen_poll, qemu_get_clock_ms(rt_clock) + 1000);
return; return;
quit: quit:
@ -291,8 +291,8 @@ int xen_domain_build_pv(const char *kernel, const char *ramdisk,
goto err; goto err;
} }
xen_poll = qemu_new_timer(rt_clock, xen_domain_poll, NULL); xen_poll = qemu_new_timer_ms(rt_clock, xen_domain_poll, NULL);
qemu_mod_timer(xen_poll, qemu_get_clock(rt_clock) + 1000); qemu_mod_timer(xen_poll, qemu_get_clock_ms(rt_clock) + 1000);
return 0; return 0;
err: err:

8
qemu-char.c
View File

@ -267,7 +267,7 @@ static int mux_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
int64_t ti; int64_t ti;
int secs; int secs;
ti = qemu_get_clock(rt_clock); ti = qemu_get_clock_ms(rt_clock);
if (d->timestamps_start == -1) if (d->timestamps_start == -1)
d->timestamps_start = ti; d->timestamps_start = ti;
ti -= d->timestamps_start; ti -= d->timestamps_start;
@ -911,7 +911,7 @@ static void pty_chr_update_read_handler(CharDriverState *chr)
* timeout to the normal (much longer) poll interval before the * timeout to the normal (much longer) poll interval before the
* timer triggers. * timer triggers.
*/ */
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 10); qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 10);
} }
static void pty_chr_state(CharDriverState *chr, int connected) static void pty_chr_state(CharDriverState *chr, int connected)
@ -925,7 +925,7 @@ static void pty_chr_state(CharDriverState *chr, int connected)
/* (re-)connect poll interval for idle guests: once per second. /* (re-)connect poll interval for idle guests: once per second.
* We check more frequently in case the guests sends data to * We check more frequently in case the guests sends data to
* the virtual device linked to our pty. */ * the virtual device linked to our pty. */
qemu_mod_timer(s->timer, qemu_get_clock(rt_clock) + 1000); qemu_mod_timer(s->timer, qemu_get_clock_ms(rt_clock) + 1000);
} else { } else {
if (!s->connected) if (!s->connected)
qemu_chr_generic_open(chr); qemu_chr_generic_open(chr);
@ -1001,7 +1001,7 @@ static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
chr->chr_update_read_handler = pty_chr_update_read_handler; chr->chr_update_read_handler = pty_chr_update_read_handler;
chr->chr_close = pty_chr_close; chr->chr_close = pty_chr_close;
s->timer = qemu_new_timer(rt_clock, pty_chr_timer, chr); s->timer = qemu_new_timer_ms(rt_clock, pty_chr_timer, chr);
return chr; return chr;
} }

6
qemu-timer.c
View File

@ -264,7 +264,7 @@ static void icount_adjust(void)
static void icount_adjust_rt(void * opaque) static void icount_adjust_rt(void * opaque)
{ {
qemu_mod_timer(icount_rt_timer, qemu_mod_timer(icount_rt_timer,
qemu_get_clock(rt_clock) + 1000); qemu_get_clock_ms(rt_clock) + 1000);
icount_adjust(); icount_adjust();
} }
@ -601,9 +601,9 @@ void configure_icount(const char *option)
the virtual time trigger catches emulated time passing too fast. the virtual time trigger catches emulated time passing too fast.
Realtime triggers occur even when idle, so use them less frequently Realtime triggers occur even when idle, so use them less frequently
than VM triggers. */ than VM triggers. */
icount_rt_timer = qemu_new_timer(rt_clock, icount_adjust_rt, NULL); icount_rt_timer = qemu_new_timer_ms(rt_clock, icount_adjust_rt, NULL);
qemu_mod_timer(icount_rt_timer, qemu_mod_timer(icount_rt_timer,
qemu_get_clock(rt_clock) + 1000); qemu_get_clock_ms(rt_clock) + 1000);
icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL); icount_vm_timer = qemu_new_timer(vm_clock, icount_adjust_vm, NULL);
qemu_mod_timer(icount_vm_timer, qemu_mod_timer(icount_vm_timer,
qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10); qemu_get_clock(vm_clock) + get_ticks_per_sec() / 10);

4
savevm.c
View File

@ -137,7 +137,7 @@ static void qemu_announce_self_once(void *opaque)
if (--count) { if (--count) {
/* delay 50ms, 150ms, 250ms, ... */ /* delay 50ms, 150ms, 250ms, ... */
qemu_mod_timer(timer, qemu_get_clock(rt_clock) + qemu_mod_timer(timer, qemu_get_clock_ms(rt_clock) +
50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100); 50 + (SELF_ANNOUNCE_ROUNDS - count - 1) * 100);
} else { } else {
qemu_del_timer(timer); qemu_del_timer(timer);
@ -148,7 +148,7 @@ static void qemu_announce_self_once(void *opaque)
void qemu_announce_self(void) void qemu_announce_self(void)
{ {
static QEMUTimer *timer; static QEMUTimer *timer;
timer = qemu_new_timer(rt_clock, qemu_announce_self_once, &timer); timer = qemu_new_timer_ms(rt_clock, qemu_announce_self_once, &timer);
qemu_announce_self_once(&timer); qemu_announce_self_once(&timer);
} }

2
slirp/slirp.c
View File

@ -393,7 +393,7 @@ void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
global_writefds = writefds; global_writefds = writefds;
global_xfds = xfds; global_xfds = xfds;
curtime = qemu_get_clock(rt_clock); curtime = qemu_get_clock_ms(rt_clock);
QTAILQ_FOREACH(slirp, &slirp_instances, entry) { QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
/* /*

4
ui/spice-core.c
View File

@ -55,14 +55,14 @@ static SpiceTimer *timer_add(SpiceTimerFunc func, void *opaque)
SpiceTimer *timer; SpiceTimer *timer;
timer = qemu_mallocz(sizeof(*timer)); timer = qemu_mallocz(sizeof(*timer));
timer->timer = qemu_new_timer(rt_clock, func, opaque); timer->timer = qemu_new_timer_ms(rt_clock, func, opaque);
QTAILQ_INSERT_TAIL(&timers, timer, next); QTAILQ_INSERT_TAIL(&timers, timer, next);
return timer; return timer;
} }
static void timer_start(SpiceTimer *timer, uint32_t ms) static void timer_start(SpiceTimer *timer, uint32_t ms)
{ {
qemu_mod_timer(timer->timer, qemu_get_clock(rt_clock) + ms); qemu_mod_timer(timer->timer, qemu_get_clock_ms(rt_clock) + ms);
} }
static void timer_cancel(SpiceTimer *timer) static void timer_cancel(SpiceTimer *timer)

10
ui/vnc.c
View File

@ -1875,8 +1875,8 @@ static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len)
if (data[0] > 3) { if (data[0] > 3) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval)) if (!qemu_timer_expired(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval))
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval); qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
} }
switch (data[0]) { switch (data[0]) {
@ -2441,7 +2441,7 @@ static void vnc_refresh(void *opaque)
if (vnc_trylock_display(vd)) { if (vnc_trylock_display(vd)) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) +
vd->timer_interval); vd->timer_interval);
return; return;
} }
@ -2468,14 +2468,14 @@ static void vnc_refresh(void *opaque)
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX) if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX; vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
} }
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval); qemu_mod_timer(vd->timer, qemu_get_clock_ms(rt_clock) + vd->timer_interval);
} }
static void vnc_init_timer(VncDisplay *vd) static void vnc_init_timer(VncDisplay *vd)
{ {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) { if (vd->timer == NULL && !QTAILQ_EMPTY(&vd->clients)) {
vd->timer = qemu_new_timer(rt_clock, vnc_refresh, vd); vd->timer = qemu_new_timer_ms(rt_clock, vnc_refresh, vd);
vnc_dpy_resize(vd->ds); vnc_dpy_resize(vd->ds);
vnc_refresh(vd); vnc_refresh(vd);
} }

4
usb-linux.c
View File

@ -1535,12 +1535,12 @@ static void usb_host_auto_check(void *unused)
} }
if (!usb_auto_timer) { if (!usb_auto_timer) {
usb_auto_timer = qemu_new_timer(rt_clock, usb_host_auto_check, NULL); usb_auto_timer = qemu_new_timer_ms(rt_clock, usb_host_auto_check, NULL);
if (!usb_auto_timer) { if (!usb_auto_timer) {
return; return;
} }
} }
qemu_mod_timer(usb_auto_timer, qemu_get_clock(rt_clock) + 2000); qemu_mod_timer(usb_auto_timer, qemu_get_clock_ms(rt_clock) + 2000);
} }
/* /*

12
vl.c
View File

@ -1142,7 +1142,7 @@ static void gui_update(void *opaque)
interval = dcl->gui_timer_interval; interval = dcl->gui_timer_interval;
dcl = dcl->next; dcl = dcl->next;
} }
qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock(rt_clock)); qemu_mod_timer(ds->gui_timer, interval + qemu_get_clock_ms(rt_clock));
} }
static void nographic_update(void *opaque) static void nographic_update(void *opaque)
@ -1150,7 +1150,7 @@ static void nographic_update(void *opaque)
uint64_t interval = GUI_REFRESH_INTERVAL; uint64_t interval = GUI_REFRESH_INTERVAL;
qemu_flush_coalesced_mmio_buffer(); qemu_flush_coalesced_mmio_buffer();
qemu_mod_timer(nographic_timer, interval + qemu_get_clock(rt_clock)); qemu_mod_timer(nographic_timer, interval + qemu_get_clock_ms(rt_clock));
} }
struct vm_change_state_entry { struct vm_change_state_entry {
@ -3089,15 +3089,15 @@ int main(int argc, char **argv, char **envp)
dcl = ds->listeners; dcl = ds->listeners;
while (dcl != NULL) { while (dcl != NULL) {
if (dcl->dpy_refresh != NULL) { if (dcl->dpy_refresh != NULL) {
ds->gui_timer = qemu_new_timer(rt_clock, gui_update, ds); ds->gui_timer = qemu_new_timer_ms(rt_clock, gui_update, ds);
qemu_mod_timer(ds->gui_timer, qemu_get_clock(rt_clock)); qemu_mod_timer(ds->gui_timer, qemu_get_clock_ms(rt_clock));
break; break;
} }
dcl = dcl->next; dcl = dcl->next;
} }
if (ds->gui_timer == NULL) { if (ds->gui_timer == NULL) {
nographic_timer = qemu_new_timer(rt_clock, nographic_update, NULL); nographic_timer = qemu_new_timer_ms(rt_clock, nographic_update, NULL);
qemu_mod_timer(nographic_timer, qemu_get_clock(rt_clock)); qemu_mod_timer(nographic_timer, qemu_get_clock_ms(rt_clock));
} }
text_consoles_set_display(ds); text_consoles_set_display(ds);