2007-09-17 01:08:06 +04:00
|
|
|
/*
|
2007-05-23 04:06:54 +04:00
|
|
|
* General purpose implementation of a simple periodic countdown timer.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2007 CodeSourcery.
|
|
|
|
*
|
2011-06-26 06:21:35 +04:00
|
|
|
* This code is licensed under the GNU LGPL.
|
2007-05-23 04:06:54 +04:00
|
|
|
*/
|
2019-08-12 08:23:45 +03:00
|
|
|
|
2016-01-26 21:17:29 +03:00
|
|
|
#include "qemu/osdep.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/timer.h"
|
2013-02-04 18:40:22 +04:00
|
|
|
#include "hw/ptimer.h"
|
2019-08-12 08:23:45 +03:00
|
|
|
#include "migration/vmstate.h"
|
2012-12-17 21:20:00 +04:00
|
|
|
#include "qemu/host-utils.h"
|
2015-09-17 19:24:56 +03:00
|
|
|
#include "sysemu/replay.h"
|
2016-09-22 20:13:07 +03:00
|
|
|
#include "sysemu/qtest.h"
|
2017-01-27 11:55:51 +03:00
|
|
|
#include "block/aio.h"
|
2017-03-03 14:01:16 +03:00
|
|
|
#include "sysemu/cpus.h"
|
2007-05-23 04:06:54 +04:00
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
#define DELTA_ADJUST 1
|
|
|
|
#define DELTA_NO_ADJUST -1
|
2016-10-24 18:26:50 +03:00
|
|
|
|
2007-05-23 04:06:54 +04:00
|
|
|
struct ptimer_state
|
|
|
|
{
|
2010-12-02 01:51:14 +03:00
|
|
|
uint8_t enabled; /* 0 = disabled, 1 = periodic, 2 = oneshot. */
|
2007-05-24 23:48:41 +04:00
|
|
|
uint64_t limit;
|
|
|
|
uint64_t delta;
|
2007-05-23 04:06:54 +04:00
|
|
|
uint32_t period_frac;
|
|
|
|
int64_t period;
|
|
|
|
int64_t last_event;
|
|
|
|
int64_t next_event;
|
2016-09-22 20:13:06 +03:00
|
|
|
uint8_t policy_mask;
|
2007-05-23 04:06:54 +04:00
|
|
|
QEMUBH *bh;
|
|
|
|
QEMUTimer *timer;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Use a bottom-half routine to avoid reentrancy issues. */
|
|
|
|
static void ptimer_trigger(ptimer_state *s)
|
|
|
|
{
|
|
|
|
if (s->bh) {
|
2015-09-17 19:24:56 +03:00
|
|
|
replay_bh_schedule_event(s->bh);
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:50 +03:00
|
|
|
static void ptimer_reload(ptimer_state *s, int delta_adjust)
|
2007-05-23 04:06:54 +04:00
|
|
|
{
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
uint32_t period_frac = s->period_frac;
|
|
|
|
uint64_t period = s->period;
|
2016-10-24 18:26:50 +03:00
|
|
|
uint64_t delta = s->delta;
|
2018-07-09 16:51:34 +03:00
|
|
|
bool suppress_trigger = false;
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
|
2018-07-09 16:51:34 +03:00
|
|
|
/*
|
|
|
|
* Note that if delta_adjust is 0 then we must be here because of
|
|
|
|
* a count register write or timer start, not because of timer expiry.
|
|
|
|
* In that case the policy might require us to suppress the timer trigger
|
|
|
|
* that we would otherwise generate for a zero delta.
|
|
|
|
*/
|
|
|
|
if (delta_adjust == 0 &&
|
|
|
|
(s->policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT)) {
|
|
|
|
suppress_trigger = true;
|
|
|
|
}
|
|
|
|
if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)
|
|
|
|
&& !suppress_trigger) {
|
2007-05-23 04:06:54 +04:00
|
|
|
ptimer_trigger(s);
|
2016-10-24 18:26:51 +03:00
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:52 +03:00
|
|
|
if (delta == 0 && !(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
|
2016-10-24 18:26:50 +03:00
|
|
|
delta = s->delta = s->limit;
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
2016-10-24 18:26:51 +03:00
|
|
|
|
|
|
|
if (s->period == 0) {
|
2016-09-22 20:13:07 +03:00
|
|
|
if (!qtest_enabled()) {
|
|
|
|
fprintf(stderr, "Timer with period zero, disabling\n");
|
|
|
|
}
|
2016-09-22 20:13:06 +03:00
|
|
|
timer_del(s->timer);
|
2007-05-23 04:06:54 +04:00
|
|
|
s->enabled = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:50 +03:00
|
|
|
if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
|
2016-10-24 18:26:51 +03:00
|
|
|
if (delta_adjust != DELTA_NO_ADJUST) {
|
|
|
|
delta += delta_adjust;
|
|
|
|
}
|
2016-10-24 18:26:50 +03:00
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
if (delta == 0 && (s->policy_mask & PTIMER_POLICY_CONTINUOUS_TRIGGER)) {
|
|
|
|
if (s->enabled == 1 && s->limit == 0) {
|
|
|
|
delta = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
|
|
|
|
if (delta_adjust != DELTA_NO_ADJUST) {
|
|
|
|
delta = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:52 +03:00
|
|
|
if (delta == 0 && (s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_RELOAD)) {
|
|
|
|
if (s->enabled == 1 && s->limit != 0) {
|
|
|
|
delta = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
if (delta == 0) {
|
|
|
|
if (!qtest_enabled()) {
|
|
|
|
fprintf(stderr, "Timer with delta zero, disabling\n");
|
|
|
|
}
|
|
|
|
timer_del(s->timer);
|
|
|
|
s->enabled = 0;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
/*
|
|
|
|
* Artificially limit timeout rate to something
|
|
|
|
* achievable under QEMU. Otherwise, QEMU spends all
|
|
|
|
* its time generating timer interrupts, and there
|
|
|
|
* is no forward progress.
|
|
|
|
* About ten microseconds is the fastest that really works
|
|
|
|
* on the current generation of host machines.
|
|
|
|
*/
|
|
|
|
|
2016-10-24 18:26:50 +03:00
|
|
|
if (s->enabled == 1 && (delta * period < 10000) && !use_icount) {
|
|
|
|
period = 10000 / delta;
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
period_frac = 0;
|
|
|
|
}
|
|
|
|
|
2007-05-23 04:06:54 +04:00
|
|
|
s->last_event = s->next_event;
|
2016-10-24 18:26:50 +03:00
|
|
|
s->next_event = s->last_event + delta * period;
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
if (period_frac) {
|
2016-10-24 18:26:50 +03:00
|
|
|
s->next_event += ((int64_t)period_frac * delta) >> 32;
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_mod(s->timer, s->next_event);
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ptimer_tick(void *opaque)
|
|
|
|
{
|
|
|
|
ptimer_state *s = (ptimer_state *)opaque;
|
2016-10-24 18:26:52 +03:00
|
|
|
bool trigger = true;
|
|
|
|
|
2007-05-23 04:06:54 +04:00
|
|
|
if (s->enabled == 2) {
|
2016-10-24 18:26:52 +03:00
|
|
|
s->delta = 0;
|
2007-05-23 04:06:54 +04:00
|
|
|
s->enabled = 0;
|
|
|
|
} else {
|
2016-10-24 18:26:51 +03:00
|
|
|
int delta_adjust = DELTA_ADJUST;
|
|
|
|
|
2016-10-24 18:26:52 +03:00
|
|
|
if (s->delta == 0 || s->limit == 0) {
|
2016-10-24 18:26:51 +03:00
|
|
|
/* If a "continuous trigger" policy is not used and limit == 0,
|
2016-10-24 18:26:52 +03:00
|
|
|
we should error out. delta == 0 means that this tick is
|
|
|
|
caused by a "no immediate reload" policy, so it shouldn't
|
|
|
|
be adjusted. */
|
2016-10-24 18:26:51 +03:00
|
|
|
delta_adjust = DELTA_NO_ADJUST;
|
2016-10-24 18:26:51 +03:00
|
|
|
}
|
|
|
|
|
2016-10-24 18:26:52 +03:00
|
|
|
if (!(s->policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)) {
|
|
|
|
/* Avoid re-trigger on deferred reload if "no immediate trigger"
|
|
|
|
policy isn't used. */
|
|
|
|
trigger = (delta_adjust == DELTA_ADJUST);
|
|
|
|
}
|
|
|
|
|
|
|
|
s->delta = s->limit;
|
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
ptimer_reload(s, delta_adjust);
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
2016-10-24 18:26:52 +03:00
|
|
|
|
|
|
|
if (trigger) {
|
|
|
|
ptimer_trigger(s);
|
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
|
2007-05-24 23:48:41 +04:00
|
|
|
uint64_t ptimer_get_count(ptimer_state *s)
|
2007-05-23 04:06:54 +04:00
|
|
|
{
|
2007-05-24 23:48:41 +04:00
|
|
|
uint64_t counter;
|
2007-05-23 04:06:54 +04:00
|
|
|
|
2016-10-24 18:26:51 +03:00
|
|
|
if (s->enabled && s->delta != 0) {
|
2016-06-06 18:59:30 +03:00
|
|
|
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
|
|
|
int64_t next = s->next_event;
|
2016-10-24 18:26:50 +03:00
|
|
|
int64_t last = s->last_event;
|
2016-06-06 18:59:30 +03:00
|
|
|
bool expired = (now - next >= 0);
|
|
|
|
bool oneshot = (s->enabled == 2);
|
|
|
|
|
2007-05-23 04:06:54 +04:00
|
|
|
/* Figure out the current counter value. */
|
2016-07-14 18:51:36 +03:00
|
|
|
if (expired) {
|
2007-05-23 04:06:54 +04:00
|
|
|
/* Prevent timer underflowing if it should already have
|
|
|
|
triggered. */
|
|
|
|
counter = 0;
|
|
|
|
} else {
|
2007-05-24 23:48:41 +04:00
|
|
|
uint64_t rem;
|
|
|
|
uint64_t div;
|
2009-03-31 18:34:24 +04:00
|
|
|
int clz1, clz2;
|
|
|
|
int shift;
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
uint32_t period_frac = s->period_frac;
|
|
|
|
uint64_t period = s->period;
|
|
|
|
|
2016-06-06 18:59:30 +03:00
|
|
|
if (!oneshot && (s->delta * period < 10000) && !use_icount) {
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
period = 10000 / s->delta;
|
|
|
|
period_frac = 0;
|
|
|
|
}
|
2009-03-31 18:34:24 +04:00
|
|
|
|
|
|
|
/* We need to divide time by period, where time is stored in
|
|
|
|
rem (64-bit integer) and period is stored in period/period_frac
|
|
|
|
(64.32 fixed point).
|
2016-10-24 18:26:50 +03:00
|
|
|
|
2009-03-31 18:34:24 +04:00
|
|
|
Doing full precision division is hard, so scale values and
|
|
|
|
do a 64-bit division. The result should be rounded down,
|
|
|
|
so that the rounding error never causes the timer to go
|
|
|
|
backwards.
|
|
|
|
*/
|
2007-05-23 04:06:54 +04:00
|
|
|
|
2016-07-14 18:51:36 +03:00
|
|
|
rem = next - now;
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
div = period;
|
2009-03-31 18:34:24 +04:00
|
|
|
|
|
|
|
clz1 = clz64(rem);
|
|
|
|
clz2 = clz64(div);
|
|
|
|
shift = clz1 < clz2 ? clz1 : clz2;
|
|
|
|
|
|
|
|
rem <<= shift;
|
|
|
|
div <<= shift;
|
|
|
|
if (shift >= 32) {
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
div |= ((uint64_t)period_frac << (shift - 32));
|
2009-03-31 18:34:24 +04:00
|
|
|
} else {
|
|
|
|
if (shift != 0)
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
div |= (period_frac >> (32 - shift));
|
2009-03-31 18:34:24 +04:00
|
|
|
/* Look at remaining bits of period_frac and round div up if
|
|
|
|
necessary. */
|
hw/ptimer: Fix issues caused by the adjusted timer limit value
Multiple issues here related to the timer with a adjusted .limit value:
1) ptimer_get_count() returns incorrect counter value for the disabled
timer after loading the counter with a small value, because adjusted limit
value is used instead of the original.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 0, 1)
4) ptimer_get_count(t) <-- would return 10000 instead of 0
2) ptimer_get_count() might return incorrect value for the timer running
with a adjusted limit value.
For instance:
1) ptimer_stop(t)
2) ptimer_set_period(t, 1)
3) ptimer_set_limit(t, 10, 1)
4) ptimer_run(t)
5) ptimer_get_count(t) <-- might return value > 10
3) Neither ptimer_set_period() nor ptimer_set_freq() are adjusting the
limit value, so it is still possible to make timer timeout value
arbitrary small.
For instance:
1) ptimer_set_period(t, 10000)
2) ptimer_set_limit(t, 1, 0)
3) ptimer_set_period(t, 1) <-- bypass limit correction
Fix all of the above issues by adjusting timer period instead of the limit.
Perform the adjustment for periodic timer only. Use the delta value instead
of the limit to make decision whether adjustment is required, as limit could
be altered while timer is running, resulting in incorrect value returned by
ptimer_get_count.
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Reviewed-by: Peter Crosthwaite <crosthwaite.peter@gmail.com>
Message-id: cd141f74f5737480ec586b9c7d18cce1d69884e2.1464367869.git.digetx@gmail.com
Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
2016-06-06 18:59:30 +03:00
|
|
|
if ((uint32_t)(period_frac << shift))
|
2009-03-31 18:34:24 +04:00
|
|
|
div += 1;
|
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
counter = rem / div;
|
2016-10-24 18:26:50 +03:00
|
|
|
|
|
|
|
if (s->policy_mask & PTIMER_POLICY_WRAP_AFTER_ONE_PERIOD) {
|
|
|
|
/* Before wrapping around, timer should stay with counter = 0
|
|
|
|
for a one period. */
|
|
|
|
if (!oneshot && s->delta == s->limit) {
|
|
|
|
if (now == last) {
|
|
|
|
/* Counter == delta here, check whether it was
|
|
|
|
adjusted and if it was, then right now it is
|
|
|
|
that "one period". */
|
|
|
|
if (counter == s->limit + DELTA_ADJUST) {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
} else if (counter == s->limit) {
|
|
|
|
/* Since the counter is rounded down and now != last,
|
|
|
|
the counter == limit means that delta was adjusted
|
|
|
|
by +1 and right now it is that adjusted period. */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
2016-10-24 18:26:52 +03:00
|
|
|
|
|
|
|
if (s->policy_mask & PTIMER_POLICY_NO_COUNTER_ROUND_DOWN) {
|
|
|
|
/* If now == last then delta == limit, i.e. the counter already
|
|
|
|
represents the correct value. It would be rounded down a 1ns
|
|
|
|
later. */
|
|
|
|
if (now != last) {
|
|
|
|
counter += 1;
|
|
|
|
}
|
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
} else {
|
|
|
|
counter = s->delta;
|
|
|
|
}
|
|
|
|
return counter;
|
|
|
|
}
|
|
|
|
|
2007-05-24 23:48:41 +04:00
|
|
|
void ptimer_set_count(ptimer_state *s, uint64_t count)
|
2007-05-23 04:06:54 +04:00
|
|
|
{
|
|
|
|
s->delta = count;
|
|
|
|
if (s->enabled) {
|
2013-08-21 19:03:08 +04:00
|
|
|
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-10-24 18:26:50 +03:00
|
|
|
ptimer_reload(s, 0);
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void ptimer_run(ptimer_state *s, int oneshot)
|
|
|
|
{
|
2016-06-06 18:59:31 +03:00
|
|
|
bool was_disabled = !s->enabled;
|
|
|
|
|
|
|
|
if (was_disabled && s->period == 0) {
|
2016-09-22 20:13:07 +03:00
|
|
|
if (!qtest_enabled()) {
|
|
|
|
fprintf(stderr, "Timer with period zero, disabling\n");
|
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
s->enabled = oneshot ? 2 : 1;
|
2016-06-06 18:59:31 +03:00
|
|
|
if (was_disabled) {
|
|
|
|
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-10-24 18:26:50 +03:00
|
|
|
ptimer_reload(s, 0);
|
2016-06-06 18:59:31 +03:00
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
|
2007-05-24 23:48:41 +04:00
|
|
|
/* Pause a timer. Note that this may cause it to "lose" time, even if it
|
2007-05-23 04:06:54 +04:00
|
|
|
is immediately restarted. */
|
|
|
|
void ptimer_stop(ptimer_state *s)
|
|
|
|
{
|
|
|
|
if (!s->enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
s->delta = ptimer_get_count(s);
|
2013-08-21 19:03:08 +04:00
|
|
|
timer_del(s->timer);
|
2007-05-23 04:06:54 +04:00
|
|
|
s->enabled = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set counter increment interval in nanoseconds. */
|
|
|
|
void ptimer_set_period(ptimer_state *s, int64_t period)
|
|
|
|
{
|
2016-06-06 18:59:30 +03:00
|
|
|
s->delta = ptimer_get_count(s);
|
2007-05-23 04:06:54 +04:00
|
|
|
s->period = period;
|
|
|
|
s->period_frac = 0;
|
2007-05-24 23:48:41 +04:00
|
|
|
if (s->enabled) {
|
2013-08-21 19:03:08 +04:00
|
|
|
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-10-24 18:26:50 +03:00
|
|
|
ptimer_reload(s, 0);
|
2007-05-24 23:48:41 +04:00
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set counter frequency in Hz. */
|
|
|
|
void ptimer_set_freq(ptimer_state *s, uint32_t freq)
|
|
|
|
{
|
2016-06-06 18:59:30 +03:00
|
|
|
s->delta = ptimer_get_count(s);
|
2007-05-23 04:06:54 +04:00
|
|
|
s->period = 1000000000ll / freq;
|
|
|
|
s->period_frac = (1000000000ll << 32) / freq;
|
2007-05-24 23:48:41 +04:00
|
|
|
if (s->enabled) {
|
2013-08-21 19:03:08 +04:00
|
|
|
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-10-24 18:26:50 +03:00
|
|
|
ptimer_reload(s, 0);
|
2007-05-24 23:48:41 +04:00
|
|
|
}
|
2007-05-23 04:06:54 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the initial countdown value. If reload is nonzero then also set
|
|
|
|
count = limit. */
|
2007-05-24 23:48:41 +04:00
|
|
|
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
|
2007-05-23 04:06:54 +04:00
|
|
|
{
|
|
|
|
s->limit = limit;
|
|
|
|
if (reload)
|
|
|
|
s->delta = limit;
|
2007-06-03 14:44:47 +04:00
|
|
|
if (s->enabled && reload) {
|
2013-08-21 19:03:08 +04:00
|
|
|
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
|
2016-10-24 18:26:50 +03:00
|
|
|
ptimer_reload(s, 0);
|
2007-05-24 23:48:41 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-06 18:59:31 +03:00
|
|
|
uint64_t ptimer_get_limit(ptimer_state *s)
|
|
|
|
{
|
|
|
|
return s->limit;
|
|
|
|
}
|
|
|
|
|
2010-12-02 01:51:14 +03:00
|
|
|
const VMStateDescription vmstate_ptimer = {
|
2009-08-31 23:30:15 +04:00
|
|
|
.name = "ptimer",
|
2010-12-02 01:51:14 +03:00
|
|
|
.version_id = 1,
|
|
|
|
.minimum_version_id = 1,
|
2014-04-16 18:01:33 +04:00
|
|
|
.fields = (VMStateField[]) {
|
2010-12-02 01:51:14 +03:00
|
|
|
VMSTATE_UINT8(enabled, ptimer_state),
|
|
|
|
VMSTATE_UINT64(limit, ptimer_state),
|
|
|
|
VMSTATE_UINT64(delta, ptimer_state),
|
|
|
|
VMSTATE_UINT32(period_frac, ptimer_state),
|
|
|
|
VMSTATE_INT64(period, ptimer_state),
|
|
|
|
VMSTATE_INT64(last_event, ptimer_state),
|
|
|
|
VMSTATE_INT64(next_event, ptimer_state),
|
2015-01-08 12:18:59 +03:00
|
|
|
VMSTATE_TIMER_PTR(timer, ptimer_state),
|
2010-12-02 01:51:14 +03:00
|
|
|
VMSTATE_END_OF_LIST()
|
|
|
|
}
|
2009-08-31 23:30:15 +04:00
|
|
|
};
|
|
|
|
|
2016-09-22 20:13:06 +03:00
|
|
|
ptimer_state *ptimer_init(QEMUBH *bh, uint8_t policy_mask)
|
2007-05-23 04:06:54 +04:00
|
|
|
{
|
|
|
|
ptimer_state *s;
|
|
|
|
|
2011-08-21 07:09:37 +04:00
|
|
|
s = (ptimer_state *)g_malloc0(sizeof(ptimer_state));
|
2007-05-23 04:06:54 +04:00
|
|
|
s->bh = bh;
|
2013-08-21 19:03:08 +04:00
|
|
|
s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
|
2016-09-22 20:13:06 +03:00
|
|
|
s->policy_mask = policy_mask;
|
2018-07-09 16:51:34 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* These two policies are incompatible -- trigger-on-decrement implies
|
|
|
|
* a timer trigger when the count becomes 0, but no-immediate-trigger
|
|
|
|
* implies a trigger when the count stops being 0.
|
|
|
|
*/
|
|
|
|
assert(!((policy_mask & PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT) &&
|
|
|
|
(policy_mask & PTIMER_POLICY_NO_IMMEDIATE_TRIGGER)));
|
2007-05-23 04:06:54 +04:00
|
|
|
return s;
|
|
|
|
}
|
2017-01-27 11:55:51 +03:00
|
|
|
|
|
|
|
void ptimer_free(ptimer_state *s)
|
|
|
|
{
|
|
|
|
qemu_bh_delete(s->bh);
|
|
|
|
timer_free(s->timer);
|
|
|
|
g_free(s);
|
|
|
|
}
|