diff mbox

[V5,06/28] monitor: change event functions as an implemention of new emit method

Message ID 1398918422-3019-7-git-send-email-wenchaoqemu@gmail.com
State New
Headers show

Commit Message

Wenchao Xia May 1, 2014, 4:26 a.m. UTC 
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(-)

Comments

Eric Blake May 1, 2014, 10:09 p.m. UTC | #1 
On 04/30/2014 10:26 PM, Wenchao Xia wrote:
> 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.

s/convertion/conversion/
s/would/will/

> 
> Signed-off-by: Wenchao Xia <wenchaoqemu@gmail.com>
> ---
>  monitor.c |   47 ++++++++++++++++++++++++++---------------------
>  1 files changed, 26 insertions(+), 21 deletions(-)
> 

> @@ -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);

I'm not quite sure I follow - is this comment evidence of something
temporarily broken for the duration of conversions, that gets fixed
later in the series; or are you breaking event rate limiting?
Wenchao Xia May 7, 2014, 12:53 p.m. UTC | #2 
于 2014/5/2 6:09, Eric Blake 写道:
> On 04/30/2014 10:26 PM, Wenchao Xia wrote:
>> 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.
>
> s/convertion/conversion/
> s/would/will/
>
>>
>> Signed-off-by: Wenchao Xia <wenchaoqemu@gmail.com>
>> ---
>>   monitor.c |   47 ++++++++++++++++++++++++++---------------------
>>   1 files changed, 26 insertions(+), 21 deletions(-)
>>
>
>> @@ -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);
>
> I'm not quite sure I follow - is this comment evidence of something
> temporarily broken for the duration of conversions, that gets fixed
> later in the series; or are you breaking event rate limiting?
>
   This change breaks rate limiting, but gets fixed after conversion.
Since I modified old rate limiting code to work in new event mechnism,
so old event mechnism can't work any more, unless I duplicate those
code, make things complicate.
diff mbox

Patch

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));