The wait command will pause the monitor the command was issued in until a new event becomes available. Events are queued if there isn't a waiter present. The wait command completes after a single event is available. Today, we queue events indefinitely but in the future, I suspect we'll drop events that are older than a certain amount of time to avoid infinitely allocating memory for long running VMs. To make use of the new notification mechanism, this patch introduces a qemu_notify_event() API. This API takes three parameters: a class which is meant to classify the type of event being generated, a name which is meant to distinguish which event in the class that has been generated, and a details parameters which is meant to allow events to send arbitrary data with a given event. v1->v2 - Added a -d flag to poll for events instead of waiting - Made old events expire after 10 minutes Signed-off-by: Anthony Liguori <aliguori(a)us.ibm.com&gt; diff --git a/Makefile b/Makefile index 633774e..b87870b 100644 --- a/Makefile +++ b/Makefile @@ -84,7 +84,7 @@ OBJS+=usb-serial.o usb-net.o OBJS+=sd.o ssi-sd.o OBJS+=bt.o bt-host.o bt-vhci.o bt-l2cap.o bt-sdp.o bt-hci.o bt-hid.o usb-bt.o OBJS+=buffered_file.o migration.o migration-tcp.o net.o qemu-sockets.o -OBJS+=qemu-char.o aio.o net-checksum.o savevm.o cache-utils.o +OBJS+=qemu-char.o aio.o net-checksum.o savevm.o cache-utils.o wait.o ifdef CONFIG_BRLAPI OBJS+= baum.o diff --git a/monitor.c b/monitor.c index ca1c11c..94c14b2 100644 --- a/monitor.c +++ b/monitor.c @@ -42,6 +42,7 @@ #include "migration.h" #include "kvm.h" #include "acl.h" +#include "wait.h" //#define DEBUG //#define DEBUG_COMPLETION @@ -1745,6 +1746,8 @@ static const mon_cmd_t mon_cmds[] = { "acl allow vnc.username fred\n" "acl deny vnc.username bob\n" "acl reset vnc.username\n" }, + { "wait", "-d", do_wait, + "[-d]", "wait for an asynchronous event (use -d to poll event)" }, { NULL, NULL, }, }; diff --git a/wait.c b/wait.c new file mode 100644 index 0000000..8f6cbad --- /dev/null +++ b/wait.c @@ -0,0 +1,145 @@ +/* + * Asynchronous monitor notification support + * + * Copyright IBM, Corp. 2009 + * + * Authors: + * Anthony Liguori <aliguori(a)us.ibm.com&gt; + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ + +#include "qemu-common.h" +#include "monitor.h" +#include "sys-queue.h" +#include "osdep.h" +#include "wait.h" + +typedef struct WaitEvent +{ + qemu_timeval timestamp; + char *class; + char *name; + char *details; + TAILQ_ENTRY(WaitEvent) node; +} WaitEvent; + +typedef struct PendingWaiter +{ + Monitor *mon; + int polling; + TAILQ_ENTRY(PendingWaiter) node; +} PendingWaiter; + +/* How long do we hold on to events (in seconds) + * default to 10 minutes. */ +#define EVENT_EXPIRATION_AGE (10 * 60) + +static TAILQ_HEAD(, WaitEvent) pending_events = + TAILQ_HEAD_INITIALIZER(pending_events); +static TAILQ_HEAD(, PendingWaiter) pending_waiters = + TAILQ_HEAD_INITIALIZER(pending_waiters); + +static void free_event(WaitEvent *e) +{ + qemu_free(e->details); + qemu_free(e->name); + qemu_free(e->class); + qemu_free(e); +} + +static void dispatch_event(PendingWaiter *w, WaitEvent *e) +{ + monitor_printf(w->mon, "%ld.%06ld: %s: %s\n", + e->timestamp.tv_sec, e->timestamp.tv_usec, + e->class, e->name); + if (e->details && strlen(e->details)) { + monitor_printf(w->mon, "%s\n", e->details); + } + if (!w->polling) + monitor_resume(w->mon); +} + +static void remove_stale_events(void) +{ + qemu_timeval now; + + qemu_gettimeofday(&now); + + while (!TAILQ_EMPTY(&pending_events)) { + WaitEvent *e; + + e = TAILQ_FIRST(&pending_events); + if ((now.tv_sec - e->timestamp.tv_sec) > EVENT_EXPIRATION_AGE) { + TAILQ_REMOVE(&pending_events, e, node); + free_event(e); + } else { + break; + } + } +} + +static int try_to_process_events(void) +{ + int processed_events = 0; + + while (!TAILQ_EMPTY(&pending_events) && !TAILQ_EMPTY(&pending_waiters)) { + WaitEvent *e; + PendingWaiter *w; + + e = TAILQ_FIRST(&pending_events); + TAILQ_REMOVE(&pending_events, e, node); + + w = TAILQ_FIRST(&pending_waiters); + TAILQ_REMOVE(&pending_waiters, w, node); + + dispatch_event(w, e); + + free_event(e); + qemu_free(w); + + processed_events = 1; + } + + remove_stale_events(); + + return processed_events; +} + +void qemu_notify_event(const char *class, const char *name, const char *details) +{ + WaitEvent *e; + + e = qemu_mallocz(sizeof(*e)); + + qemu_gettimeofday(&e->timestamp); + e->class = qemu_strdup(class); + e->name = qemu_strdup(name); + if (details) + e->details = qemu_strdup(details); + + TAILQ_INSERT_TAIL(&pending_events, e, node); + + try_to_process_events(); +} + +void do_wait(Monitor *mon, int polling) +{ + PendingWaiter *w; + + w = qemu_mallocz(sizeof(*w)); + w->mon = mon; + w->polling = polling; + + TAILQ_INSERT_TAIL(&pending_waiters, w, node); + + if (!w->polling) + monitor_suspend(w->mon); + + if (!try_to_process_events() && w->polling) { + TAILQ_REMOVE(&pending_waiters, w, node); + qemu_free(w); + } +} diff --git a/wait.h b/wait.h new file mode 100644 index 0000000..3fb455f --- /dev/null +++ b/wait.h @@ -0,0 +1,23 @@ +/* + * Asynchronous monitor notification support + * + * Copyright IBM, Corp. 2009 + * + * Authors: + * Anthony Liguori <aliguori(a)us.ibm.com&gt; + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ + +#ifndef QEMU_WAIT_H +#define QEMU_WAIT_H + +#include "monitor.h" + +void qemu_notify_event(const char *class, const char *name, + const char *details); +void do_wait(Monitor *mon, int polling); + +#endif

