qemu-timer.c: Use upstream version.

This completely modifies the implementation of timers to match upstream,
the only difference is that the oddly-placed qemu_gpoll_ns() function is
disabled (it's not used yet).

Most of the changes here (but not all), were applied through the following
sed script:

	s|qemu_get_clock\s*(\s*vm_clock\s*)|qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)|g
	s|qemu_get_clock\s*(\s*rt_clock\s*)|qemu_clock_get_ms(QEMU_CLOCK_REALTIME)|g
	s|qemu_get_clock_ns\s*(\s*vm_clock\s*)|qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL)|g
	s|qemu_get_clock_ns\s*(\s*rt_clock\s*)|qemu_clock_get_ns(QEMU_CLOCK_REALTIME)|g
	s|qemu_get_clock_ms\s*(\s*vm_clock\s*)|qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL)|g
	s|qemu_get_clock_ms\s*(\s*rt_clock\s*)|qemu_clock_get_ms(QEMU_CLOCK_REALTIME)|g
	s|qemu_get_clock_ms\s*(\s*host_clock\s*)|qemu_clock_get_ms(QEMU_CLOCK_HOST)|g
	s|qemu_get_clock_ms\s*(\s*SHAPER_CLOCK\s*)|qemu_clock_get_ms(SHAPER_CLOCK)|g
	s|qemu_mod_timer\s*(|timer_mod(|g
	s|qemu_del_timer\s*(|timer_del(|g
	s|qemu_free_timer\s*(|timer_free(|g
	s|qemu_new_timer_ms\s*(\s*rt_clock,|timer_new(QEMU_CLOCK_REALTIME, SCALE_MS,|g
	s|qemu_new_timer_ns\s*(\s*rt_clock,|timer_new(QEMU_CLOCK_REALTIME, SCALE_NS,|g
	s|qemu_new_timer_ms\s*(\s*vm_clock,|timer_new(QEMU_CLOCK_VIRTUAL, SCALE_MS,|g
	s|qemu_new_timer_ns\s*(\s*vm_clock,|timer_new(QEMU_CLOCK_VIRTUAL, SCALE_NS,|g
	s|qemu_new_timer_ms\s*(\s*host_clock,|timer_new(QEMU_CLOCK_HOST, SCALE_MS,|g
	s|qemu_new_timer_ns\s*(\s*host_clock,|timer_new(QEMU_CLOCK_HOST, SCALE_NS,|g
	s|qemu_new_timer_ms\s*(\s*SHAPER_CLOCK\s*,|timer_new(SHAPER_CLOCK, SCALE_MS,|g
	s|qemu_put_timer\s*(|timer_put(|g
	s|qemu_get_timer\s*(|timer_get(|g
	s|qemu_timer_pending\s*(|timer_pending(|g
	s|qemu_clock_next_deadline\s*(\s*vm_clock|qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL|g
	s|qemu_clock_next_deadline\s*(\s*rt_clock|qemu_clock_deadline_ns_all(QEMU_CLOCK_REALTIME|g
	s|qemu_clock_next_deadline\s*(\s*host_clock|qemu_clock_deadline_ns_all(QEMU_CLOCK_HOST|g

+ Disable icount-based clock warping/adjustments. It will be re-enabled in the future
  after cpu emulation has been completely refactored.

Change-Id: Ifbcf4a52654eed3a08dfe59b0546a75d4627f758

Author: digit-android

android/hw-sensors.c

@@ -211,8 +211,8 @@ _hwSensorClient_free( HwSensorClient*  cl )
     }
     /* remove timer, if any */
     if (cl->timer) {
-        qemu_del_timer(cl->timer);
-        qemu_free_timer(cl->timer);
+        timer_del(cl->timer);
+        timer_free(cl->timer);
         cl->timer = NULL;
     }
     AFREE(cl);
@@ -232,7 +232,7 @@ _hwSensorClient_new( HwSensors*  sensors )
     cl->sensors     = sensors;
     cl->enabledMask = 0;
     cl->delay_ms    = 800;
-    cl->timer       = qemu_new_timer_ns(vm_clock, _hwSensorClient_tick, cl);
+    cl->timer       = timer_new(QEMU_CLOCK_VIRTUAL, SCALE_NS, _hwSensorClient_tick, cl);
 
     cl->next         = sensors->clients;
     sensors->clients = cl;
@@ -337,7 +337,7 @@ _hwSensorClient_tick( void*  opaque )
         _hwSensorClient_send(cl, (uint8_t*) buffer, strlen(buffer));
     }
 
-    now_ns = qemu_get_clock_ns(vm_clock);
+    now_ns = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 
     snprintf(buffer, sizeof buffer, "sync:%" PRId64, now_ns/1000);
     _hwSensorClient_send(cl, (uint8_t*)buffer, strlen(buffer));
@@ -352,7 +352,7 @@ _hwSensorClient_tick( void*  opaque )
         delay = 20;
 
     delay *= 1000000LL;  /* convert to nanoseconds */
-    qemu_mod_timer(cl->timer, now_ns + delay);
+    timer_mod(cl->timer, now_ns + delay);
 }
 
 /* handle incoming messages from the HAL module */
@@ -461,7 +461,7 @@ _hwSensorClient_save( QEMUFile*  f, QemudClient*  client, void*  opaque  )
 
     qemu_put_be32(f, sc->delay_ms);
     qemu_put_be32(f, sc->enabledMask);
-    qemu_put_timer(f, sc->timer);
+    timer_put(f, sc->timer);
 }
 
 /* Loads sensor-specific client data from snapshot */
@@ -472,7 +472,7 @@ _hwSensorClient_load( QEMUFile*  f, QemudClient*  client, void*  opaque  )
 
     sc->delay_ms = qemu_get_be32(f);
     sc->enabledMask = qemu_get_be32(f);
-    qemu_get_timer(f, sc->timer);
+    timer_get(f, sc->timer);
 
     return 0;
 }

android/looper-qemu.c

@@ -34,40 +34,40 @@ qlooptimer_startRelative(void* impl, Duration timeout_ms)
 {
     QEMUTimer* tt = impl;
     if (timeout_ms == DURATION_INFINITE)
-        qemu_del_timer(tt);
+        timer_del(tt);
     else
-        qemu_mod_timer(tt, qemu_get_clock_ms(host_clock) + timeout_ms);
+        timer_mod(tt, qemu_clock_get_ms(QEMU_CLOCK_HOST) + timeout_ms);
 }
 
 static void
 qlooptimer_startAbsolute(void* impl, Duration deadline_ms)
 {
     QEMUTimer* tt = impl;
     if (deadline_ms == DURATION_INFINITE)
-        qemu_del_timer(tt);
+        timer_del(tt);
     else
-        qemu_mod_timer(tt, deadline_ms);
+        timer_mod(tt, deadline_ms);
 }
 
 static void
 qlooptimer_stop(void* impl)
 {
     QEMUTimer* tt = impl;
-    qemu_del_timer(tt);
+    timer_del(tt);
 }
 
 static int
 qlooptimer_isActive(void* impl)
 {
     QEMUTimer* tt = impl;
-    return qemu_timer_pending(tt);
+    return timer_pending(tt);
 }
 
 static void
 qlooptimer_free(void* impl)
 {
     QEMUTimer* tt = impl;
-    qemu_free_timer(tt);
+    timer_free(tt);
 }
 
 static const LoopTimerClass  qlooptimer_class = {
@@ -85,7 +85,7 @@ qlooper_timer_init(Looper*        looper,
                    void*          opaque)
 {
     timer->clazz = (LoopTimerClass*) &qlooptimer_class;
-    timer->impl  = qemu_new_timer_ms(host_clock, callback, opaque);
+    timer->impl  = timer_new(QEMU_CLOCK_HOST, SCALE_MS, callback, opaque);
 }
 
 /**********************************************************************
@@ -370,7 +370,7 @@ qlooper_handle_io_bh(void* opaque)
 static Duration
 qlooper_now(Looper* ll)
 {
-    return qemu_get_clock_ms(host_clock);
+    return qemu_clock_get_ms(QEMU_CLOCK_HOST);
 }
 
 extern void qemu_system_shutdown_request(void);

android/shaper.c

@@ -14,7 +14,7 @@
 #include "qemu/timer.h"
 #include <stdlib.h>
 
-#define  SHAPER_CLOCK        rt_clock
+#define  SHAPER_CLOCK        QEMU_CLOCK_REALTIME
 #define  SHAPER_CLOCK_UNIT   1000.
 
 static int
@@ -123,8 +123,8 @@ netshaper_destroy( NetShaper  shaper )
             queued_packet_free(packet);
         }
 
-        qemu_del_timer(shaper->timer);
-        qemu_free_timer(shaper->timer);
+        timer_del(shaper->timer);
+        timer_free(shaper->timer);
         shaper->timer = NULL;
         g_free(shaper);
     }
@@ -137,7 +137,7 @@ netshaper_expires( NetShaper  shaper )
     QueuedPacket  packet;
 
     while ((packet = shaper->packets) != NULL) {
-        int64_t   now = qemu_get_clock_ms( SHAPER_CLOCK );
+        int64_t   now = qemu_clock_get_ms( SHAPER_CLOCK );
 
        if (packet->expiration > now)
            break;
@@ -151,7 +151,7 @@ netshaper_expires( NetShaper  shaper )
    /* reprogram timer if needed */
    if (shaper->packets) {
        shaper->block_until = shaper->packets->expiration;
-       qemu_mod_timer( shaper->timer, shaper->block_until );
+       timer_mod( shaper->timer, shaper->block_until );
    } else {
        shaper->block_until = -1;
    }
@@ -167,9 +167,9 @@ netshaper_create( int                do_copy,
     shaper->active = 0;
     shaper->packets = NULL;
     shaper->num_packets = 0;
-    shaper->timer   = qemu_new_timer_ms( SHAPER_CLOCK,
-                                         (QEMUTimerCB*) netshaper_expires,
-                                         shaper );
+    shaper->timer   = timer_new( SHAPER_CLOCK, SCALE_MS,
+                                 (QEMUTimerCB*) netshaper_expires,
+                                 shaper );
     shaper->send_func = send_func;
     shaper->max_rate  = 1e6;
     shaper->inv_rate  = 0.;
@@ -216,7 +216,7 @@ netshaper_send_aux( NetShaper  shaper,
         return;
     }
 
-    now = qemu_get_clock_ms( SHAPER_CLOCK );
+    now = qemu_clock_get_ms( SHAPER_CLOCK );
     if (now >= shaper->block_until) {
         shaper->send_func( data, size, opaque );
         shaper->block_until = now + size*shaper->inv_rate;
@@ -246,7 +246,7 @@ netshaper_send_aux( NetShaper  shaper,
             *pnode       = packet;
 
             if (packet == shaper->packets)
-                qemu_mod_timer( shaper->timer, packet->expiration );
+                timer_mod( shaper->timer, packet->expiration );
         }
         shaper->num_packets += 1;
     }
@@ -274,7 +274,7 @@ netshaper_can_send( NetShaper  shaper )
     if (shaper->packets)
         return 0;
 
-    now = qemu_get_clock_ms( SHAPER_CLOCK );
+    now = qemu_clock_get_ms( SHAPER_CLOCK );
     return (now >= shaper->block_until);
 }
 
@@ -424,7 +424,7 @@ static void
 netdelay_expires( NetDelay  delay )
 {
     Session  session;
-    int64_t  now = qemu_get_clock_ms( SHAPER_CLOCK );
+    int64_t  now = qemu_clock_get_ms(SHAPER_CLOCK);
     int      rearm = 0;
     int64_t  rearm_time = 0;
 
@@ -452,7 +452,7 @@ netdelay_expires( NetDelay  delay )
     }
 
     if (rearm)
-        qemu_mod_timer( delay->timer, rearm_time );
+        timer_mod( delay->timer, rearm_time );
 }
 
 
@@ -463,9 +463,9 @@ netdelay_create( NetShaperSendFunc  send_func )
 
     delay->sessions     = NULL;
     delay->num_sessions = 0;
-    delay->timer        = qemu_new_timer_ms( SHAPER_CLOCK,
-                                             (QEMUTimerCB*) netdelay_expires,
-                                             delay );
+    delay->timer        = timer_new( SHAPER_CLOCK, SCALE_MS,
+                                     (QEMUTimerCB*) netdelay_expires,
+                                     delay );
     delay->active = 0;
     delay->min_ms = 0;
     delay->max_ms = 0;
@@ -553,7 +553,7 @@ netdelay_send_aux( NetDelay  delay, const void*  data, size_t  size, void* opaqu
                 delay->sessions      = session;
                 delay->num_sessions += 1;
 
-                session->expiration = qemu_get_clock_ms( SHAPER_CLOCK ) + latency;
+                session->expiration = qemu_clock_get_ms(SHAPER_CLOCK) + latency;
 
                 session->src_ip   = info->src_ip;
                 session->dst_ip   = info->dst_ip;

arch_init.c

@@ -298,7 +298,7 @@ int ram_save_live(QEMUFile *f, int stage, void *opaque)
     }
 
     bytes_transferred_last = bytes_transferred;
-    bwidth = qemu_get_clock_ns(rt_clock);
+    bwidth = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
 
     while (!qemu_file_rate_limit(f)) {
         int bytes_sent;
@@ -310,7 +310,7 @@ int ram_save_live(QEMUFile *f, int stage, void *opaque)
         }
     }
 
-    bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
+    bwidth = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - bwidth;
     bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
 
     /* if we haven't transferred anything this round, force expected_time to a

audio/audio.c

@@ -1198,7 +1198,7 @@ static void audio_timer (void *opaque)
     AudioState *s = opaque;
 #if 0
 #define  MAX_DIFFS  100
-    int64_t         now  = qemu_get_clock_ms(vm_clock);
+    int64_t         now  = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL);
     static int64_t  last = 0;
     static float    diffs[MAX_DIFFS];
     static int      num_diffs;
@@ -1227,7 +1227,7 @@ static void audio_timer (void *opaque)
 #endif
 
     audio_run ("timer");
-    qemu_mod_timer (s->ts, qemu_get_clock_ns (vm_clock) + conf.period.ticks);
+    timer_mod(s->ts, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + conf.period.ticks);
 }
 
 
@@ -1250,10 +1250,10 @@ static void audio_reset_timer (void)
     AudioState *s = &glob_audio_state;
 
     if (audio_is_timer_needed ()) {
-        qemu_mod_timer (s->ts, qemu_get_clock_ns (vm_clock) + 1);
+        timer_mod(s->ts, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 1);
     }
     else {
-        qemu_del_timer (s->ts);
+        timer_del(s->ts);
     }
 }
 
@@ -1964,7 +1964,7 @@ static void audio_init (void)
     QLIST_INIT (&s->cap_head);
     atexit (audio_atexit);
 
-    s->ts = qemu_new_timer_ns (vm_clock, audio_timer, s);
+    s->ts = timer_new(QEMU_CLOCK_VIRTUAL, SCALE_NS, audio_timer, s);
     if (!s->ts) {
         dolog ("Could not create audio timer\n");
         return;

audio/noaudio.c

@@ -46,7 +46,7 @@ static int no_run_out (HWVoiceOut *hw, int live)
     int64_t ticks;
     int64_t bytes;
 
-    now = qemu_get_clock (vm_clock);
+    now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
     ticks = now - no->old_ticks;
     bytes = muldiv64 (ticks, hw->info.bytes_per_second, get_ticks_per_sec ());
     bytes = audio_MIN (bytes, INT_MAX);
@@ -102,7 +102,7 @@ static int no_run_in (HWVoiceIn *hw)
     int samples = 0;
 
     if (dead) {
-        int64_t now = qemu_get_clock (vm_clock);
+        int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
         int64_t ticks = now - no->old_ticks;
         int64_t bytes =
             muldiv64 (ticks, hw->info.bytes_per_second, get_ticks_per_sec ());

audio/wavaudio.c

@@ -60,7 +60,7 @@ static int wav_out_run (HWVoiceOut *hw, int live)
     int rpos, decr, samples;
     uint8_t *dst;
     struct st_sample *src;
-    int64_t now = qemu_get_clock (vm_clock);
+    int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
     int64_t ticks = now - wav->old_ticks;
     int64_t bytes =
         muldiv64 (ticks, hw->info.bytes_per_second, get_ticks_per_sec ());
@@ -355,7 +355,7 @@ static int wav_in_run (HWVoiceIn *hw)
     uint8_t*      src;
     struct st_sample*  dst;
 
-    int64_t  now   = qemu_get_clock (vm_clock);
+    int64_t  now   = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
     int64_t  ticks = now - wav->old_ticks;
     int64_t  bytes = muldiv64(ticks, hw->info.bytes_per_second, get_ticks_per_sec());
 

audio/winaudio.c

@@ -292,7 +292,7 @@ winaudio_out_run (HWVoiceOut *hw, int live)
             s->write_pos += wav_bytes;
             if (s->write_pos == s->write_size) {
 #if xxDEBUG
-                int64_t  now  = qemu_get_clock(vm_clock) - start_time;
+                int64_t  now  = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) - start_time;
                 int64_t  diff = now - last_time;
 
                 D("run_out: (%7.3f:%7d):waveOutWrite buffer:%d\n",
@@ -617,7 +617,7 @@ winaudio_init(void)
     WinAudioState*  s = &g_winaudio;
 
 #if DEBUG
-    start_time = qemu_get_clock(vm_clock);
+    start_time = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
     last_time  = 0;
 #endif
 

block/raw-posix.c

@@ -889,7 +889,7 @@ static int fd_open(BlockDriverState *bs)
         return 0;
     last_media_present = (s->fd >= 0);
     if (s->fd >= 0 &&
-        (qemu_get_clock(rt_clock) - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
+        (qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - s->fd_open_time) >= FD_OPEN_TIMEOUT) {
         close(s->fd);
         s->fd = -1;
 #ifdef DEBUG_FLOPPY
@@ -898,15 +898,15 @@ static int fd_open(BlockDriverState *bs)
     }
     if (s->fd < 0) {
         if (s->fd_got_error &&
-            (qemu_get_clock(rt_clock) - s->fd_error_time) < FD_OPEN_TIMEOUT) {
+            (qemu_clock_get_ms(QEMU_CLOCK_REALTIME) - s->fd_error_time) < FD_OPEN_TIMEOUT) {
 #ifdef DEBUG_FLOPPY
             printf("No floppy (open delayed)\n");
 #endif
             return -EIO;
         }
         s->fd = open(bs->filename, s->open_flags & ~O_NONBLOCK);
         if (s->fd < 0) {
-            s->fd_error_time = qemu_get_clock(rt_clock);
+            s->fd_error_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
             s->fd_got_error = 1;
             if (last_media_present)
                 s->fd_media_changed = 1;
@@ -921,7 +921,7 @@ static int fd_open(BlockDriverState *bs)
     }
     if (!last_media_present)
         s->fd_media_changed = 1;
-    s->fd_open_time = qemu_get_clock(rt_clock);
+    s->fd_open_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
     s->fd_got_error = 0;
     return 0;
 }