2:16 a.m.
1. Look at the init_events function and see how it's called when you cancel the
execution of the indication_tester.py
2. Notice that when you kill the qemu process, the event_thread invokes the callback, but
the event received (look at the invoke_callback function) is a read, instead of a hangup
2:16 a.m.
New subject: [PATCH 1 of 3] Creates and register provider class GuestCrashAlertIndication
# HG changeset patch
# User Richard Maciel <rmaciel(a)linux.vnet.ibm.com>
# Date 1248549583 10800
# Node ID 23b104fd6d9cad1416d89c60750c603eef7d3381
# Parent 2e80fd8fdbc575decc0b8a1623f8b9ad9122dccf
Creates and register provider class GuestCrashAlertIndication
Signed-off-by: Richard Maciel <rmaciel(a)linux.vnet.ibm.com>
diff -r 2e80fd8fdbc5 -r 23b104fd6d9c Makefile.am
--- a/Makefile.am Fri Dec 11 18:04:28 2009 -0800
+++ b/Makefile.am Sat Jul 25 16:19:43 2009 -0300
@@ -56,7 +56,8 @@
schema/InputPool.mof \
schema/HostedAccessPoint.mof \
schema/ServiceAccessBySAP.mof \
- schema/SAPAvailableForElement.mof
+ schema/SAPAvailableForElement.mof \
+ schema/GuestCrashAlertIndication.mof
INTEROP_MOFS = \
schema/ComputerSystem.mof \
@@ -136,7 +137,8 @@
schema/InputPool.registration \
schema/HostedAccessPoint.registration \
schema/ServiceAccessBySAP.registration \
- schema/SAPAvailableForElement.registration
+ schema/SAPAvailableForElement.registration \
+ schema/GuestCrashAlertIndication.registration
INTEROP_REGS = \
schema/RegisteredProfile.registration \
diff -r 2e80fd8fdbc5 -r 23b104fd6d9c schema/GuestCrashAlertIndication.mof
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/schema/GuestCrashAlertIndication.mof Sat Jul 25 16:19:43 2009 -0300
@@ -0,0 +1,17 @@
+// Copyright IBM Corp. 2007
+
+[Description ("Xen guest crash alert"),
+ Provider("cmpi::Virt_GuestCrashAlertIndication")
+]
+class Xen_GuestCrashAlertIndication : CIM_AlertIndication
+{
+ uint32 RaiseIndication([IN] CIM_InstCreation REF TheIndication);
+};
+
+[Description ("KVM guest crash alert"),
+ Provider("cmpi::Virt_GuestCrashAlertIndication")
+]
+class KVM_GuestCrashAlertIndication : CIM_AlertIndication
+{
+ uint32 RaiseIndication([IN] CIM_InstCreation REF TheIndication);
+};
diff -r 2e80fd8fdbc5 -r 23b104fd6d9c schema/GuestCrashAlertIndication.registration
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/schema/GuestCrashAlertIndication.registration Sat Jul 25 16:19:43 2009 -0300
@@ -0,0 +1,4 @@
+# Copyright IBM Corp. 2007
+# Classname Namespace ProviderName ProviderModule ProviderTypes
+Xen_GuestCrashAlertIndication root/virt Virt_GuestCrashAlertIndicationProvider
Virt_GuestCrashAlertIndication indication method
+KVM_GuestCrashAlertIndication root/virt Virt_GuestCrashAlertIndicationProvider
Virt_GuestCrashAlertIndication indication method
2:16 a.m.
New subject: [PATCH 2 of 3] Raises GuestCrashAlertIndication when QEMU crashes
# HG changeset patch
# User Richard Maciel <rmaciel(a)linux.vnet.ibm.com>
# Date 1248549583 10800
# Node ID 22540c8901bd5a58a6631c6b449c92a3d0c5fd5b
# Parent 23b104fd6d9cad1416d89c60750c603eef7d3381
Raises GuestCrashAlertIndication when QEMU crashes
Signed-off-by: Richard Maciel <rmaciel(a)linux.vnet.ibm.com>
diff -r 23b104fd6d9c -r 22540c8901bd src/Makefile.am
--- a/src/Makefile.am Sat Jul 25 16:19:43 2009 -0300
+++ b/src/Makefile.am Sat Jul 25 16:19:43 2009 -0300
@@ -76,7 +76,8 @@
libVirt_ServiceAffectsElement.la \
libVirt_HostedAccessPoint.la \
libVirt_ServiceAccessBySAP.la \
- libVirt_SAPAvailableForElement.la
+ libVirt_SAPAvailableForElement.la \
+ libVirt_GuestCrashAlertIndication.la
libVirt_ComputerSystem_la_SOURCES = Virt_ComputerSystem.c
libVirt_ComputerSystem_la_DEPENDENCIES = libVirt_VirtualSystemSnapshotService.la
@@ -238,3 +239,7 @@
libVirt_SAPAvailableForElement_la_SOURCES = Virt_SAPAvailableForElement.c
libVirt_SAPAvailableForElement_la_LIBADD = -lVirt_ComputerSystem
-lVirt_KVMRedirectionSAP
+libVirt_GuestCrashAlertIndication_la_DEPENDENCIES = libVirt_ComputerSystem.la
+libVirt_GuestCrashAlertIndication_la_SOURCES = Virt_GuestCrashAlertIndication.c
+libVirt_GuestCrashAlertIndication_la_LIBADD = -lVirt_ComputerSystem
+
diff -r 23b104fd6d9c -r 22540c8901bd src/Virt_GuestCrashAlertIndication.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Virt_GuestCrashAlertIndication.c Sat Jul 25 16:19:43 2009 -0300
@@ -0,0 +1,524 @@
+/*
+ * Copyright IBM Corp. 2009
+ *
+ * Authors:
+ * Richard Maciel <rmaciel(a)linux.vnet.ibm.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+#include <unistd.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <pthread.h>
+
+#include <cmpidt.h>
+#include <cmpift.h>
+#include <cmpimacs.h>
+
+#include <libvirt/libvirt.h>
+
+#include <libcmpiutil/libcmpiutil.h>
+#include <misc_util.h>
+#include <libcmpiutil/std_indication.h>
+#include <cs_util.h>
+
+#include "config.h"
+#include "infostore.h"
+
+typedef struct cb_info {
+ const CMPIContext *context;
+ const CMPIObjectPath *obj_path;
+} *cb_info_ptr;
+
+static const CMPIBroker *_BROKER;
+
+#define CAI_NUM_PLATFORMS 3
+enum CAI_PLATFORMS {CAI_XEN,
+ CAI_KVM,
+ CAI_LXC,
+};
+static int active_filters[CAI_NUM_PLATFORMS];
+
+static pthread_mutex_t cb_reg_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static void set_alert_ind_props(const CMPIBroker *broker,
+ const char *classname,
+ const CMPIContext *ctx,
+ const CMPIInstance *ind)
+{
+ CMPIStatus s;
+ CMPIString *str = NULL;
+ CMPIUint16 val;
+ CMPIArray *array = NULL;
+ CMPIDateTime *time = NULL;
+
+
+ //CMSetProperty(ind, "Description", &str, CMPI_string);
+
+
+ // val 1
+ val = 1;
+ CMSetProperty(ind, "AlertType", &val, CMPI_uint16);
+
+ str = CMNewString(broker, "Virtual guest crash", &s);
+ CMSetProperty(ind, "OtherAlertType", &str, CMPI_string);
+
+ val = 7;
+ CMSetProperty(ind, "PerceivedSeverity", &val, CMPI_uint16);
+
+ // val 48
+ val = 48;
+ CMSetProperty(ind, "ProbableCause", &val, CMPI_uint16);
+
+ //CMSetProperty(ind, "ProbableCauseDescription", &str,
CMPI_string);
+
+ // val 1
+ val = 1;
+ CMSetProperty(ind, "Trending", &val, CMPI_uint16);
+
+ // This is an array
+ // CMSetProperty(ind, "RecommendedActions", &str, CMPI_string);
+
+ time = CMNewDateTime(broker, &s);
+ CMSetProperty(ind, "EventTime", &time, CMPI_dateTime);
+
+ // Kaitlin, do I need to fill this one?
+ //CMSetProperty(ind, "SystemCreationClassName", &str,
CMPI_string);
+
+ // What about this?
+ // CMSetProperty(ind, "SystemName", &str, CMPI_string);
+
+ str = CMNewString(broker, classname, &s);
+ CMSetProperty(ind, "ProviderName", &str, CMPI_string);
+
+ str = CMNewString(broker, "DTMF", &s);
+ CMSetProperty(ind, "OwningEntity", &str, CMPI_string);
+
+ str = CMNewString(broker, "322", &s);
+ CMSetProperty(ind, "MessageID", &str, CMPI_string);
+
+ //CMSetProperty(ind, "Message", &str, CMPI_string);
+
+ // This is an string array
+ array = CMNewArray(broker, 1, CMPI_stringA, &s);
+ str = CMNewString(broker,
+ "Virtual machine execution ended "
+ "unexpectly",
+ &s);
+ s = CMSetArrayElementAt(array, 0, &str, CMPI_string);
+ CMSetProperty(ind, "MessageArguments", &array, CMPI_string);
+}
+
+static CMPIStatus create_and_deliver_ind(const CMPIBroker *broker,
+ const CMPIContext *ctx,
+ struct ind_args *args,
+ const CMPIInstance *ind)
+{
+ CMPIStatus s;
+ CMPIObjectPath *ind_op = NULL;
+
+ set_alert_ind_props(broker, args->classname, ctx, ind);
+
+ ind_op = CMGetObjectPath(ind, NULL);
+ CU_DEBUG("Delivering Indication: %s",
+ CMGetCharPtr(CMObjectPathToString(ind_op, NULL)));
+
+ s = stdi_deliver(broker, ctx, args, (CMPIInstance *)ind);
+ if (s.rc == CMPI_RC_OK) {
+ CU_DEBUG("Indication delivered");
+ } else {
+ CU_DEBUG("Not delivered: %s", CMGetCharPtr(s.msg));
+ }
+
+ return s;
+}
+
+DECLARE_FILTER(xen_crashed, "Xen_GuestCrashAlertIndication");
+DECLARE_FILTER(kvm_crashed, "KVM_GuestCrashAlertIndication");
+
+static struct std_ind_filter *filters[] = {
+ &xen_crashed,
+ &kvm_crashed,
+ NULL,
+};
+
+static CMPIStatus raise_indication(const CMPIBroker *broker,
+ const CMPIContext *ctx,
+ const CMPIInstance *ind)
+{
+ CMPIStatus s = {CMPI_RC_OK, NULL};
+ CMPIObjectPath *ref = NULL;
+ struct std_indication_ctx *_ctx = NULL;
+ struct ind_args *args = NULL;
+
+ CU_DEBUG("Guest Crash Raise indication");
+
+ ref = CMGetObjectPath(ind, &s);
+ if (s.rc != CMPI_RC_OK) {
+ cu_statusf(broker, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unable to get a reference to the guest");
+ goto out;
+ }
+
+ /* FIXME: This is a Pegasus work around. Pegsus loses the namespace
+ when an ObjectPath is pulled from an instance */
+ if (STREQ(NAMESPACE(ref), ""))
+ CMSetNameSpace(ref, "root/virt");
+
+ /*s = get_domain_by_ref(broker, ref, &src_inst);
+ if (s.rc != CMPI_RC_OK || CMIsNullObject(src_inst))
+ goto out;*/
+
+ _ctx = malloc(sizeof(struct std_indication_ctx));
+ if (_ctx == NULL) {
+ cu_statusf(broker, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unable to allocate indication context");
+ goto out;
+ }
+
+ _ctx->brkr = broker;
+ _ctx->handler = NULL;
+ _ctx->filters = filters;
+ _ctx->enabled = true;
+
+ args = malloc(sizeof(struct ind_args));
+ if (args == NULL) {
+ cu_statusf(broker, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unable to allocate ind_args");
+ goto out;
+ }
+
+ args->ns = strdup(NAMESPACE(ref));
+ args->classname = strdup(CLASSNAME(ref));
+ args->_ctx = _ctx;
+
+
+ s = create_and_deliver_ind(broker, ctx, args, ind);
+
+ if (s.rc != CMPI_RC_OK) {
+ cu_statusf(_BROKER, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unable to generate indication");
+ }
+
+ out:
+ if (args != NULL)
+ stdi_free_ind_args(&args);
+
+ if (_ctx != NULL)
+ free(_ctx);
+
+ return s;
+}
+
+
+static void free_cb(void *opaque)
+{
+ cb_info_ptr cbinfo = NULL;
+
+ CU_DEBUG("Releasing memory from guest crash callback");
+
+ cbinfo = (cb_info_ptr)opaque;
+ free(cbinfo);
+}
+
+static char * inc_counter(virDomainPtr dom)
+{
+ struct infostore_ctx *store = NULL;
+ char *str = NULL;
+ uint64_t counter = 0;
+ bool ret = false;
+
+ pthread_mutex_lock(&cb_reg_mutex);
+
+ store = infostore_open(dom);
+
+ if (store == NULL) {
+ CU_DEBUG("Could not open infostore");
+ goto out;
+ }
+
+ counter = infostore_get_u64(store, "EventID");
+
+ if (counter == 0)
+ CU_DEBUG("No EventID available. Creating...");
+
+ counter++;
+
+ if (asprintf(&str, "%llu", counter) < 0) {
+ CU_DEBUG("Could not alloc memory for counter");
+ goto out;
+ }
+
+ ret = infostore_set_u64(store, "EventID", counter);
+ if (!ret) {
+ CU_DEBUG("Could not save EventID to infostore");
+ free(str);
+ }
+
+ out:
+ if (!ret)
+ str = NULL;
+
+ infostore_close(store);
+
+ pthread_mutex_unlock(&cb_reg_mutex);
+
+ return str;
+}
+
+static void preset_alert_ind_props(CMPIInstance *ind, virDomainPtr dom)
+{
+ CMPIStatus s;
+ CMPIString *str = NULL;
+ char *dom_name = (char *)virDomainGetName(dom);
+ char *counter = NULL;
+
+ if (dom_name == NULL) {
+ CU_DEBUG("Could not retrieve name of guest responsible for "
+ "crash");
+ dom_name = "Guest name not available";
+ }
+
+ str = CMNewString(_BROKER, dom_name, &s);
+ CMSetProperty(ind, "AlertingManagedElement", &str, CMPI_string);
+
+ // This property must be unique, retrieve a counter from infostore
+ counter = inc_counter(dom);
+ if (counter == NULL) {
+ CU_DEBUG("Could not retrieve counter");
+ } else {
+ str = CMNewString(_BROKER, counter, &s);
+ CMSetProperty(ind, "EventID", &str, CMPI_string);
+ free(counter);
+ }
+}
+
+static int guest_crashed_cb(virConnectPtr conn,
+ virDomainPtr dom,
+ int event,
+ int detail,
+ void *opaque)
+{
+ char *type = NULL;
+ CMPIStatus s = {CMPI_RC_OK, NULL};
+ const char *ind_name = "GuestCrashAlertIndication";
+ CMPIInstance *ind = NULL;
+ cb_info_ptr cbinfo = NULL;
+ const CMPIObjectPath *op = NULL;
+ const CMPIContext *context = NULL;
+
+ CU_DEBUG("Preparing %s", ind_name);
+
+ if (event != VIR_DOMAIN_EVENT_STOPPED_FAILED) {
+ CU_DEBUG("Event not monitored. Ignoring...");
+ return 0;
+ }
+
+ cbinfo = (cb_info_ptr)opaque;
+ op = cbinfo->obj_path;
+ context = cbinfo->context;
+
+ ind = get_typed_instance(_BROKER,
+ CLASSNAME(op),
+ ind_name,
+ NAMESPACE(op));
+
+ preset_alert_ind_props(ind, dom);
+
+ if (ind == NULL) {
+ CU_DEBUG("Failed to create ind '%s'", ind_name);
+ goto out;
+ }
+
+ type = get_typed_class(CLASSNAME(op), ind_name);
+
+ s = stdi_raise_indication(_BROKER,
+ context,
+ type,
+ NAMESPACE(op),
+ ind);
+
+ out:
+ free(type);
+
+ return s.rc != CMPI_RC_OK;
+}
+
+static int platform_from_class(const char *cn)
+{
+ if (STARTS_WITH(cn, "Xen"))
+ return CAI_XEN;
+ else if (STARTS_WITH(cn, "KVM"))
+ return CAI_KVM;
+ else if (STARTS_WITH(cn, "LXC"))
+ return CAI_LXC;
+ else
+ return -1;
+}
+
+static CMPIStatus ActivateFilter(CMPIIndicationMI* mi,
+ const CMPIContext* ctx,
+ const CMPISelectExp* se,
+ const char *ns,
+ const CMPIObjectPath* op,
+ CMPIBoolean first)
+{
+ virConnectPtr conn = NULL;
+ CMPIStatus s = {CMPI_RC_OK, NULL};
+ cb_info_ptr cbinfo = NULL;
+ int platform;
+ int ret = 0;
+
+ cbinfo = (cb_info_ptr)malloc(sizeof(struct cb_info));
+ cbinfo->context = ctx;
+ cbinfo->obj_path = op;
+
+ CU_DEBUG("ActivateFilter for %s", CLASSNAME(op));
+
+ if (CMIsNullObject(op)) {
+ cu_statusf(_BROKER, &s,
+ CMPI_RC_ERR_FAILED,
+ "No ObjectPath given");
+ goto out;
+ }
+
+ platform = platform_from_class(CLASSNAME(op));
+ if (platform < 0) {
+ cu_statusf(_BROKER, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unknown platform");
+ goto out;
+ }
+
+ pthread_mutex_lock(&cb_reg_mutex);
+
+ active_filters[platform]++;
+
+ if (active_filters[platform] == 1) {
+ conn = connect_by_classname(_BROKER, CLASSNAME(op), &s);
+
+ CU_DEBUG("Registering callback function");
+ ret = virConnectDomainEventRegister(conn,
+ guest_crashed_cb,
+ (void *)cbinfo,
+ free_cb);
+ CU_DEBUG("ret val: %d\n", ret);
+ }
+
+ pthread_mutex_unlock(&cb_reg_mutex);
+
+ out:
+ return s;
+}
+
+static CMPIStatus DeActivateFilter(CMPIIndicationMI* mi,
+ const CMPIContext* ctx,
+ const CMPISelectExp* se,
+ const char *ns,
+ const CMPIObjectPath* op,
+ CMPIBoolean last)
+{
+ virConnectPtr conn = NULL;
+ int platform;
+ int ret = 0;
+
+ CMPIStatus s = {CMPI_RC_OK, NULL};
+
+ pthread_mutex_lock(&cb_reg_mutex);
+
+ platform = platform_from_class(CLASSNAME(op));
+ if (platform < 0) {
+ cu_statusf(_BROKER, &s,
+ CMPI_RC_ERR_FAILED,
+ "Unknown platform");
+ goto out;
+ }
+
+ if (active_filters[platform] == 1) {
+ // Unregister callback
+ conn = connect_by_classname(_BROKER, CLASSNAME(op), &s);
+
+ CU_DEBUG("De-registering callback function");
+ ret = virConnectDomainEventDeregister(conn,
+ guest_crashed_cb);
+ CU_DEBUG("ret val: %d\n", ret);
+
+ }
+
+ active_filters[platform]--;
+
+ pthread_mutex_unlock(&cb_reg_mutex);
+
+ CU_DEBUG("DeActivateFilter for %s", CLASSNAME(op));
+
+ out:
+ return s;
+}
+
+static _EI_RTYPE EnableIndications(CMPIIndicationMI* mi,
+ const CMPIContext *ctx)
+{
+ CU_DEBUG("EnableIndications");
+
+ _EI_RET();
+
+}
+
+static _EI_RTYPE DisableIndications(CMPIIndicationMI* mi,
+ const CMPIContext *ctx)
+{
+ CU_DEBUG("DisableIndications");
+
+ _EI_RET();
+}
+
+
+
+static struct std_indication_handler csi = {
+ .raise_fn = raise_indication,
+ .trigger_fn = NULL,
+ .activate_fn = ActivateFilter,
+ .deactivate_fn = DeActivateFilter,
+ .enable_fn = EnableIndications,
+ .disable_fn = DisableIndications,
+};
+
+DEFAULT_IND_CLEANUP();
+DEFAULT_AF();
+DEFAULT_MP();
+
+STDI_IndicationMIStub(,
+ Virt_GuestCrashAlertIndicationProvider,
+ _BROKER,
+ libvirt_cim_init(),
+ &csi,
+ filters);
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-set-style: "K&R"
+ * tab-width: 8
+ * c-basic-offset: 8
+ * indent-tabs-mode: nil
+ * End:
+ */
2:16 a.m.
New subject: [PATCH 3 of 3] [RFC] Implement libvirt event callback management
# HG changeset patch
# User Hollis Blanchard <hollisb(a)us.ibm.com>
# Date 1250181138 25200
# Node ID 9c4cb3443e88714c2029cff3c37d59e3ab8a5a01
# Parent 22540c8901bd5a58a6631c6b449c92a3d0c5fd5b
[RFC] Implement libvirt event callback management.
Libvirt requires that users implement their own event monitoring and
callback-management infrastructure. Actually, two similar lists are needed: one
for file descriptors to monitor, and one for pending timers.
This patch starts exactly one event-monitoring thread per libvirt-cim instance.
Multiple provider threads in the same process will share this thread.
Signed-off-by: Hollis Blanchard <hollisb(a)us.ibm.com>
---
This builds but isn't tested, and may very well contain embarrassing list
manipulation or locking bugs. It really needs a consumer to test, i.e. for
someone to register a domain event callback.
Comments welcome.
Please CC me on replies.
diff -r 22540c8901bd -r 9c4cb3443e88 libxkutil/Makefile.am
--- a/libxkutil/Makefile.am Sat Jul 25 16:19:43 2009 -0300
+++ b/libxkutil/Makefile.am Thu Aug 13 09:32:18 2009 -0700
@@ -5,14 +5,14 @@
CFLAGS += $(CFLAGS_STRICT)
noinst_HEADERS = cs_util.h misc_util.h device_parsing.h xmlgen.h infostore.h \
- pool_parsing.h
+ pool_parsing.h event.h
lib_LTLIBRARIES = libxkutil.la
AM_LDFLAGS = -lvirt -luuid
libxkutil_la_SOURCES = cs_util_instance.c misc_util.c device_parsing.c \
- xmlgen.c infostore.c pool_parsing.c
+ xmlgen.c infostore.c pool_parsing.c event.c
noinst_PROGRAMS = xml_parse_test
diff -r 22540c8901bd -r 9c4cb3443e88 libxkutil/event.c
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/libxkutil/event.c Thu Aug 13 09:32:18 2009 -0700
@@ -0,0 +1,418 @@
+/*
+ * Copyright IBM Corp. 2009
+ *
+ * Authors:
+ * Hollis Blanchard <hollisb(a)us.ibm.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <errno.h>
+#include <poll.h>
+#include <values.h>
+
+#include <libvirt/libvirt.h>
+#include <libvirt/virterror.h>
+
+#include "event.h"
+
+struct timer {
+ int id;
+ int timeout;
+ void *opaque;
+ virFreeCallback ff;
+ struct timer *next;
+ bool deleted;
+};
+
+struct watch {
+ int id;
+ int fd;
+ int events;
+ virEventHandleCallback cb;
+ void *opaque;
+ virFreeCallback ff;
+ struct watch *next;
+ bool deleted;
+};
+
+static pthread_t watch_thread_id;
+
+static int next_watch_id;
+static struct watch *watch_list;
+static int watch_count;
+static pthread_mutex_t watch_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+static int next_timer_id;
+static struct timer *timer_list;
+static pthread_mutex_t timer_list_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+
+static int eventAddHandle(int fd, int events, virEventHandleCallback cb,
+ void *opaque, virFreeCallback ff)
+{
+ struct watch *watch;
+
+ CU_DEBUG("%s", __func__);
+
+ watch = malloc(sizeof(struct watch));
+ if (!watch)
+ return -ENOMEM;
+
+ CU_DEBUG("watch->fd = %d", fd);
+
+ watch->fd = fd;
+ watch->events = events;
+ watch->cb = cb;
+ watch->opaque = opaque;
+ watch->ff = ff;
+ watch->deleted = 0;
+
+ pthread_mutex_lock(&watch_list_mutex);
+
+ watch->id = next_watch_id++;
+ CU_DEBUG("watch->id = %d", watch->id);
+ watch->next = watch_list;
+ watch_list = watch;
+ watch_count++;
+
+ pthread_mutex_unlock(&watch_list_mutex);
+
+ return watch->id;
+}
+
+static void eventUpdateHandle(int id, int events)
+{
+ struct watch *cur;
+
+ CU_DEBUG("%s %d", __func__, id);
+
+ pthread_mutex_lock(&watch_list_mutex);
+
+ for (cur = watch_list; cur != NULL; cur = cur->next) {
+ if (cur->id == id) {
+ cur->events = events;
+ CU_DEBUG("id: %d, events: %d", cur->id,
cur->events);
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&watch_list_mutex);
+}
+
+/* To avoid locking problems, watches are just flagged here, and the memory is
+ * freed later. */
+static int eventRemoveHandle(int id)
+{
+ struct watch *cur;
+
+ CU_DEBUG("%s %d", __func__, id);
+
+ pthread_mutex_lock(&watch_list_mutex);
+
+ for (cur = watch_list; cur != NULL; cur = cur->next) {
+ if (cur->id == id) {
+ cur->deleted = 1;
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&watch_list_mutex);
+
+ return 0;
+}
+
+/* Delete all watches marked for deletion. */
+static void event_watch_free_deleted(void)
+{
+ struct watch *cur;
+ struct watch **link;
+
+ CU_DEBUG("%s", __func__);
+
+ pthread_mutex_lock(&watch_list_mutex);
+
+ cur = watch_list;
+ link = &watch_list;
+ while (cur != NULL) {
+ struct watch *next = cur->next;
+
+ if (cur->deleted) {
+ CU_DEBUG("Deleting id: %d", cur->id);
+ *link = next;
+
+ cur->ff(cur->opaque);
+ free(cur);
+ watch_count--;
+ } else
+ link = &cur->next;
+
+ cur = next;
+ }
+
+ pthread_mutex_unlock(&watch_list_mutex);
+}
+
+static int eventAddTimeout(int timeout, virEventTimeoutCallback cb,
+ void *opaque, virFreeCallback ff)
+{
+ struct timer *timer;
+
+ CU_DEBUG("%s", __func__);
+
+ timer = malloc(sizeof(struct timer));
+ if (!timer)
+ return -ENOMEM;
+
+ CU_DEBUG("timeout: %d", timeout);
+
+ timer->timeout = timeout;
+ timer->opaque = opaque;
+ timer->ff = ff;
+ timer->deleted = 0;
+
+ pthread_mutex_lock(&timer_list_mutex);
+
+ timer->id = next_timer_id++;
+ timer->next = timer_list;
+ timer_list = timer;
+
+ pthread_mutex_unlock(&timer_list_mutex);
+
+ return timer->id;
+}
+
+static void eventUpdateTimeout(int id, int timeout)
+{
+ struct timer *cur;
+
+ CU_DEBUG("%s %d", __func__, id);
+
+ pthread_mutex_lock(&timer_list_mutex);
+
+ for (cur = timer_list; cur != NULL; cur = cur->next) {
+ if (cur->id == id) {
+ cur->timeout = timeout;
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&timer_list_mutex);
+}
+
+static int eventRemoveTimeout(int id)
+{
+ struct timer *cur;
+
+ CU_DEBUG("%s %d", __func__, id);
+
+ pthread_mutex_lock(&timer_list_mutex);
+
+ for (cur = timer_list; cur != NULL; cur = cur->next) {
+ if (cur->id == id) {
+ cur->deleted = 1;
+ break;
+ }
+ }
+
+ pthread_mutex_unlock(&timer_list_mutex);
+
+ return 0;
+}
+
+/* Delete all timers marked for deletion. */
+static void event_timer_free_deleted(void)
+{
+ struct timer *cur;
+ struct timer **link;
+
+ CU_DEBUG("%s", __func__);
+
+ pthread_mutex_lock(&timer_list_mutex);
+
+ cur = timer_list;
+ link = &timer_list;
+ while (cur != NULL) {
+ struct timer *next = cur->next;
+
+ if (cur->deleted) {
+ CU_DEBUG("deleted timer");
+ *link = next;
+
+ cur->ff(cur->opaque);
+ free(cur);
+ } else
+ link = &cur->next;
+
+ cur = next;
+ }
+
+ pthread_mutex_unlock(&timer_list_mutex);
+}
+
+
+
+static int poll_to_libvirt_events(int pevents)
+{
+ int vevents = 0;
+
+ if (pevents & POLLIN)
+ vevents |= VIR_EVENT_HANDLE_READABLE;
+
+ if (pevents & POLLOUT)
+ vevents |= VIR_EVENT_HANDLE_WRITABLE;
+
+ if (pevents & POLLERR)
+ vevents |= VIR_EVENT_HANDLE_ERROR;
+
+ if (pevents & POLLHUP)
+ vevents |= VIR_EVENT_HANDLE_HANGUP;
+
+ return vevents;
+}
+
+static int libvirt_to_poll_events(int vevents)
+{
+ int pevents = 0;
+
+ if (vevents & VIR_EVENT_HANDLE_READABLE)
+ pevents |= POLLIN;
+
+ if (vevents & VIR_EVENT_HANDLE_WRITABLE)
+ pevents |= POLLOUT;
+
+ if (vevents & VIR_EVENT_HANDLE_ERROR)
+ pevents |= POLLERR;
+
+ if (vevents & VIR_EVENT_HANDLE_HANGUP)
+ pevents |= POLLHUP;
+
+ return pevents;
+}
+
+static void invoke_callback(struct watch *watch, struct pollfd *pollfd)
+{
+ int vevents = poll_to_libvirt_events(watch->events);
+
+ CU_DEBUG("invoke_callback. events: %d", vevents);
+
+ watch->cb(watch->id, watch->fd, vevents, watch->opaque);
+}
+
+static int event_next_timeout(void)
+{
+ struct timer *cur;
+ int closest = 10000;
+
+ for (cur = timer_list; cur != NULL; cur = cur->next) {
+ CU_DEBUG("cur->timeout: %d", cur->timeout);
+ if (cur->timeout > 0 && cur->timeout < closest)
+ closest = cur->timeout;
+ }
+
+ return closest;
+}
+
+/* One thread to watch all fds for all events for all libvirt threads. */
+static void *event_thread(void *ptr)
+{
+ while (1) {
+ struct watch *cur;
+ struct pollfd *pollfds;
+ struct pollfd *pollfd;
+ int timeout;
+ int i;
+ int pollrv;
+
+ CU_DEBUG("event_thread");
+
+ //pthread_mutex_lock(&watch_list_mutex);
+
+ pollfds = malloc(sizeof(struct pollfd) * watch_count);
+
+ /* fill in pollfds array from our watch list */
+ for (pollfd = &pollfds[0], cur = watch_list;
+ cur != NULL;
+ pollfd++, cur = cur->next) {
+ CU_DEBUG("pollfd = %d", *pollfd);
+ pollfd->fd = cur->fd;
+ pollfd->events = libvirt_to_poll_events(cur->events);
+ }
+
+ //CU_DEBUG("event_next_timeout");
+
+ timeout = event_next_timeout();
+
+ //CU_DEBUG("poll timeout: %d", timeout);
+
+ pollrv = poll(pollfds, watch_count, timeout);
+
+ //CU_DEBUG("pool");
+
+ /* invoke callbacks in case of event */
+ if (pollrv > 0) {
+ CU_DEBUG("Got movement");
+ for (i = 0; i < watch_count; i++) {
+ for (cur = watch_list; cur != NULL; cur = cur->next)
+ if (cur->fd == pollfds[i].fd
+ && !cur->deleted) {
+ CU_DEBUG("Invoke call back fds:
%d", pollfds[i]);
+ invoke_callback(cur, &pollfds[i]);
+ break;
+ }
+ }
+ } else {
+ CU_DEBUG("All clear: %d", pollrv);
+ }
+
+ //pthread_mutex_unlock(&watch_list_mutex);
+
+ free(pollfds);
+
+ event_watch_free_deleted();
+ event_timer_free_deleted();
+ }
+
+ return NULL;
+}
+
+void init_events(void)
+{
+ static pthread_mutex_t thread_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+ CU_DEBUG("%s", __func__);
+
+ pthread_mutex_lock(&thread_mutex);
+
+ if (!watch_thread_id) {
+ virEventRegisterImpl(eventAddHandle,
+ eventUpdateHandle,
+ eventRemoveHandle,
+ eventAddTimeout,
+ eventUpdateTimeout,
+ eventRemoveTimeout);
+
+ pthread_create(&watch_thread_id, NULL, event_thread, NULL);
+ }
+
+ pthread_mutex_unlock(&thread_mutex);
+}
diff -r 22540c8901bd -r 9c4cb3443e88 libxkutil/event.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/libxkutil/event.h Thu Aug 13 09:32:18 2009 -0700
@@ -0,0 +1,29 @@
+/*
+ * Copyright IBM Corp. 2009
+ *
+ * Authors:
+ * Hollis Blanchard <hollisb(a)us.ibm.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef __EVENT_H
+#define __EVENT_H
+
+#include <libcmpiutil.h>
+
+void init_events(void);
+
+#endif /* __EVENT_H */
diff -r 22540c8901bd -r 9c4cb3443e88 libxkutil/misc_util.c
--- a/libxkutil/misc_util.c Sat Jul 25 16:19:43 2009 -0300
+++ b/libxkutil/misc_util.c Thu Aug 13 09:32:18 2009 -0700
@@ -38,6 +38,7 @@
#include "misc_util.h"
#include "cs_util.h"
+#include "event.h"
#include <config.h>
@@ -489,6 +490,7 @@
bool libvirt_cim_init(void)
{
+ init_events();
return virInitialize() == 0;
}
5393
days inactive
5393
days old
3 comments
1 participants
participants (1)
-
Richard Maciel