This patch introduces a standard way to document all new events. It also enforces that documentation exists for each event. This documentation includes a description of the details parameters that the event generates. Signed-off-by: Anthony Liguori <aliguori(a)us.ibm.com&gt; diff --git a/Makefile.target b/Makefile.target index b32d1af..adfe81b 100644 --- a/Makefile.target +++ b/Makefile.target @@ -495,6 +495,7 @@ endif #CONFIG_BSD_USER ifndef CONFIG_USER_ONLY OBJS=vl.o osdep.o monitor.o pci.o loader.o isa_mmio.o machine.o dma-helpers.o +OBJS+=wait-events.o # virtio has to be here due to weird dependency between PCI and virtio-net. # need to fix this properly OBJS+=virtio.o virtio-blk.o virtio-balloon.o virtio-net.o virtio-console.o diff --git a/monitor.c b/monitor.c index 1a7d026..8aed435 100644 --- a/monitor.c +++ b/monitor.c @@ -43,6 +43,7 @@ #include "kvm.h" #include "acl.h" #include "wait.h" +#include "wait-events.h" //#define DEBUG //#define DEBUG_COMPLETION @@ -1752,6 +1753,8 @@ static const mon_cmd_t mon_cmds[] = { { "poll", "-xs?", do_poll, "[-x] [mask]", "poll for an asynchronous event (-x to make mask exclusive, mask specifies the event classes to poll for)" }, + { "show_event", "s?s?", do_show_event, "[class [name]]", + "show information about supported events" }, { NULL, NULL, }, }; diff --git a/wait-events.c b/wait-events.c new file mode 100644 index 0000000..3617ca6 --- /dev/null +++ b/wait-events.c @@ -0,0 +1,143 @@ +/* + * Asynchronous monitor notification support + * + * Copyright IBM, Corp. 2009 + * + * Authors: + * Anthony Liguori <aliguori(a)us.ibm.com&gt; + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ + +#include "qemu-common.h" +#include "wait-events.h" + +typedef struct EventDesc +{ + const char *name; + const char *short_desc; + const char *long_desc; + const char *detail_format; +} EventDesc; + +typedef struct EventClassDesc +{ + const char *class; + const char *short_desc; + const char *long_desc; + const EventDesc *events; +} EventClassDesc; + +static const EventDesc vm_state_events[] = { + { 0 }, +}; + +static const EventClassDesc vm_event_classes[] = { + { 0 }, +}; + +static const EventDesc *find_event_desc(const EventClassDesc *desc, const char *name) +{ + int i; + + for (i = 0; desc->events[i].name; i++) { + if (strcmp(desc->events[i].name, name) == 0) + return &desc->events[i]; + } + + return NULL; +} + +static const EventClassDesc *find_event_class(const char *class) +{ + int i; + + for (i = 0; vm_event_classes[i].class; i++) { + if (strcmp(vm_event_classes[i].class, class) == 0) + return &vm_event_classes[i]; + } + + return NULL; +} + +int qemu_is_notify_event_valid(const char *class, const char *name) +{ + const EventClassDesc *c; + const EventDesc *e; + + c = find_event_class(class); + if (c == NULL) + return 0; + + e = find_event_desc(c, name); + if (e == NULL) + return 0; + + return 1; +} + +static void do_show_event_name(Monitor *mon, const EventDesc *e) +{ + monitor_printf(mon, "%s\n", e->long_desc); + if (e->detail_format && strlen(e->detail_format)) { + monitor_printf(mon, "\n"); + monitor_printf(mon, "Details Format:\n"); + monitor_printf(mon, "%s\n", e->detail_format); + } +} + +static void do_show_event_class(Monitor *mon, const EventClassDesc *c) +{ + int i; + + monitor_printf(mon, "%s\n", c->long_desc); + monitor_printf(mon, "\n"); + monitor_printf(mon, "Events:\n"); + for (i = 0; c->events[i].name; i++) { + monitor_printf(mon, " %s - %s\n", + c->events[i].name, + c->events[i].short_desc); + } +} + +static void do_show_event_list(Monitor *mon) +{ + int i; + + for (i = 0; vm_event_classes[i].class; i++) { + monitor_printf(mon, "%s - %s\n", + vm_event_classes[i].class, + vm_event_classes[i].short_desc); + } +} + +void do_show_event(Monitor *mon, const char *class, const char *name) +{ + if (class && strlen(class)) { + const EventClassDesc *c; + + c = find_event_class(class); + if (c == NULL) { + monitor_printf(mon, "Unknown class: %s\n", class); + return; + } + + if (name && strlen(name)) { + const EventDesc *e; + + e = find_event_desc(c, name); + if (e == NULL) { + monitor_printf(mon, "Unknown event: %s\n", name); + return; + } + + do_show_event_name(mon, e); + } else { + do_show_event_class(mon, c); + } + } else { + do_show_event_list(mon); + } +} diff --git a/wait-events.h b/wait-events.h new file mode 100644 index 0000000..4770ec5 --- /dev/null +++ b/wait-events.h @@ -0,0 +1,23 @@ +/* + * Asynchronous monitor notification support + * + * Copyright IBM, Corp. 2009 + * + * Authors: + * Anthony Liguori <aliguori(a)us.ibm.com&gt; + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + */ + +#ifndef QEMU_WAIT_EVENTS_H +#define QEMU_WAIT_EVENTS_H + +#include "monitor.h" + +int qemu_is_notify_event_valid(const char *class, const char *name); + +void do_show_event(Monitor *mon, const char *class, const char *name); + +#endif diff --git a/wait.c b/wait.c index ebc156a..a976a72 100644 --- a/wait.c +++ b/wait.c @@ -16,6 +16,7 @@ #include "sys-queue.h" #include "osdep.h" #include "wait.h" +#include "wait-events.h" typedef struct WaitEvent { @@ -161,6 +162,11 @@ void qemu_notify_event(const char *class, const char *name, const char *details) { WaitEvent *e; + if (!qemu_is_notify_event_valid(class, name)) { + fprintf(stderr, "BUG: invalid class/name %s: %s\n", class, name); + abort(); + } + e = qemu_mallocz(sizeof(*e)); qemu_gettimeofday(&e->timestamp);

