OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

ptimer: Remove old ptimer_init_with_bh() API

Browse Source 
Now all the users of ptimers have converted to the transaction-based
API, we can remove ptimer_init_with_bh() and all the code paths
that are used only by bottom-half based ptimers, and tidy up the
documentation comments to consider the transaction-based API the
only possibility.

The code changes result from:
 * s->bh no longer exists
 * s->callback is now always non-NULL

Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-id: 20191025142411.17085-1-peter.maydell@linaro.org
This commit is contained in:
Peter Maydell 2019-11-11 13:44:16 +00:00
parent 654efcb511
commit af2a580f7e
2 changed files with 36 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
hw/core/ptimer.c
View File

@ -29,7 +29,6 @@ struct ptimer_state
int64_t last_event;
int64_t next_event;
uint8_t policy_mask;
QEMUBH *bh;
QEMUTimer *timer;
ptimer_cb callback;
void *callback_opaque;
@ -46,13 +45,8 @@ struct ptimer_state
/* Use a bottom-half routine to avoid reentrancy issues. */
static void ptimer_trigger(ptimer_state *s)
{
if (s->bh) {
replay_bh_schedule_event(s->bh);
}
if (s->callback) {
s->callback(s->callback_opaque);
}
}
static void ptimer_reload(ptimer_state *s, int delta_adjust)
{
@ -296,23 +290,18 @@ uint64_t ptimer_get_count(ptimer_state *s)
void ptimer_set_count(ptimer_state *s, uint64_t count)
{
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
s->delta = count;
if (s->enabled) {
if (!s->callback) {
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ptimer_reload(s, 0);
} else {
s->need_reload = true;
}
}
}
void ptimer_run(ptimer_state *s, int oneshot)
{
bool was_disabled = !s->enabled;
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
if (was_disabled && s->period == 0) {
if (!qtest_enabled()) {
@ -322,20 +311,15 @@ void ptimer_run(ptimer_state *s, int oneshot)
}
s->enabled = oneshot ? 2 : 1;
if (was_disabled) {
if (!s->callback) {
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ptimer_reload(s, 0);
} else {
s->need_reload = true;
}
}
}
/* Pause a timer. Note that this may cause it to "lose" time, even if it
is immediately restarted. */
void ptimer_stop(ptimer_state *s)
{
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
if (!s->enabled)
return;
@ -343,62 +327,45 @@ void ptimer_stop(ptimer_state *s)
s->delta = ptimer_get_count(s);
timer_del(s->timer);
s->enabled = 0;
if (s->callback) {
s->need_reload = false;
}
}
/* Set counter increment interval in nanoseconds. */
void ptimer_set_period(ptimer_state *s, int64_t period)
{
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
s->delta = ptimer_get_count(s);
s->period = period;
s->period_frac = 0;
if (s->enabled) {
if (!s->callback) {
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ptimer_reload(s, 0);
} else {
s->need_reload = true;
}
}
}
/* Set counter frequency in Hz. */
void ptimer_set_freq(ptimer_state *s, uint32_t freq)
{
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
s->delta = ptimer_get_count(s);
s->period = 1000000000ll / freq;
s->period_frac = (1000000000ll << 32) / freq;
if (s->enabled) {
if (!s->callback) {
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ptimer_reload(s, 0);
} else {
s->need_reload = true;
}
}
}
/* Set the initial countdown value. If reload is nonzero then also set
count = limit. */
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload)
{
assert(s->in_transaction || !s->callback);
assert(s->in_transaction);
s->limit = limit;
if (reload)
s->delta = limit;
if (s->enabled && reload) {
if (!s->callback) {
s->next_event = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL);
ptimer_reload(s, 0);
} else {
s->need_reload = true;
}
}
}
uint64_t ptimer_get_limit(ptimer_state *s)
{
@ -407,7 +374,7 @@ uint64_t ptimer_get_limit(ptimer_state *s)
void ptimer_transaction_begin(ptimer_state *s)
{
assert(!s->in_transaction || !s->callback);
assert(!s->in_transaction);
s->in_transaction = true;
s->need_reload = false;
}
@ -448,37 +415,12 @@ const VMStateDescription vmstate_ptimer = {
}
};
ptimer_state *ptimer_init_with_bh(QEMUBH *bh, uint8_t policy_mask)
{
ptimer_state *s;
s = (ptimer_state *)g_malloc0(sizeof(ptimer_state));
s->bh = bh;
s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ptimer_tick, s);
s->policy_mask = policy_mask;
/*
* 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)));
return s;
}
ptimer_state *ptimer_init(ptimer_cb callback, void *callback_opaque,
uint8_t policy_mask)
{
ptimer_state *s;
/*
* The callback function is mandatory; so we use it to distinguish
* old-style QEMUBH ptimers from new transaction API ptimers.
* (ptimer_init_with_bh() allows a NULL bh pointer and at least
* one device (digic-timer) passes NULL, so it's not the case
* that either s->bh != NULL or s->callback != NULL.)
*/
/* The callback function is mandatory. */
assert(callback);
s = g_new0(ptimer_state, 1);
@ -499,9 +441,6 @@ ptimer_state *ptimer_init(ptimer_cb callback, void *callback_opaque,
void ptimer_free(ptimer_state *s)
{
if (s->bh) {
qemu_bh_delete(s->bh);
}
timer_free(s->timer);
g_free(s);
}

45
include/hw/ptimer.h
View File

@ -10,15 +10,24 @@
#include "qemu/timer.h"
/* The ptimer API implements a simple periodic countdown timer.
/*
* The ptimer API implements a simple periodic countdown timer.
* The countdown timer has a value (which can be read and written via
* ptimer_get_count() and ptimer_set_count()). When it is enabled
* using ptimer_run(), the value will count downwards at the frequency
* which has been configured using ptimer_set_period() or ptimer_set_freq().
* When it reaches zero it will trigger a QEMU bottom half handler, and
* When it reaches zero it will trigger a callback function, and
* can be set to either reload itself from a specified limit value
* and keep counting down, or to stop (as a one-shot timer).
*
* A transaction-based API is used for modifying ptimer state: all calls
* to functions which modify ptimer state must be between matched calls to
* ptimer_transaction_begin() and ptimer_transaction_commit().
* When ptimer_transaction_commit() is called it will evaluate the state
* of the timer after all the changes in the transaction, and call the
* callback if necessary. (See the ptimer_init() documentation for the full
* list of state-modifying functions and detailed semantics of the callback.)
*
* Forgetting to set the period/frequency (or setting it to zero) is a
* bug in the QEMU device and will cause warning messages to be printed
* to stderr when the guest attempts to enable the timer.
@ -72,7 +81,7 @@
* ptimer_set_count() or ptimer_set_limit() will not trigger the timer
* (though it will cause a reload). Only a counter decrement to "0"
* will cause a trigger. Not compatible with NO_IMMEDIATE_TRIGGER;
* ptimer_init_with_bh() will assert() that you don't set both.
* ptimer_init() will assert() that you don't set both.
*/
#define PTIMER_POLICY_TRIGGER_ONLY_ON_DECREMENT (1 << 5)
@ -80,17 +89,6 @@
typedef struct ptimer_state ptimer_state;
typedef void (*ptimer_cb)(void *opaque);
/**
* ptimer_init_with_bh - Allocate and return a new ptimer
* @bh: QEMU bottom half which is run on timer expiry
* @policy: PTIMER_POLICY_* bits specifying behaviour
*
* The ptimer returned must be freed using ptimer_free().
* The ptimer takes ownership of @bh and will delete it
* when the ptimer is eventually freed.
*/
ptimer_state *ptimer_init_with_bh(QEMUBH *bh, uint8_t policy_mask);
/**
* ptimer_init - Allocate and return a new ptimer
* @callback: function to call on ptimer expiry
@ -127,8 +125,7 @@ ptimer_state *ptimer_init(ptimer_cb callback,
* ptimer_free - Free a ptimer
* @s: timer to free
*
* Free a ptimer created using ptimer_init_with_bh() (including
* deleting the bottom half which it is using).
* Free a ptimer created using ptimer_init().
*/
void ptimer_free(ptimer_state *s);
@ -164,7 +161,7 @@ void ptimer_transaction_commit(ptimer_state *s);
* may be more appropriate.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_set_period(ptimer_state *s, int64_t period);
@ -180,7 +177,7 @@ void ptimer_set_period(ptimer_state *s, int64_t period);
* precise to fractions of a nanosecond, avoiding rounding errors.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_set_freq(ptimer_state *s, uint32_t freq);
@ -210,7 +207,7 @@ uint64_t ptimer_get_limit(ptimer_state *s);
* reload the counter when their reload register is written to.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_set_limit(ptimer_state *s, uint64_t limit, int reload);
@ -234,7 +231,7 @@ uint64_t ptimer_get_count(ptimer_state *s);
* point in the future.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_set_count(ptimer_state *s, uint64_t count);
@ -243,15 +240,15 @@ void ptimer_set_count(ptimer_state *s, uint64_t count);
* @s: ptimer
* @oneshot: non-zero if this timer should only count down once
*
* Start a ptimer counting down; when it reaches zero the bottom half
* passed to ptimer_init_with_bh() will be invoked.
* Start a ptimer counting down; when it reaches zero the callback function
* passed to ptimer_init() will be invoked.
* If the @oneshot argument is zero,
* the counter value will then be reloaded from the limit and it will
* start counting down again. If @oneshot is non-zero, then the counter
* will disable itself when it reaches zero.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_run(ptimer_state *s, int oneshot);
@ -266,7 +263,7 @@ void ptimer_run(ptimer_state *s, int oneshot);
* restarted.
*
* This function will assert if it is called outside a
* ptimer_transaction_begin/commit block, unless this is a bottom-half ptimer.
* ptimer_transaction_begin/commit block.
*/
void ptimer_stop(ptimer_state *s);