hw/core/ptimer.c

   1 /*
   2  * General purpose implementation of a simple periodic countdown timer.
   3  *
   4  * Copyright (c) 2007 CodeSourcery.
   5  *
   6  * This code is licensed under the GNU LGPL.
   7  */
   8
   9 #include "qemu/osdep.h"
  10 #include "qemu/timer.h"
  11 #include "hw/ptimer.h"
  12 #include "migration/vmstate.h"
  13 #include "qemu/host-utils.h"
  14 #include "sysemu/replay.h"
  15 #include "sysemu/qtest.h"
  16 #include "block/aio.h"
  17 #include "sysemu/cpus.h"
  18
  19 #define DELTA_ADJUST     1
  20 #define DELTA_NO_ADJUST -1
  21
  22 struct ptimer_state
  23 {
  24     uint8_t enabled; /* 0 = disabled, 1 = periodic, 2 = oneshot.  */
  25     uint64_t limit;
  26     uint64_t delta;
  27     uint32_t period_frac;
  28     int64_t period;
  29     int64_t last_event;
  30     int64_t next_event;
  31     uint8_t policy_mask;
  32     QEMUBH *bh;
  33     QEMUTimer *timer;
  34 };
  35
  36 /* Use a bottom-half routine to avoid reentrancy issues.  */
  37 static void ptimer_trigger(ptimer_state *s)
  38 {
  39     if (s->bh) {
  40         replay_bh_schedule_event(s->bh);
  41     }
  42 }
  43
  44 static void ptimer_reload(ptimer_state *s, int delta_adjust)
  45 {
  46     uint32_t period_frac = s->period_frac;
  47     uint64_t period = s->period;
  48     uint64_t delta = s->delta;
  49     bool suppress_trigger = false;
  50
  51     /*
  52      * Note that if delta_adjust is 0 then we must be here because of
  53      * a count register write or timer start, not because of timer expiry.
  54      * In that case the policy might require us to suppress the timer trigger
  55      * that we would otherwise generate for a zero delta.
  56      */
  57     if (delta_adjust == 0 &&
  58         (s->policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT)) {
  59         suppress_trigger = true;
  60     }
  61     if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)
  62         && !suppress_trigger) {
  63         ptimer_trigger(s);
  64     }
  65
  66     if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
  67         delta = s->delta = s->limit;
  68     }
  69
  70     if (s->period == 0) {
  71         if (!qtest_enabled()) {
  72             fprintf(stderr, "Timer with period zero, disabling\n");
  73         }
  74         timer_del(s->timer);
  75         s->enabled = 0;
  76         return;
  77     }
  78
  79     if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
  80         if (delta_adjust != DELTA_NO_ADJUST) {
  81             delta += delta_adjust;
  82         }
  83     }
  84
  85     if (delta == 0 && (s->policy_mask & PTIMER_POLICY_CONTINUOUS_TRIGGER)) {
  86         if (s->enabled == 1 && s->limit == 0) {
  87             delta = 1;
  88         }
  89     }
  90
  91     if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
  92         if (delta_adjust != DELTA_NO_ADJUST) {
  93             delta = 1;
  94         }
  95     }
  96
  97     if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
  98         if (s->enabled == 1 && s->limit != 0) {
  99             delta = 1;
 100         }
 101     }
 102
 103     if (delta == 0) {
 104         if (!qtest_enabled()) {
 105             fprintf(stderr, "Timer with delta zero, disabling\n");
 106         }
 107         timer_del(s->timer);
 108         s->enabled = 0;
 109         return;
 110     }
 111
 112     /*
 113      * Artificially limit timeout rate to something
 114      * achievable under QEMU.  Otherwise, QEMU spends all
 115      * its time generating timer interrupts, and there
 116      * is no forward progress.
 117      * About ten microseconds is the fastest that really works
 118      * on the current generation of host machines.
 119      */
 120
 121     if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
 122         period = 10000 / delta;
 123         period_frac = 0;
 124     }
 125
 126     s->last_event = s->next_event;
 127     s->next_event = s->last_event + delta * period;
 128     if (period_frac) {
 129         s->next_event += ((int64_t)period_frac * delta) >> 32;
 130     }
 131     timer_mod(s->timer, s->next_event);
 132 }
 133
 134 static void ptimer_tick(void *opaque)
 135 {
 136     ptimer_state *s = (ptimer_state *)opaque;
 137     bool trigger = true;
 138
 139     if (s->enabled == 2) {
 140         s->delta = 0;
 141         s->enabled = 0;
 142     } else {
 143         int delta_adjust = DELTA_ADJUST;
 144
 145         if (s->delta == 0 || s->limit == 0) {
 146             /* If a "continuous trigger" policy is not used and limit == 0,
 147                we should error out. delta == 0 means that this tick is
 148                caused by a "no immediate reload" policy, so it shouldn't
 149                be adjusted.  */
 150             delta_adjust = DELTA_NO_ADJUST;
 151         }
 152
 153         if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
 154             /* Avoid re-trigger on deferred reload if "no immediate trigger"
 155                policy isn't used.  */
 156             trigger = (delta_adjust == DELTA_ADJUST);
 157         }
 158
 159         s->delta = s->limit;
 160
 161         ptimer_reload(s, delta_adjust);
 162     }
 163
 164     if (trigger) {
 165         ptimer_trigger(s);
 166     }
 167 }
 168
 169 uint64_t ptimer_get_count(ptimer_state *s)
 170 {
 171     uint64_t counter;
 172
 173     if (s->enabled && s->delta != 0) {
 174         int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 175         int64_t next = s->next_event;
 176         int64_t last = s->last_event;
 177         bool expired = (now - next >= 0);
 178         bool oneshot = (s->enabled == 2);
 179
 180         /* Figure out the current counter value.  */
 181         if (expired) {
 182             /* Prevent timer underflowing if it should already have
 183                triggered.  */
 184             counter = 0;
 185         } else {
 186             uint64_t rem;
 187             uint64_t div;
 188             int clz1, clz2;
 189             int shift;
 190             uint32_t period_frac = s->period_frac;
 191             uint64_t period = s->period;
 192
 193             if (!oneshot && (s->delta * period < 10000) && !use_icount) {
 194                 period = 10000 / s->delta;
 195                 period_frac = 0;
 196             }
 197
 198             /* We need to divide time by period, where time is stored in
 199                rem (64-bit integer) and period is stored in period/period_frac
 200                (64.32 fixed point).
 201
 202                Doing full precision division is hard, so scale values and
 203                do a 64-bit division.  The result should be rounded down,
 204                so that the rounding error never causes the timer to go
 205                backwards.
 206             */
 207
 208             rem = next - now;
 209             div = period;
 210
 211             clz1 = clz64(rem);
 212             clz2 = clz64(div);
 213             shift = clz1 < clz2 ? clz1 : clz2;
 214
 215             rem <<= shift;
 216             div <<= shift;
 217             if (shift >= 32) {
 218                 div |= ((uint64_t)period_frac << (shift - 32));
 219             } else {
 220                 if (shift != 0)
 221                     div |= (period_frac >> (32 - shift));
 222                 /* Look at remaining bits of period_frac and round div up if
 223                    necessary.  */
 224                 if ((uint32_t)(period_frac << shift))
 225                     div += 1;
 226             }
 227             counter = rem / div;
 228
 229             if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
 230                 /* Before wrapping around, timer should stay with counter = 0
 231                    for a one period.  */
 232                 if (!oneshot && s->delta == s->limit) {
 233                     if (now == last) {
 234                         /* Counter == delta here, check whether it was
 235                            adjusted and if it was, then right now it is
 236                            that "one period".  */
 237                         if (counter == s->limit + DELTA_ADJUST) {
 238                             return 0;
 239                         }
 240                     } else if (counter == s->limit) {
 241                         /* Since the counter is rounded down and now != last,
 242                            the counter == limit means that delta was adjusted
 243                            by +1 and right now it is that adjusted period.  */
 244                         return 0;
 245                     }
 246                 }
 247             }
 248         }
 249
 250         if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
 251             /* If now == last then delta == limit, i.e. the counter already
 252                represents the correct value. It would be rounded down a 1ns
 253                later.  */
 254             if (now != last) {
 255                 counter += 1;
 256             }
 257         }
 258     } else {
 259         counter = s->delta;
 260     }
 261     return counter;
 262 }
 263
 264 void ptimer_set_count(ptimer_state *s, uint64_t count)
 265 {
 266     s->delta = count;
 267     if (s->enabled) {
 268         s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 269         ptimer_reload(s, 0);
 270     }
 271 }
 272
 273 void ptimer_run(ptimer_state *s, int oneshot)
 274 {
 275     bool was_disabled = !s->enabled;
 276
 277     if (was_disabled && s->period == 0) {
 278         if (!qtest_enabled()) {
 279             fprintf(stderr, "Timer with period zero, disabling\n");
 280         }
 281         return;
 282     }
 283     s->enabled = oneshot ? 2 : 1;
 284     if (was_disabled) {
 285         s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 286         ptimer_reload(s, 0);
 287     }
 288 }
 289
 290 /* Pause a timer.  Note that this may cause it to "lose" time, even if it
 291    is immediately restarted.  */
 292 void ptimer_stop(ptimer_state *s)
 293 {
 294     if (!s->enabled)
 295         return;
 296
 297     s->delta = ptimer_get_count(s);
 298     timer_del(s->timer);
 299     s->enabled = 0;
 300 }
 301
 302 /* Set counter increment interval in nanoseconds.  */
 303 void ptimer_set_period(ptimer_state *s, int64_t period)
 304 {
 305     s->delta = ptimer_get_count(s);
 306     s->period = period;
 307     s->period_frac = 0;
 308     if (s->enabled) {
 309         s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 310         ptimer_reload(s, 0);
 311     }
 312 }
 313
 314 /* Set counter frequency in Hz.  */
 315 void ptimer_set_freq(ptimer_state *s, uint32_t freq)
 316 {
 317     s->delta = ptimer_get_count(s);
 318     s->period = 1000000000ll / freq;
 319     s->period_frac = (1000000000ll << 32) / freq;
 320     if (s->enabled) {
 321         s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 322         ptimer_reload(s, 0);
 323     }
 324 }
 325
 326 /* Set the initial countdown value.  If reload is nonzero then also set
 327    count = limit.  */
 328 void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
 329 {
 330     s->limit = limit;
 331     if (reload)
 332         s->delta = limit;
 333     if (s->enabled && reload) {
 334         s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
 335         ptimer_reload(s, 0);
 336     }
 337 }
 338
 339 uint64_t ptimer_get_limit(ptimer_state *s)
 340 {
 341     return s->limit;
 342 }
 343
 344 const VMStateDescription vmstate_ptimer = {
 345     .name = "ptimer",
 346     .version_id = 1,
 347     .minimum_version_id = 1,
 348     .fields = (VMStateField[]) {
 349         VMSTATE_UINT8(enabled, ptimer_state),
 350         VMSTATE_UINT64(limit, ptimer_state),
 351         VMSTATE_UINT64(delta, ptimer_state),
 352         VMSTATE_UINT32(period_frac, ptimer_state),
 353         VMSTATE_INT64(period, ptimer_state),
 354         VMSTATE_INT64(last_event, ptimer_state),
 355         VMSTATE_INT64(next_event, ptimer_state),
 356         VMSTATE_TIMER_PTR(timer, ptimer_state),
 357         VMSTATE_END_OF_LIST()
 358     }
 359 };
 360
 361 ptimer_state *ptimer_init(QEMUBH *bh, uint8_t policy_mask)
 362 {
 363     ptimer_state *s;
 364
 365     s = (ptimer_state *)g_malloc0(sizeof(ptimer_state));
 366     s->bh = bh;
 367     s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
 368     s->policy_mask = policy_mask;
 369
 370     /*
 371      * These two policies are incompatible -- trigger-on-decrement implies
 372      * a timer trigger when the count becomes 0, but no-immediate-trigger
 373      * implies a trigger when the count stops being 0.
 374      */
 375     assert(!((policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT) &&
 376              (policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)));
 377     return s;
 378 }
 379
 380 void ptimer_free(ptimer_state *s)
 381 {
 382     qemu_bh_delete(s->bh);
 383     timer_free(s->timer);
 384     g_free(s);
 385 }