This patch adds notification whenever a client connects or disconnects via VNC. I'd like to add a lot more events especially ones that are auth related but this is at least a start. Signed-off-by: Anthony Liguori <aliguori(a)us.ibm.com&gt; diff --git a/vnc.c b/vnc.c index 6d93215..abe6bdf 100644 --- a/vnc.c +++ b/vnc.c @@ -29,6 +29,7 @@ #include "qemu_socket.h" #include "qemu-timer.h" #include "acl.h" +#include "wait.h" #define VNC_REFRESH_INTERVAL (1000 / 30) @@ -872,6 +873,15 @@ static void audio_del(VncState *vs) } } +static void vnc_send_connect_event(VncState *vs) +{ + qemu_notify_event("vnc-event", "connect", vs->peer_address); +} + +static void vnc_send_disconnect_event(VncState *vs) +{ + qemu_notify_event("vnc-event", "disconnect", vs->peer_address); +} int vnc_client_io_error(VncState *vs, int ret, int last_errno) { @@ -889,6 +899,8 @@ int vnc_client_io_error(VncState *vs, int ret, int last_errno) } } + vnc_send_disconnect_event(vs); + qemu_free(vs->peer_address); VNC_DEBUG("Closing down client sock %d %d\n", ret, ret < 0 ? last_errno : 0); qemu_set_fd_handler2(vs->csock, NULL, NULL, NULL, NULL); closesocket(vs->csock); @@ -2008,6 +2020,9 @@ static void vnc_connect(VncDisplay *vd, int csock) vs->next = vd->clients; vd->clients = vs; + + vs->peer_address = vnc_socket_remote_addr("client-address=%s:%s", vs->csock); + vnc_send_connect_event(vs); } static void vnc_listen_read(void *opaque) @@ -2055,7 +2070,6 @@ void vnc_display_init(DisplayState *ds) register_displaychangelistener(ds, dcl); } - void vnc_display_close(DisplayState *ds) { VncDisplay *vs = ds ? (VncDisplay *)ds->opaque : vnc_display; diff --git a/vnc.h b/vnc.h index 3ae95f3..745d655 100644 --- a/vnc.h +++ b/vnc.h @@ -161,6 +161,8 @@ struct VncState Buffer zlib_tmp; z_stream zlib_stream[4]; + char *peer_address; + VncState *next; }; diff --git a/wait-events.c b/wait-events.c index ecd26d2..8a2af85 100644 --- a/wait-events.c +++ b/wait-events.c @@ -45,10 +45,24 @@ static const EventDesc vm_state_events[] = { { 0 }, }; +static const EventDesc vnc_events[] = { + { "connect", "a client has connected", + "This event occurs whenever a client connects to the builtin VNC server.", + "address=host:service", }, + { "disconnect", "a client has disconnected", + "This event occurs whenever a client disconnects to the builtin VNC server.", + "client-address=host:service", }, + { 0 }, +}; + static const EventClassDesc vm_event_classes[] = { { "vm-state", "the VM start/stop state has changed", "These events occur whenever a VM's state changes.", vm_state_events, }, + { "vnc-event", "events from the builtin VNC server", + "These events are generated by the builtin VNC server. They include\n" + "connection information, authentication information, etc.", + vnc_events, }, { 0 }, }; diff --git a/wait.c b/wait.c index a976a72..33fb702 100644 --- a/wait.c +++ b/wait.c @@ -114,7 +114,7 @@ static int event_in_mask(PendingWaiter *w, WaitEvent *e) { int ret; - if (e->class == NULL) + if (w->mask == NULL) ret = 1; else ret = find_string(w->mask, e->class); @@ -128,20 +128,18 @@ static int event_in_mask(PendingWaiter *w, WaitEvent *e) static int try_to_process_events(void) { int processed_events = 0; + WaitEvent *e, *ne; - while (!TAILQ_EMPTY(&pending_events) && !TAILQ_EMPTY(&pending_waiters)) { - WaitEvent *e; + TAILQ_FOREACH_SAFE(e, &pending_events, node, ne) { PendingWaiter *w; - e = TAILQ_FIRST(&pending_events); - TAILQ_REMOVE(&pending_events, e, node); - TAILQ_FOREACH(w, &pending_waiters, node) { if (event_in_mask(w, e)) break; } if (w) { + TAILQ_REMOVE(&pending_events, e, node); TAILQ_REMOVE(&pending_waiters, w, node); dispatch_event(w, e);