[Qemu-devel] [PATCH V5 06/28] monitor: change event functions as an implemention of new emit method

[Wenchao Xia <wenchaoqemu@gmail.com>]

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 <wenchaoqemu@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