Now monitor has been hooked on the new event mechanism, so the patches
later can convert event callers one by one. qmp_query_events() is also
switched to use new generated event defines. Note that old function
monitor_protocol_event() is kept for existing caller to avoid code break,
but rate limiting is bypassed to avoid too many duplicated code. After
convertion, the function would be removed.
Signed-off-by: Wenchao Xia <wenchaoq...@gmail.com>
---
monitor.c | 47 ++++++++++++++++++++++++++---------------------
1 files changed, 26 insertions(+), 21 deletions(-)
diff --git a/monitor.c b/monitor.c
index 1266ba0..6482ebe 100644
--- a/monitor.c
+++ b/monitor.c
@@ -69,6 +69,8 @@
#include "qmp-commands.h"
#include "hmp.h"
#include "qemu/thread.h"
+#include "qapi/qmp-event.h"
+#include "qapi-event.h"
/* for pic/irq_info */
#if defined(TARGET_SPARC)
@@ -178,7 +180,7 @@ typedef struct MonitorControl {
* instance.
*/
typedef struct MonitorEventState {
- MonitorEvent event; /* Event being tracked */
+ QAPIEvent event; /* Event being tracked */
int64_t rate; /* Period over which to throttle. 0 to disable */
int64_t last; /* Time at which event was last emitted */
QEMUTimer *timer; /* Timer for handling delayed events */
@@ -454,6 +456,7 @@ static void timestamp_put(QDict *qdict)
}
+/* Following is kept only for monitor_protocol_event() */
static const char *monitor_event_names[] = {
[QEVENT_SHUTDOWN] = "SHUTDOWN",
[QEVENT_RESET] = "RESET",
@@ -488,13 +491,13 @@ static const char *monitor_event_names[] = {
};
QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
-MonitorEventState monitor_event_state[QEVENT_MAX];
+MonitorEventState monitor_event_state[QAPI_EVENT_MAX];
/*
* Emits the event to every monitor instance
*/
static void
-monitor_protocol_event_emit(MonitorEvent event,
+monitor_protocol_event_emit(QAPIEvent event,
QObject *data)
{
Monitor *mon;
@@ -513,12 +516,12 @@ monitor_protocol_event_emit(MonitorEvent event,
* applying any rate limiting if required.
*/
static void
-monitor_protocol_event_queue(MonitorEvent event,
- QObject *data)
+monitor_protocol_event_queue(int event_kind, QDict *data, Error **errp)
{
MonitorEventState *evstate;
+ QAPIEvent event = (QAPIEvent)event_kind;
int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
- assert(event < QEVENT_MAX);
+ assert(event < QAPI_EVENT_MAX);
evstate = &(monitor_event_state[event]);
trace_monitor_protocol_event_queue(event,
@@ -529,7 +532,7 @@ monitor_protocol_event_queue(MonitorEvent event,
/* Rate limit of 0 indicates no throttling */
if (!evstate->rate) {
- monitor_protocol_event_emit(event, data);
+ monitor_protocol_event_emit(event, QOBJECT(data));
evstate->last = now;
} else {
int64_t delta = now - evstate->last;
@@ -545,10 +548,10 @@ monitor_protocol_event_queue(MonitorEvent event,
int64_t then = evstate->last + evstate->rate;
timer_mod_ns(evstate->timer, then);
}
- evstate->data = data;
+ evstate->data = QOBJECT(data);
qobject_incref(evstate->data);
} else {
- monitor_protocol_event_emit(event, data);
+ monitor_protocol_event_emit(event, QOBJECT(data));
evstate->last = now;
}
}
@@ -587,11 +590,11 @@ static void monitor_protocol_event_handler(void *opaque)
* milliseconds
*/
static void
-monitor_protocol_event_throttle(MonitorEvent event,
+monitor_protocol_event_throttle(QAPIEvent event,
int64_t rate)
{
MonitorEventState *evstate;
- assert(event < QEVENT_MAX);
+ assert(event < QAPI_EVENT_MAX);
evstate = &(monitor_event_state[event]);
@@ -606,18 +609,19 @@ monitor_protocol_event_throttle(MonitorEvent event,
evstate->data = NULL;
}
-
/* Global, one-time initializer to configure the rate limiting
* and initialize state */
static void monitor_protocol_event_init(void)
{
/* Limit RTC & BALLOON events to 1 per second */
- monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
- monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
- monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
+ monitor_protocol_event_throttle(QAPI_EVENT_RTC_CHANGE, 1000);
+ monitor_protocol_event_throttle(QAPI_EVENT_BALLOON_CHANGE, 1000);
+ monitor_protocol_event_throttle(QAPI_EVENT_WATCHDOG, 1000);
/* limit the rate of quorum events to avoid hammering the management */
- monitor_protocol_event_throttle(QEVENT_QUORUM_REPORT_BAD, 1000);
- monitor_protocol_event_throttle(QEVENT_QUORUM_FAILURE, 1000);
+ monitor_protocol_event_throttle(QAPI_EVENT_QUORUM_REPORT_BAD, 1000);
+ monitor_protocol_event_throttle(QAPI_EVENT_QUORUM_FAILURE, 1000);
+
+ qmp_event_set_func_emit(monitor_protocol_event_queue);
}
/**
@@ -644,7 +648,8 @@ void monitor_protocol_event(MonitorEvent event, QObject
*data)
}
trace_monitor_protocol_event(event, event_name, qmp);
- monitor_protocol_event_queue(event, QOBJECT(qmp));
+ /* Bypass rate limiting for now */
+ monitor_protocol_event_emit(event, QOBJECT(qmp));
QDECREF(qmp);
}
@@ -1042,10 +1047,10 @@ CommandInfoList *qmp_query_commands(Error **errp)
EventInfoList *qmp_query_events(Error **errp)
{
EventInfoList *info, *ev_list = NULL;
- MonitorEvent e;
+ QAPIEvent e;
- for (e = 0 ; e < QEVENT_MAX ; e++) {
- const char *event_name = monitor_event_names[e];
+ for (e = 0 ; e < QAPI_EVENT_MAX ; e++) {
+ const char *event_name = QAPIEvent_lookup[e];
assert(event_name != NULL);
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
--
1.7.1
