ptimer: Remove old ptimer_init_with_bh() API (af2a580f) · Commits · SUMMER2020 / students / proj-2021291

hw/core/ptimer.c

+15 −76

Original line number	Diff line number	Diff line
		@@ -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);
		}

include/hw/ptimer.h

+21 −24

Original line number	Diff line number	Diff line
		@@ -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);