Re: [libvirt] [PATCH] Xen Events Updated

On Fri, Nov 21, 2008 at 02:11:39PM -0500, Ben Guthro wrote: > I have integrated your changes, and moved this bit referenced below, > so it works with my setup. Could you please test with yours, and > make sure I didn't break anything? It didn't break anything, but I found more edge cases & a couple of bugs and optimizations. Changes in this version - We now also monitor IN_MOVED_TO and IN_MOVED_FROM, so that we catch 'mv foo /etc/xen' and 'mv /etc/xen/foo /tmp' as define & undefine events - On the @introduced watch handler we'll retry if we don't find the UUID / name first time around, to deal with inevitable race while XenD populates this info in xenstore. - In the @introduced & @removed handlers, simply to just check the domain ID, not name/uuid, since running VMs are unique on ID. - Fix UUID stored to be the raw unsigned char, not NULL terminated string form, so we're passing correct data into virGetDomain. This is now working reliably with my RHEL-5 Xen for all events, and should be a little more resilent on new Xen too. b/src/xen_inotify.c | 458 +++++++++++++++++++++++++++ b/src/xen_inotify.h | 31 + configure.in | 13 examples/domain-events/events-c/event-test.c | 2 include/libvirt/virterror.h | 1 po/POTFILES.in | 1 python/libvir.c | 3 src/Makefile.am | 5 src/util.c | 4 src/virterror.c | 3 src/xen_unified.c | 197 +++++++++++ src/xen_unified.h | 63 +++ src/xm_internal.c | 198 +++++++---- src/xm_internal.h | 6 src/xs_internal.c | 419 ++++++++++++++++++++++++ src/xs_internal.h | 52 +++ 16 files changed, 1383 insertions(+), 73 deletions(-) Daniel diff -r f10add69a53c configure.in --- a/configure.in Mon Nov 24 09:08:00 2008 -0500 +++ b/configure.in Mon Nov 24 09:08:01 2008 -0500 @@ -147,6 +147,8 @@ dnl Allow to build without Xen, QEMU/KVM dnl Allow to build without Xen, QEMU/KVM, test or remote driver AC_ARG_WITH([xen], [ --with-xen add XEN support (on)],[],[with_xen=yes]) +AC_ARG_WITH([xen-inotify], +[ --with-xen-inotify add XEN inotify support (on)],[],[with_xen_inotify=yes]) AC_ARG_WITH([qemu], [ --with-qemu add QEMU/KVM support (on)],[],[with_qemu=yes]) AC_ARG_WITH([uml], @@ -333,6 +335,17 @@ AM_CONDITIONAL([WITH_XEN], [test "$with_ AM_CONDITIONAL([WITH_XEN], [test "$with_xen" = "yes"]) AC_SUBST([XEN_CFLAGS]) AC_SUBST([XEN_LIBS]) + +dnl +dnl check for kernel headers required by xen_inotify +dnl +if test "$with_xen_inotify" != "no"; then + AC_CHECK_HEADER([linux/inotify.h],[],[with_xen_inotify=no]) +fi +if test "$with_xen_inotify" = "yes"; then + AC_DEFINE_UNQUOTED([WITH_XEN_INOTIFY], 1,[whether Xen inotify sub-driver is enabled]) +fi +AM_CONDITIONAL([WITH_XEN_INOTIFY], [test "$with_xen_inotify" = "yes"]) dnl dnl check for kernel headers required by src/bridge.c diff -r f10add69a53c examples/domain-events/events-c/event-test.c --- a/examples/domain-events/events-c/event-test.c Mon Nov 24 09:08:00 2008 -0500 +++ b/examples/domain-events/events-c/event-test.c Mon Nov 24 09:08:01 2008 -0500 @@ -308,7 +308,7 @@ int main(int argc, char **argv) myEventRemoveTimeoutFunc); virConnectPtr dconn = NULL; - dconn = virConnectOpen (argv[1] ? argv[1] : "qemu:///system"); + dconn = virConnectOpen (argv[1] ? argv[1] : NULL); if (!dconn) { printf("error opening\n"); return -1; diff -r f10add69a53c include/libvirt/virterror.h --- a/include/libvirt/virterror.h Mon Nov 24 09:08:00 2008 -0500 +++ b/include/libvirt/virterror.h Mon Nov 24 09:08:01 2008 -0500 @@ -60,6 +60,7 @@ typedef enum { VIR_FROM_DOMAIN, /* Error from domain config */ VIR_FROM_UML, /* Error at the UML driver */ VIR_FROM_NODEDEV, /* Error from node device monitor */ + VIR_FROM_XEN_INOTIFY, /* Error from xen inotify layer */ } virErrorDomain; diff -r f10add69a53c po/POTFILES.in --- a/po/POTFILES.in Mon Nov 24 09:08:00 2008 -0500 +++ b/po/POTFILES.in Mon Nov 24 09:08:01 2008 -0500 @@ -35,6 +35,7 @@ src/uuid.c src/uuid.c src/virsh.c src/virterror.c +src/xen_inotify.c src/xen_internal.c src/xend_internal.c src/xm_internal.c diff -r f10add69a53c python/libvir.c --- a/python/libvir.c Mon Nov 24 09:08:00 2008 -0500 +++ b/python/libvir.c Mon Nov 24 09:08:01 2008 -0500 @@ -1564,7 +1564,8 @@ getLibvirtModuleObject (void) { return libvirt_module; // PyImport_ImportModule returns a new reference - libvirt_module = PyImport_ImportModule("libvirt"); + /* Bogus (char *) cast for RHEL-5 python API brokenness */ + libvirt_module = PyImport_ImportModule((char *)"libvirt"); if(!libvirt_module) { #if DEBUG_ERROR printf("%s Error importing libvirt module\n", __FUNCTION__); diff -r f10add69a53c src/Makefile.am --- a/src/Makefile.am Mon Nov 24 09:08:00 2008 -0500 +++ b/src/Makefile.am Mon Nov 24 09:08:01 2008 -0500 @@ -101,6 +101,9 @@ XEN_DRIVER_SOURCES = \ xend_internal.c xend_internal.h \ xm_internal.c xm_internal.h \ xs_internal.c xs_internal.h +if WITH_XEN_INOTIFY +XEN_DRIVER_SOURCES += xen_inotify.c xen_inotify.h +endif LXC_DRIVER_SOURCES = \ lxc_conf.c lxc_conf.h \ @@ -188,6 +191,8 @@ libvirt_driver_la_SOURCES = \ libvirt_driver_la_CFLAGS = $(XEN_CFLAGS) libvirt_driver_la_LDFLAGS = $(XEN_LIBS) + +libvirt_driver_la_CFLAGS = $(XEN_CFLAGS) if WITH_TEST if WITH_DRIVER_MODULES diff -r f10add69a53c src/util.c --- a/src/util.c Mon Nov 24 09:08:00 2008 -0500 +++ b/src/util.c Mon Nov 24 09:08:01 2008 -0500 @@ -613,6 +613,10 @@ virRun(virConnectPtr conn, VIR_FREE(outbuf); VIR_FREE(errbuf); VIR_FREE(argv_str); + if (outfd != -1) + close(outfd); + if (errfd != -1) + close(errfd); return ret; } diff -r f10add69a53c src/virterror.c --- a/src/virterror.c Mon Nov 24 09:08:00 2008 -0500 +++ b/src/virterror.c Mon Nov 24 09:08:01 2008 -0500 @@ -262,6 +262,9 @@ virDefaultErrorFunc(virErrorPtr err) case VIR_FROM_XENSTORE: dom = "Xen Store "; break; + case VIR_FROM_XEN_INOTIFY: + dom = "Xen Inotify "; + break; case VIR_FROM_DOM: dom = "Domain "; break; diff -r f10add69a53c src/xen_inotify.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/xen_inotify.c Mon Nov 24 10:29:13 2008 -0500 @@ -0,0 +1,458 @@ +/* + * xen_inofify.c: Xen notification of xml file activity in the + * following dirs: + * /etc/xen + * /var/lib/xend/domains + * + * Copyright (C) 2008 VirtualIron + * + * 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 + * + * Author: Ben Guthro + */ +#include <config.h> +#include <dirent.h> +#include <sys/inotify.h> + +#include "virterror_internal.h" +#include "datatypes.h" +#include "driver.h" +#include "memory.h" +#include "event.h" +#include "xen_unified.h" +#include "conf.h" +#include "domain_conf.h" +#include "xen_inotify.h" +#include "xend_internal.h" +#include "logging.h" +#include "uuid.h" + +#include "xm_internal.h" /* for xenXMDomainConfigParse */ + +#define virXenInotifyError(conn, code, fmt...) \ + virReportErrorHelper(NULL, VIR_FROM_XEN_INOTIFY, code, __FILE__, \ + __FUNCTION__, __LINE__, fmt) + +#define LIBVIRTD_DOMAINS_DIR "/var/lib/xend/domains" +static const char *configDir = NULL; +static int useXenConfigCache = 0; +static xenUnifiedDomainInfoListPtr configInfoList = NULL; + +struct xenUnifiedDriver xenInotifyDriver = { + xenInotifyOpen, /* open */ + xenInotifyClose, /* close */ + NULL, /* version */ + NULL, /* hostname */ + NULL, /* URI */ + NULL, /* nodeGetInfo */ + NULL, /* getCapabilities */ + NULL, /* listDomains */ + NULL, /* numOfDomains */ + NULL, /* domainCreateLinux */ + NULL, /* domainSuspend */ + NULL, /* domainResume */ + NULL, /* domainShutdown */ + NULL, /* domainReboot */ + NULL, /* domainDestroy */ + NULL, /* domainGetOSType */ + NULL, /* domainGetMaxMemory */ + NULL, /* domainSetMaxMemory */ + NULL, /* domainSetMemory */ + NULL, /* domainGetInfo */ + NULL, /* domainSave */ + NULL, /* domainRestore */ + NULL, /* domainCoreDump */ + NULL, /* domainSetVcpus */ + NULL, /* domainPinVcpu */ + NULL, /* domainGetVcpus */ + NULL, /* domainGetMaxVcpus */ + NULL, /* listDefinedDomains */ + NULL, /* numOfDefinedDomains */ + NULL, /* domainCreate */ + NULL, /* domainDefineXML */ + NULL, /* domainUndefine */ + NULL, /* domainAttachDevice */ + NULL, /* domainDetachDevice */ + NULL, /* domainGetAutostart */ + NULL, /* domainSetAutostart */ + NULL, /* domainGetSchedulerType */ + NULL, /* domainGetSchedulerParameters */ + NULL, /* domainSetSchedulerParameters */ +}; + +static virDomainPtr +xenInotifyXenCacheLookup(virConnectPtr conn, const char *filename) { + xenXMConfCachePtr entry; + virDomainPtr dom; + + if (!(entry = virHashLookup(xenXMGetConfigCache(), filename))) { + DEBUG("No config found for %s", filename); + return NULL; + } + + if(!(dom = virGetDomain(conn, entry->def->name, + (unsigned char*)entry->def->uuid))) { + DEBUG0("Error getting dom from def"); + return NULL; + } + return dom; +} + +static virDomainPtr +xenInotifyXendDomainsDirLookup(virConnectPtr conn, const char *filename) { + int i; + virDomainPtr dom; + const char *uuid_str; + unsigned char uuid[VIR_UUID_BUFLEN]; + + /* xend is managing domains. we will get + * a filename in the manner: + * /var/lib/xend/domains/<uuid>/ + */ + uuid_str = filename + strlen(LIBVIRTD_DOMAINS_DIR) + 1; + + if (virUUIDParse(uuid_str, uuid) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "parsing uuid %s", uuid_str); + return (NULL); + } + /* call directly into xend here, as driver may not yet + be set during open while we are building our + initial list of domains */ + DEBUG("Looking for dom with uuid: %s", uuid_str); + if(!(dom = xenDaemonLookupByUUID(conn, uuid))) { + /* If we are here, the domain has gone away. + search for, and create a domain from the stored + list info */ + for (i=0; i<configInfoList->count; i++) { + if (!memcmp(uuid, configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN)) { + if(!(dom = virGetDomain(conn, configInfoList->doms[i]->name, + configInfoList->doms[i]->uuid))) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "finding dom for %s", uuid_str); + return NULL; + } + DEBUG0("Found dom on list"); + return dom; + } + } + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("finding dom on config list")); + return NULL; + } + + /* succeeded too find domain by uuid */ + return dom; +} + +static virDomainPtr +xenInotifyDomainLookup(virConnectPtr conn, const char *filename) { + virDomainPtr dom; + virDomainInfo info; + + dom = useXenConfigCache ? xenInotifyXenCacheLookup(conn, filename) : + xenInotifyXendDomainsDirLookup(conn, filename); + + if(dom) { + if ( (useXenConfigCache ? xenXMDomainGetInfo(dom, &info) : + xenDaemonDomainGetInfo(dom, &info)) < 0) + dom->id = -1; + else + dom->id = (info.state == VIR_DOMAIN_SHUTOFF) ? -1 : dom->id; + return dom; + } + return NULL; +} + +static int +xenInotifyXendDomainsDirRemoveEntry(virConnectPtr conn ATTRIBUTE_UNUSED, + const char *fname) { + const char *uuidstr = fname + strlen(LIBVIRTD_DOMAINS_DIR) + 1; + unsigned char uuid[VIR_UUID_BUFLEN]; + int i; + + if (virUUIDParse(uuidstr, uuid) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "parsing uuid %s", uuidstr); + return -1; + } + + /* match and remove on uuid */ + for (i=0; i<configInfoList->count; i++) { + if (!memcmp(uuid, configInfoList->doms[i]->uuid, VIR_UUID_BUFLEN)) { + VIR_FREE(configInfoList->doms[i]->name); + VIR_FREE(configInfoList->doms[i]); + + if (i < (configInfoList->count - 1)) + memmove(configInfoList->doms + i, + configInfoList->doms + i + 1, + sizeof(*(configInfoList->doms)) * + (configInfoList->count - (i + 1))); + + if (VIR_REALLOC_N(configInfoList->doms, + configInfoList->count - 1) < 0) { + ; /* Failure to reduce memory allocation isn't fatal */ + } + configInfoList->count--; + return 0; + } + } + return -1; +} + +static int +xenInotifyXendDomainsDirAddEntry(virConnectPtr conn, + const char *fname) { + virDomainPtr dom = xenInotifyDomainLookup(conn, fname); + if(!dom) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("Error looking up domain")); + return -1; + } + + if( xenUnifiedAddDomainInfo(configInfoList, + dom->id, dom->name, dom->uuid) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("Error adding file to config cache")); + virUnrefDomain(dom); + return -1; + } + virUnrefDomain(dom); + return 0; +} + +static int +xenInotifyRemoveDomainConfigInfo(virConnectPtr conn, + const char *fname) { + return useXenConfigCache ? xenXMConfigCacheRemoveFile(conn, fname) : + xenInotifyXendDomainsDirRemoveEntry(conn, fname); +} + +static int +xenInotifyAddDomainConfigInfo(virConnectPtr conn, + const char *fname) { + return useXenConfigCache ? xenXMConfigCacheAddFile(conn, fname) : + xenInotifyXendDomainsDirAddEntry(conn, fname); +} + +static void +xenInotifyEvent(int watch ATTRIBUTE_UNUSED, + int fd, + int events ATTRIBUTE_UNUSED, + void *data) +{ + char buf[1024]; + char fname[1024]; + struct inotify_event *e; + int got; + char *tmp, *name; + virConnectPtr conn = (virConnectPtr) data; + xenUnifiedPrivatePtr priv = NULL; + virDomainPtr dom = NULL; + + DEBUG0("got inotify event"); + + if( conn && conn->privateData ) { + priv = conn->privateData; + } else { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("conn, or private data is NULL")); + return; + } + +reread: + got = read(fd, buf, sizeof(buf)); + if (got == -1) { + if (errno == EINTR) + goto reread; + return; + } + + tmp = buf; + while (got) { + if (got < sizeof(struct inotify_event)) + return; /* bad */ + + e = (struct inotify_event *)tmp; + tmp += sizeof(struct inotify_event); + got -= sizeof(struct inotify_event); + + if (got < e->len) + return; + + tmp += e->len; + got -= e->len; + + name = (char *)&(e->name); + + snprintf(fname, 1024, "%s/%s", configDir, name); + + if (e->mask & (IN_DELETE | IN_MOVED_FROM)) { + if (!(dom = xenInotifyDomainLookup(conn, fname))) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("looking up dom")); + continue; + } + + xenUnifiedDomainEventDispatch(conn->privateData, dom, + VIR_DOMAIN_EVENT_UNDEFINED, + VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); + + + if (xenInotifyRemoveDomainConfigInfo(conn, fname) < 0 ) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("Error adding file to config cache")); + return; + } + } else if (e->mask & ( IN_CREATE | IN_CLOSE_WRITE | IN_MOVED_TO) ) { + if (xenInotifyAddDomainConfigInfo(conn, fname) < 0 ) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("Error adding file to config cache")); + return; + } + + if (!(dom = xenInotifyDomainLookup(conn, fname))) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("looking up dom")); + continue; + } + + xenUnifiedDomainEventDispatch(conn->privateData, dom, + VIR_DOMAIN_EVENT_DEFINED, + VIR_DOMAIN_EVENT_DEFINED_ADDED); + } + + } +} + +/** + * xenInotifyOpen: + * @conn: pointer to the connection block + * @name: URL for the target, NULL for local + * @flags: combination of virDrvOpenFlag(s) + * + * Connects and starts listening for inotify events + * + * Returns 0 or -1 in case of error. + */ +int +xenInotifyOpen(virConnectPtr conn ATTRIBUTE_UNUSED, + virConnectAuthPtr auth ATTRIBUTE_UNUSED, + int flags ATTRIBUTE_UNUSED) +{ + DIR *dh; + struct dirent *ent; + char path[PATH_MAX]; + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData; + + if(priv->xendConfigVersion <= 2) { + /* /etc/xen */ + configDir = xenXMGetConfigDir(); + useXenConfigCache = 1; + } else { + /* /var/lib/xend/domains/<uuid>/config.sxp */ + configDir = LIBVIRTD_DOMAINS_DIR; + useXenConfigCache = 0; + + if ( VIR_ALLOC(configInfoList ) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("failed to allocate configInfoList")); + return -1; + } + + /* populate initial list */ + if (!(dh = opendir(configDir))) { + virXenInotifyError (NULL, VIR_ERR_INTERNAL_ERROR, + "%s", strerror(errno)); + return -1; + } + while ((ent = readdir(dh))) { + if (STRPREFIX(ent->d_name, ".")) + continue; + + /* Build the full file path */ + if ((strlen(configDir) + 1 + strlen(ent->d_name) + 1) > PATH_MAX) + continue; + strcpy(path, configDir); + strcat(path, "/"); + strcat(path, ent->d_name); + + if (xenInotifyAddDomainConfigInfo(conn, path) < 0 ) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("Error adding file to config list")); + return -1; + } + } + + } + + if ((priv->inotifyFD = inotify_init()) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("initializing inotify")); + return -1; + } + + DEBUG("Adding a watch on %s", configDir); + if (inotify_add_watch(priv->inotifyFD, + configDir, + IN_CREATE | + IN_CLOSE_WRITE | IN_DELETE | + IN_MOVED_TO | IN_MOVED_FROM) < 0) { + virXenInotifyError(NULL, VIR_ERR_INTERNAL_ERROR, + "adding watch on %s", _(configDir)); + return -1; + } + + DEBUG0("Building initial config cache"); + if (useXenConfigCache && + xenXMConfigCacheRefresh (conn) < 0) { + DEBUG("Failed to enable XM config cache %s", conn->err.message); + return -1; + } + + DEBUG0("Registering with event loop"); + /* Add the handle for monitoring */ + if ((priv->inotifyWatch = virEventAddHandle(priv->inotifyFD, VIR_EVENT_HANDLE_READABLE, + xenInotifyEvent, conn, NULL)) < 0) { + DEBUG0("Failed to add inotify handle, disabling events"); + } + + conn->refs++; + return 0; +} + +/** + * xenInotifyClose: + * @conn: pointer to the connection block + * + * Close and stop listening for inotify events + * + * Returns 0 in case of success or -1 in case of error. + */ +int +xenInotifyClose(virConnectPtr conn) +{ + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData; + + if(configInfoList) + xenUnifiedDomainInfoListFree(configInfoList); + + if (priv->inotifyWatch != -1) + virEventRemoveHandle(priv->inotifyWatch); + close(priv->inotifyFD); + virUnrefConnect(conn); + + return 0; +} diff -r f10add69a53c src/xen_inotify.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/xen_inotify.h Mon Nov 24 09:08:01 2008 -0500 @@ -0,0 +1,31 @@ +/* + * xen_inofify.h: Xen notification of xml files + * + * Copyright (C) 2008 VirtualIron + * + * 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 + * + * Author: Ben Guthro + */ +#ifndef __VIR_XEN_INOTIFY_H__ +#define __VIR_XEN_INOTIFY_H__ +#include "internal.h" +extern struct xenUnifiedDriver xenInotifyDriver; + +int xenInotifyOpen (virConnectPtr conn, + virConnectAuthPtr auth, + int flags); +int xenInotifyClose (virConnectPtr conn); +#endif diff -r f10add69a53c src/xen_unified.c --- a/src/xen_unified.c Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xen_unified.c Mon Nov 24 09:46:55 2008 -0500 @@ -37,6 +37,9 @@ #include "xend_internal.h" #include "xs_internal.h" #include "xm_internal.h" +#if WITH_XEN_INOTIFY +#include "xen_inotify.h" +#endif #include "xml.h" #include "util.h" #include "memory.h" @@ -57,6 +60,9 @@ static struct xenUnifiedDriver *drivers[ [XEN_UNIFIED_XEND_OFFSET] = &xenDaemonDriver, [XEN_UNIFIED_XS_OFFSET] = &xenStoreDriver, [XEN_UNIFIED_XM_OFFSET] = &xenXMDriver, +#if WITH_XEN_INOTIFY + [XEN_UNIFIED_INOTIFY_OFFSET] = &xenInotifyDriver, +#endif }; #define xenUnifiedError(conn, code, fmt...) \ @@ -223,6 +229,7 @@ xenUnifiedOpen (virConnectPtr conn, virC { int i, ret = VIR_DRV_OPEN_DECLINED; xenUnifiedPrivatePtr priv; + virDomainEventCallbackListPtr cbList; if (conn->uri == NULL) { if (!xenUnifiedProbe()) @@ -259,6 +266,13 @@ xenUnifiedOpen (virConnectPtr conn, virC return VIR_DRV_OPEN_ERROR; } conn->privateData = priv; + + /* Allocate callback list */ + if (VIR_ALLOC(cbList) < 0) { + xenUnifiedError (NULL, VIR_ERR_NO_MEMORY, "allocating callback list"); + return VIR_DRV_OPEN_ERROR; + } + priv->domainEventCallbacks = cbList; priv->handle = -1; priv->xendConfigVersion = -1; @@ -333,6 +347,15 @@ xenUnifiedOpen (virConnectPtr conn, virC goto fail; } +#if WITH_XEN_INOTIFY + DEBUG0("Trying Xen inotify sub-driver"); + if (drivers[XEN_UNIFIED_INOTIFY_OFFSET]->open(conn, auth, flags) == + VIR_DRV_OPEN_SUCCESS) { + DEBUG0("Activated Xen inotify sub-driver"); + priv->opened[XEN_UNIFIED_INOTIFY_OFFSET] = 1; + } +#endif + return VIR_DRV_OPEN_SUCCESS; fail: @@ -357,6 +380,8 @@ xenUnifiedClose (virConnectPtr conn) int i; virCapabilitiesFree(priv->caps); + virDomainEventCallbackListFree(priv->domainEventCallbacks); + for (i = 0; i < XEN_UNIFIED_NR_DRIVERS; ++i) if (priv->opened[i] && drivers[i]->close) (void) drivers[i]->close (conn); @@ -1290,6 +1315,40 @@ xenUnifiedNodeGetFreeMemory (virConnectP xenUnifiedError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); return(0); +} + +static int +xenUnifiedDomainEventRegister (virConnectPtr conn, + void *callback, + void *opaque, + void (*freefunc)(void *)) +{ + GET_PRIVATE (conn); + if (priv->xsWatch == -1) { + xenUnifiedError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + return -1; + } + + conn->refs++; + return virDomainEventCallbackListAdd(conn, priv->domainEventCallbacks, + callback, opaque, freefunc); +} + +static int +xenUnifiedDomainEventDeregister (virConnectPtr conn, + void *callback) +{ + int ret; + GET_PRIVATE (conn); + if (priv->xsWatch == -1) { + xenUnifiedError (conn, VIR_ERR_NO_SUPPORT, __FUNCTION__); + return -1; + } + + ret = virDomainEventCallbackListRemove(conn, priv->domainEventCallbacks, + callback); + virUnrefConnect(conn); + return ret; } /*----- Register with libvirt.c, and initialise Xen drivers. -----*/ @@ -1356,6 +1415,8 @@ static virDriver xenUnifiedDriver = { .domainBlockPeek = xenUnifiedDomainBlockPeek, .nodeGetCellsFreeMemory = xenUnifiedNodeGetCellsFreeMemory, .getFreeMemory = xenUnifiedNodeGetFreeMemory, + .domainEventRegister = xenUnifiedDomainEventRegister, + .domainEventDeregister = xenUnifiedDomainEventDeregister, }; /** @@ -1375,3 +1436,139 @@ xenRegister (void) return virRegisterDriver (&xenUnifiedDriver); } +/** + * xenUnifiedDomainInfoListFree: + * + * Free the Domain Info List + */ +void +xenUnifiedDomainInfoListFree(xenUnifiedDomainInfoListPtr list) +{ + int i; + for (i=0; i<list->count; i++) { + VIR_FREE(list->doms[i]->name); + VIR_FREE(list->doms[i]); + } + VIR_FREE(list); +} + +/** + * xenUnifiedAddDomainInfo: + * + * Add name and uuid to the domain info list + * + * Returns: 0 on success, -1 on failure + */ +int +xenUnifiedAddDomainInfo(xenUnifiedDomainInfoListPtr list, + int id, char *name, + unsigned char *uuid) +{ + xenUnifiedDomainInfoPtr info; + int n; + + /* check if we already have this callback on our list */ + for (n=0; n < list->count; n++) { + if (STREQ(list->doms[n]->name, name) && + !memcmp(list->doms[n]->uuid, uuid, VIR_UUID_BUFLEN)) { + DEBUG0("WARNING: dom already tracked"); + return -1; + } + } + + if (VIR_ALLOC(info) < 0) + goto memory_error; + if (!(info->name = strdup(name))) + goto memory_error; + + memcpy(info->uuid, uuid, VIR_UUID_BUFLEN); + info->id = id; + + /* Make space on list */ + n = list->count; + if (VIR_REALLOC_N(list->doms, n + 1) < 0) { + goto memory_error; + } + + list->doms[n] = info; + list->count++; + return 0; +memory_error: + xenUnifiedError (NULL, VIR_ERR_NO_MEMORY, "allocating domain info"); + if (info) + VIR_FREE(info->name); + VIR_FREE(info); + return -1; +} + +/** + * xenUnifiedRemoveDomainInfo: + * + * Removes name and uuid to the domain info list + * + * Returns: 0 on success, -1 on failure + */ +int +xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr list, + int id, char *name, + unsigned char *uuid) +{ + int i; + for (i = 0 ; i < list->count ; i++) { + if( list->doms[i]->id == id && + STREQ(list->doms[i]->name, name) && + !memcmp(list->doms[i]->uuid, uuid, VIR_UUID_BUFLEN)) { + + VIR_FREE(list->doms[i]->name); + VIR_FREE(list->doms[i]); + + if (i < (list->count - 1)) + memmove(list->doms + i, + list->doms + i + 1, + sizeof(*(list->doms)) * + (list->count - (i + 1))); + + if (VIR_REALLOC_N(list->doms, + list->count - 1) < 0) { + ; /* Failure to reduce memory allocation isn't fatal */ + } + list->count--; + + return 0; + } + } + return -1; +} + +/** + * xenUnifiedDomainEventDispatch: + * + * Dispatch domain events to registered callbacks + * + */ +void xenUnifiedDomainEventDispatch (xenUnifiedPrivatePtr priv, + virDomainPtr dom, + int event, + int detail) +{ + int i; + virDomainEventCallbackListPtr cbList; + + if(!priv) return; + + cbList = priv->domainEventCallbacks; + if(!cbList) return; + + for(i=0 ; i < cbList->count ; i++) { + if(cbList->callbacks[i] && cbList->callbacks[i]->cb) { + if (dom) { + DEBUG("Dispatching callback %p %p event %d", + cbList->callbacks[i], + cbList->callbacks[i]->cb, event); + cbList->callbacks[i]->cb(cbList->callbacks[i]->conn, + dom, event, detail, + cbList->callbacks[i]->opaque); + } + } + } +} diff -r f10add69a53c src/xen_unified.h --- a/src/xen_unified.h Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xen_unified.h Mon Nov 24 10:18:38 2008 -0500 @@ -14,6 +14,12 @@ #include "internal.h" #include "capabilities.h" #include "driver.h" +#include "domain_conf.h" +#include "xs_internal.h" +#if WITH_XEN_INOTIFY +#include "xen_inotify.h" +#endif +#include "domain_event.h" #ifndef HAVE_WINSOCK2_H #include <sys/un.h> @@ -29,7 +35,13 @@ extern int xenRegister (void); #define XEN_UNIFIED_XEND_OFFSET 2 #define XEN_UNIFIED_XS_OFFSET 3 #define XEN_UNIFIED_XM_OFFSET 4 + +#if WITH_XEN_INOTIFY +#define XEN_UNIFIED_INOTIFY_OFFSET 5 +#define XEN_UNIFIED_NR_DRIVERS 6 +#else #define XEN_UNIFIED_NR_DRIVERS 5 +#endif #define MIN_XEN_GUEST_SIZE 64 /* 64 megabytes */ @@ -85,6 +97,33 @@ struct xenUnifiedDriver { virDrvDomainSetSchedulerParameters domainSetSchedulerParameters; }; +typedef struct xenXMConfCache *xenXMConfCachePtr; +typedef struct xenXMConfCache { + time_t refreshedAt; + char filename[PATH_MAX]; + virDomainDefPtr def; +} xenXMConfCache; + +/* xenUnifiedDomainInfoPtr: + * The minimal state we have about active domains + * This is the minmal info necessary to still get a + * virDomainPtr when the domain goes away + */ +struct _xenUnifiedDomainInfo { + int id; + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; +}; +typedef struct _xenUnifiedDomainInfo xenUnifiedDomainInfo; +typedef xenUnifiedDomainInfo *xenUnifiedDomainInfoPtr; + +struct _xenUnifiedDomainInfoList { + unsigned int count; + xenUnifiedDomainInfoPtr *doms; +}; +typedef struct _xenUnifiedDomainInfoList xenUnifiedDomainInfoList; +typedef xenUnifiedDomainInfoList *xenUnifiedDomainInfoListPtr; + /* xenUnifiedPrivatePtr: * * Per-connection private data, stored in conn->privateData. All Xen @@ -113,6 +152,19 @@ struct _xenUnifiedPrivate { * xen_unified.c. */ int opened[XEN_UNIFIED_NR_DRIVERS]; + + /* A list of xenstore watches */ + xenStoreWatchListPtr xsWatchList; + int xsWatch; + + /* An list of callbacks */ + virDomainEventCallbackListPtr domainEventCallbacks; + +#if WITH_XEN_INOTIFY + /* The inotify fd */ + int inotifyFD; + int inotifyWatch; +#endif }; typedef struct _xenUnifiedPrivate *xenUnifiedPrivatePtr; @@ -122,4 +174,15 @@ int xenNbCpus(virConnectPtr conn); int xenNbCpus(virConnectPtr conn); char *xenDomainUsedCpus(virDomainPtr dom); +void xenUnifiedDomainInfoListFree(xenUnifiedDomainInfoListPtr info); +int xenUnifiedAddDomainInfo(xenUnifiedDomainInfoListPtr info, + int id, char *name, + unsigned char *uuid); +int xenUnifiedRemoveDomainInfo(xenUnifiedDomainInfoListPtr info, + int id, char *name, + unsigned char *uuid); +void xenUnifiedDomainEventDispatch (xenUnifiedPrivatePtr priv, + virDomainPtr dom, + int event, + int detail); #endif /* __VIR_XEN_UNIFIED_H__ */ diff -r f10add69a53c src/xm_internal.c --- a/src/xm_internal.c Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xm_internal.c Mon Nov 24 09:08:01 2008 -0500 @@ -45,6 +45,8 @@ #include "uuid.h" #include "util.h" #include "memory.h" +#include "logging.h" + /* The true Xen limit varies but so far is always way less than 1024, which is the Linux kernel limit according @@ -53,13 +55,6 @@ static int xenXMConfigSetString(virConfPtr conf, const char *setting, const char *str); - -typedef struct xenXMConfCache *xenXMConfCachePtr; -typedef struct xenXMConfCache { - time_t refreshedAt; - char filename[PATH_MAX]; - virDomainDefPtr def; -} xenXMConfCache; static char configDir[PATH_MAX]; /* Config file name to config object */ @@ -124,6 +119,14 @@ struct xenUnifiedDriver xenXMDriver = { NULL, /* domainSetSchedulerParameters */ }; +virHashTablePtr xenXMGetConfigCache (void) { + return configCache; +} + +char *xenXMGetConfigDir (void) { + return configDir; +} + #define xenXMError(conn, code, fmt...) \ virReportErrorHelper(conn, VIR_FROM_XENXM, code, __FILE__, \ __FUNCTION__, __LINE__, fmt) @@ -371,13 +374,121 @@ xenXMConfigSaveFile(virConnectPtr conn, return ret; } +int +xenXMConfigCacheRemoveFile(virConnectPtr conn ATTRIBUTE_UNUSED, + const char *filename) +{ + xenXMConfCachePtr entry; + + entry = virHashLookup(configCache, filename); + if (!entry) { + DEBUG("No config entry for %s", filename); + return 0; + } + + virHashRemoveEntry(nameConfigMap, entry->def->name, NULL); + virHashRemoveEntry(configCache, filename, xenXMConfigFree); + DEBUG("Removed %s %s", entry->def->name, filename); + return 0; +} + + +int +xenXMConfigCacheAddFile(virConnectPtr conn, const char *filename) +{ + xenXMConfCachePtr entry; + struct stat st; + int newborn = 0; + time_t now = time(NULL); + + DEBUG("Adding file %s", filename); + + /* Get modified time */ + if ((stat(filename, &st) < 0)) { + xenXMError (conn, VIR_ERR_INTERNAL_ERROR, + "cannot stat %s: %s", filename, strerror(errno)); + return -1; + } + + /* Ignore zero length files, because inotify fires before + any content has actually been created */ + if (st.st_size == 0) { + DEBUG("Ignoring zero length file %s", filename); + return -1; + } + + /* If we already have a matching entry and it is not + modified, then carry on to next one*/ + if ((entry = virHashLookup(configCache, filename))) { + char *nameowner; + + if (entry->refreshedAt >= st.st_mtime) { + entry->refreshedAt = now; + /* return success if up-to-date */ + return 0; + } + + /* If we currently own the name, then release it and + re-acquire it later - just in case it was renamed */ + nameowner = (char *)virHashLookup(nameConfigMap, entry->def->name); + if (nameowner && STREQ(nameowner, filename)) { + virHashRemoveEntry(nameConfigMap, entry->def->name, NULL); + } + + /* Clear existing config entry which needs refresh */ + virDomainDefFree(entry->def); + entry->def = NULL; + } else { /* Completely new entry */ + newborn = 1; + if (VIR_ALLOC(entry) < 0) { + xenXMError (conn, VIR_ERR_NO_MEMORY, "%s", strerror(errno)); + return -1; + } + memcpy(entry->filename, filename, PATH_MAX); + } + entry->refreshedAt = now; + + if (!(entry->def = xenXMConfigReadFile(conn, entry->filename))) { + DEBUG("Failed to read %s", entry->filename); + if (!newborn) + virHashRemoveEntry(configCache, filename, NULL); + VIR_FREE(entry); + return -1; + } + + /* If its a completely new entry, it must be stuck into + the cache (refresh'd entries are already registered) */ + if (newborn) { + if (virHashAddEntry(configCache, entry->filename, entry) < 0) { + virDomainDefFree(entry->def); + VIR_FREE(entry); + xenXMError (conn, VIR_ERR_INTERNAL_ERROR, + "%s", _("xenXMConfigCacheRefresh: virHashAddEntry")); + return -1; + } + } + + /* See if we need to map this config file in as the primary owner + * of the domain in question + */ + if (!virHashLookup(nameConfigMap, entry->def->name)) { + if (virHashAddEntry(nameConfigMap, entry->def->name, entry->filename) < 0) { + virHashRemoveEntry(configCache, filename, NULL); + virDomainDefFree(entry->def); + VIR_FREE(entry); + } + } + DEBUG("Added config %s %s", entry->def->name, filename); + + return 0; +} /* This method is called by various methods to scan /etc/xen (or whatever directory was set by LIBVIRT_XM_CONFIG_DIR environment variable) and process any domain configs. It has rate-limited so never rescans more frequently than once every X seconds */ -static int xenXMConfigCacheRefresh (virConnectPtr conn) { +int xenXMConfigCacheRefresh (virConnectPtr conn) { DIR *dh; struct dirent *ent; time_t now = time(NULL); @@ -401,9 +512,7 @@ static int xenXMConfigCacheRefresh (virC } while ((ent = readdir(dh))) { - xenXMConfCachePtr entry; struct stat st; - int newborn = 0; char path[PATH_MAX]; /* @@ -447,62 +556,8 @@ static int xenXMConfigCacheRefresh (virC /* If we already have a matching entry and it is not modified, then carry on to next one*/ - if ((entry = virHashLookup(configCache, path))) { - char *nameowner; - - if (entry->refreshedAt >= st.st_mtime) { - entry->refreshedAt = now; - continue; - } - - /* If we currently own the name, then release it and - re-acquire it later - just in case it was renamed */ - nameowner = (char *)virHashLookup(nameConfigMap, entry->def->name); - if (nameowner && STREQ(nameowner, path)) { - virHashRemoveEntry(nameConfigMap, entry->def->name, NULL); - } - - /* Clear existing config entry which needs refresh */ - virDomainDefFree(entry->def); - entry->def = NULL; - } else { /* Completely new entry */ - newborn = 1; - if (VIR_ALLOC(entry) < 0) { - xenXMError (conn, VIR_ERR_NO_MEMORY, "%s", strerror(errno)); - goto cleanup; - } - memcpy(entry->filename, path, PATH_MAX); - } - entry->refreshedAt = now; - - if (!(entry->def = xenXMConfigReadFile(conn, entry->filename))) { - if (!newborn) - virHashRemoveEntry(configCache, path, NULL); - VIR_FREE(entry); - continue; - } - - /* If its a completely new entry, it must be stuck into - the cache (refresh'd entries are already registered) */ - if (newborn) { - if (virHashAddEntry(configCache, entry->filename, entry) < 0) { - virDomainDefFree(entry->def); - VIR_FREE(entry); - xenXMError (conn, VIR_ERR_INTERNAL_ERROR, - "%s", _("xenXMConfigCacheRefresh: virHashAddEntry")); - goto cleanup; - } - } - - /* See if we need to map this config file in as the primary owner - * of the domain in question - */ - if (!virHashLookup(nameConfigMap, entry->def->name)) { - if (virHashAddEntry(nameConfigMap, entry->def->name, entry->filename) < 0) { - virHashRemoveEntry(configCache, ent->d_name, NULL); - virDomainDefFree(entry->def); - VIR_FREE(entry); - } + if (xenXMConfigCacheAddFile(conn, path) < 0) { + /* Ignoring errors, since alot of stuff goes wrong in /etc/xen */ } } @@ -513,7 +568,6 @@ static int xenXMConfigCacheRefresh (virC virHashRemoveSet(configCache, xenXMConfigReaper, xenXMConfigFree, (const void*) &now); ret = 0; - cleanup: if (dh) closedir(dh); @@ -1503,8 +1557,10 @@ virDomainPtr xenXMDomainLookupByName(vir return (NULL); } +#ifndef WITH_XEN_INOTIFY if (xenXMConfigCacheRefresh (conn) < 0) return (NULL); +#endif if (!(filename = virHashLookup(nameConfigMap, domname))) return (NULL); @@ -1555,8 +1611,10 @@ virDomainPtr xenXMDomainLookupByUUID(vir return (NULL); } +#ifndef WITH_XEN_INOTIFY if (xenXMConfigCacheRefresh (conn) < 0) return (NULL); +#endif if (!(entry = virHashSearch(configCache, xenXMDomainSearchForUUID, (const void *)uuid))) { return (NULL); @@ -2208,8 +2266,10 @@ virDomainPtr xenXMDomainDefineXML(virCon if (conn->flags & VIR_CONNECT_RO) return (NULL); +#ifndef WITH_XEN_INOTIFY if (xenXMConfigCacheRefresh (conn) < 0) return (NULL); +#endif if (!(def = virDomainDefParseString(conn, priv->caps, xml))) return (NULL); @@ -2376,8 +2436,10 @@ int xenXMListDefinedDomains(virConnectPt return (-1); } +#ifndef WITH_XEN_INOTIFY if (xenXMConfigCacheRefresh (conn) < 0) return (-1); +#endif if (maxnames > virHashSize(configCache)) maxnames = virHashSize(configCache); @@ -2401,8 +2463,10 @@ int xenXMNumOfDefinedDomains(virConnectP return (-1); } +#ifndef WITH_XEN_INOTIFY if (xenXMConfigCacheRefresh (conn) < 0) return (-1); +#endif return virHashSize(nameConfigMap); } diff -r f10add69a53c src/xm_internal.h --- a/src/xm_internal.h Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xm_internal.h Mon Nov 24 09:08:01 2008 -0500 @@ -32,6 +32,12 @@ extern struct xenUnifiedDriver xenXMDriv extern struct xenUnifiedDriver xenXMDriver; int xenXMInit (void); +virHashTablePtr xenXMGetConfigCache(void); +char *xenXMGetConfigDir(void); +int xenXMConfigCacheRefresh (virConnectPtr conn); +int xenXMConfigCacheAddFile(virConnectPtr conn, const char *filename); +int xenXMConfigCacheRemoveFile(virConnectPtr conn, const char *filename); + int xenXMOpen(virConnectPtr conn, virConnectAuthPtr auth, int flags); int xenXMClose(virConnectPtr conn); const char *xenXMGetType(virConnectPtr conn); diff -r f10add69a53c src/xs_internal.c --- a/src/xs_internal.c Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xs_internal.c Mon Nov 24 10:19:11 2008 -0500 @@ -29,6 +29,10 @@ #include "virterror_internal.h" #include "datatypes.h" #include "driver.h" +#include "memory.h" +#include "event.h" +#include "logging.h" +#include "uuid.h" #include "xen_unified.h" #include "xs_internal.h" #include "xen_internal.h" /* for xenHypervisorCheckID */ @@ -42,6 +46,9 @@ #endif #ifndef PROXY +/* A list of active domain name/uuids */ +static xenUnifiedDomainInfoListPtr activeDomainList = NULL; + static char *xenStoreDomainGetOSType(virDomainPtr domain); struct xenUnifiedDriver xenStoreDriver = { @@ -302,7 +309,52 @@ xenStoreOpen(virConnectPtr conn, } return (-1); } - return (0); + +#ifndef PROXY + /* Init activeDomainList */ + if ( VIR_ALLOC(activeDomainList) < 0) { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("failed to allocate activeDomainList")); + return -1; + } + + /* Init watch list before filling in domInfoList, + so we can know if it is the first time through + when the callback fires */ + if ( VIR_ALLOC(priv->xsWatchList) < 0 ) { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("failed to allocate xsWatchList")); + return -1; + } + + /* This will get called once at start */ + if ( xenStoreAddWatch(conn, "@releaseDomain", + "releaseDomain", xenStoreDomainReleased, priv) < 0 ) + { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("adding watch @releaseDomain")); + return -1; + } + + /* The initial call of this will fill domInfoList */ + if( xenStoreAddWatch(conn, "@introduceDomain", + "introduceDomain", xenStoreDomainIntroduced, priv) < 0 ) + { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("adding watch @introduceDomain")); + return -1; + } + + /* Add an event handle */ + if ((priv->xsWatch = virEventAddHandle(xs_fileno(priv->xshandle), + VIR_EVENT_HANDLE_READABLE, + xenStoreWatchEvent, + conn, + NULL)) < 0) + DEBUG0("Failed to add event handle, disabling events\n"); + +#endif //PROXY + return 0; } /** @@ -324,10 +376,29 @@ xenStoreClose(virConnectPtr conn) } priv = (xenUnifiedPrivatePtr) conn->privateData; - if (priv->xshandle == NULL) - return(-1); - + + if (xenStoreRemoveWatch(conn, "@introduceDomain", "introduceDomain") < 0) { + DEBUG0("Warning, could not remove @introduceDomain watch"); + /* not fatal */ + } + + if (xenStoreRemoveWatch(conn, "@releaseDomain", "releaseDomain") < 0) { + DEBUG0("Warning, could not remove @releaseDomain watch"); + /* not fatal */ + } + + xenStoreWatchListFree(priv->xsWatchList); +#ifndef PROXY + xenUnifiedDomainInfoListFree(activeDomainList); +#endif + if (priv->xshandle == NULL) + return(-1); + + if (priv->xsWatch != -1) + virEventRemoveHandle(priv->xsWatch); xs_daemon_close(priv->xshandle); + priv->xshandle = NULL; + return (0); } @@ -920,3 +991,343 @@ char *xenStoreDomainGetName(virConnectPt return xs_read(priv->xshandle, 0, prop, &len); } +#ifndef PROXY +int xenStoreDomainGetUUID(virConnectPtr conn, + int id, + unsigned char *uuid) { + char prop[200]; + xenUnifiedPrivatePtr priv; + unsigned int len; + char *uuidstr; + int ret = 0; + + priv = (xenUnifiedPrivatePtr) conn->privateData; + if (priv->xshandle == NULL) + return -1; + + snprintf(prop, 199, "/local/domain/%d/vm", id); + prop[199] = 0; + // This will return something like + // /vm/00000000-0000-0000-0000-000000000000 + uuidstr = xs_read(priv->xshandle, 0, prop, &len); + + // remove "/vm/" + ret = virUUIDParse(uuidstr + 4, uuid); + + VIR_FREE(uuidstr); + + return ret; +} +#endif //PROXY + +void xenStoreWatchListFree(xenStoreWatchListPtr list) +{ + int i; + for (i=0; i<list->count; i++) { + VIR_FREE(list->watches[i]->path); + VIR_FREE(list->watches[i]->token); + VIR_FREE(list->watches[i]); + } + VIR_FREE(list); +} + +int xenStoreAddWatch(virConnectPtr conn, + const char *path, + const char *token, + xenStoreWatchCallback cb, + void *opaque) +{ + xenStoreWatchPtr watch; + int n; + xenStoreWatchListPtr list; + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData; + + if (priv->xshandle == NULL) + return -1; + + list = priv->xsWatchList; + if(!list) + return -1; + + /* check if we already have this callback on our list */ + for (n=0; n < list->count; n++) { + if( STREQ(list->watches[n]->path, path) && + STREQ(list->watches[n]->token, token)) { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("watch already tracked")); + return -1; + } + } + + if (VIR_ALLOC(watch) < 0) + return -1; + watch->path = strdup(path); + watch->token = strdup(token); + watch->cb = cb; + watch->opaque = opaque; + + /* Make space on list */ + n = list->count; + if (VIR_REALLOC_N(list->watches, n + 1) < 0) { + virXenStoreError(NULL, VIR_ERR_INTERNAL_ERROR, + "%s", _("reallocating list")); + VIR_FREE(watch); + return -1; + } + + list->watches[n] = watch; + list->count++; + + conn->refs++; + + return xs_watch(priv->xshandle, watch->path, watch->token); +} + +int xenStoreRemoveWatch(virConnectPtr conn, + const char *path, + const char *token) +{ + int i; + xenStoreWatchListPtr list; + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData; + + if (priv->xshandle == NULL) + return -1; + + list = priv->xsWatchList; + if(!list) + return -1; + + for (i = 0 ; i < list->count ; i++) { + if( STREQ(list->watches[i]->path, path) && + STREQ(list->watches[i]->token, token)) { + + if (!xs_unwatch(priv->xshandle, + list->watches[i]->path, + list->watches[i]->path)) + { + DEBUG0("WARNING: Could not remove watch"); + /* Not fatal, continue */ + } + + VIR_FREE(list->watches[i]->path); + VIR_FREE(list->watches[i]->token); + VIR_FREE(list->watches[i]); + + if (i < (list->count - 1)) + memmove(list->watches + i, + list->watches + i + 1, + sizeof(*(list->watches)) * + (list->count - (i + 1))); + + if (VIR_REALLOC_N(list->watches, + list->count - 1) < 0) { + ; /* Failure to reduce memory allocation isn't fatal */ + } + list->count--; +#ifndef PROXY + virUnrefConnect(conn); +#endif + return 0; + } + } + return -1; +} + +xenStoreWatchPtr xenStoreFindWatch(xenStoreWatchListPtr list, + const char *path, + const char *token) +{ + int i; + for (i = 0 ; i < list->count ; i++) + if( STREQ(path, list->watches[i]->path) && + STREQ(token, list->watches[i]->token) ) + return list->watches[i]; + + return NULL; +} + +void xenStoreWatchEvent(int watch ATTRIBUTE_UNUSED, + int fd ATTRIBUTE_UNUSED, + int events ATTRIBUTE_UNUSED, + void *data) +{ + char **event; + char *path; + char *token; + unsigned int stringCount; + xenStoreWatchPtr sw; + + virConnectPtr conn = data; + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) conn->privateData; + if(!priv) return; + if(!priv->xshandle) return; + + event = xs_read_watch(priv->xshandle, &stringCount); + if (!event) + return; + + path = event[XS_WATCH_PATH]; + token = event[XS_WATCH_TOKEN]; + + sw = xenStoreFindWatch(priv->xsWatchList, path, token); + if( sw ) + sw->cb(conn, path, token, sw->opaque); + VIR_FREE(event); +} + +#ifndef PROXY +/* The domain callback for the @introduceDomain watch */ +int xenStoreDomainIntroduced(virConnectPtr conn, + const char *path ATTRIBUTE_UNUSED, + const char *token ATTRIBUTE_UNUSED, + void *opaque) +{ + int i, j, found, missing = 0, retries = 20; + int new_domain_cnt; + int *new_domids; + int nread; + + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) opaque; + +retry: + new_domain_cnt = xenStoreNumOfDomains(conn); + if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) { + virXenStoreError(NULL, VIR_ERR_NO_MEMORY, + "%s", _("failed to allocate domids")); + return -1; + } + nread = xenStoreListDomains(conn, new_domids, new_domain_cnt); + if (nread != new_domain_cnt) { + // mismatch. retry this read + VIR_FREE(new_domids); + goto retry; + } + + missing = 0; + for (i=0 ; i < new_domain_cnt ; i++) { + found = 0; + for (j = 0 ; j < activeDomainList->count ; j++) { + if (activeDomainList->doms[j]->id == new_domids[i]) { + found = 1; + break; + } + } + + if (!found) { + virDomainPtr dom; + char *name; + unsigned char uuid[VIR_UUID_BUFLEN]; + + if (!(name = xenStoreDomainGetName(conn, new_domids[i]))) { + missing = 1; + continue; + } + if (xenStoreDomainGetUUID(conn, new_domids[i], uuid) < 0) { + missing = 1; + VIR_FREE(name); + continue; + } + + dom = virGetDomain(conn, name, uuid); + if (dom) { + dom->id = new_domids[i]; + + /* This domain was not in the old list. Emit an event */ + xenUnifiedDomainEventDispatch(priv, dom, + VIR_DOMAIN_EVENT_STARTED, + VIR_DOMAIN_EVENT_STARTED_BOOTED); + + /* Add to the list */ + xenUnifiedAddDomainInfo(activeDomainList, + new_domids[i], name, uuid); + + virUnrefDomain(dom); + } + + VIR_FREE(name); + } + } + VIR_FREE(new_domids); + + if (missing && retries--) { + DEBUG0("Some domains were missing, trying again"); + usleep(100 * 1000); + goto retry; + } + return 0; +} + +/* The domain callback for the @destroyDomain watch */ +int xenStoreDomainReleased(virConnectPtr conn, + const char *path ATTRIBUTE_UNUSED, + const char *token ATTRIBUTE_UNUSED, + void *opaque) +{ + int i, j, found, removed, retries = 20; + int new_domain_cnt; + int *new_domids; + int nread; + + xenUnifiedPrivatePtr priv = (xenUnifiedPrivatePtr) opaque; + + if(!activeDomainList->count) return 0; + +retry: + new_domain_cnt = xenStoreNumOfDomains(conn); + + if( VIR_ALLOC_N(new_domids,new_domain_cnt) < 0 ) { + virXenStoreError(NULL, VIR_ERR_NO_MEMORY, + "%s", _("failed to allocate domids")); + return -1; + } + nread = xenStoreListDomains(conn, new_domids, new_domain_cnt); + if (nread != new_domain_cnt) { + // mismatch. retry this read + VIR_FREE(new_domids); + goto retry; + } + + removed = 0; + for (j=0 ; j < activeDomainList->count ; j++) { + found = 0; + for (i=0 ; i < new_domain_cnt ; i++) { + if (activeDomainList->doms[j]->id == new_domids[i]) { + found = 1; + break; + } + } + + if (!found) { + virDomainPtr dom = virGetDomain(conn, + activeDomainList->doms[j]->name, + activeDomainList->doms[j]->uuid); + if(dom) { + dom->id = -1; + /* This domain was not in the new list. Emit an event */ + xenUnifiedDomainEventDispatch(priv, dom, + VIR_DOMAIN_EVENT_STOPPED, + VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN); + /* Remove from the list */ + xenUnifiedRemoveDomainInfo(activeDomainList, + activeDomainList->doms[j]->id, + activeDomainList->doms[j]->name, + activeDomainList->doms[j]->uuid); + + virUnrefDomain(dom); + removed = 1; + } + } + } + + VIR_FREE(new_domids); + + if (!removed && retries--) { + DEBUG0("No domains removed, retrying"); + usleep(100 * 1000); + goto retry; + } + return 0; +} + +#endif //PROXY diff -r f10add69a53c src/xs_internal.h --- a/src/xs_internal.h Mon Nov 24 09:08:00 2008 -0500 +++ b/src/xs_internal.h Mon Nov 24 10:18:59 2008 -0500 @@ -51,5 +51,57 @@ char * xenStoreDomainGetDiskID(virConne const char *dev); char * xenStoreDomainGetName(virConnectPtr conn, int id); +int xenStoreDomainGetUUID(virConnectPtr conn, + int id, + unsigned char *uuid); +typedef int (*xenStoreWatchCallback)(virConnectPtr conn, + const char *path, + const char *token, + void *opaque); + +struct _xenStoreWatch { + char *path; + char *token; + xenStoreWatchCallback cb; + void *opaque; +}; +typedef struct _xenStoreWatch xenStoreWatch; +typedef xenStoreWatch *xenStoreWatchPtr; + +struct _xenStoreWatchList { + unsigned int count; + xenStoreWatchPtr *watches; +}; +typedef struct _xenStoreWatchList xenStoreWatchList; +typedef xenStoreWatchList *xenStoreWatchListPtr; + + +void xenStoreWatchListFree(xenStoreWatchListPtr head); + +int xenStoreAddWatch(virConnectPtr conn, + const char *path, + const char *token, + xenStoreWatchCallback cb, + void *opaque); +int xenStoreRemoveWatch(virConnectPtr conn, + const char *path, + const char *token); +xenStoreWatchPtr xenStoreFindWatch(xenStoreWatchListPtr list, + const char *path, + const char *token); + +void xenStoreWatchEvent(int watch, int fd, int events, void *data); + +/* domain events */ +int xenStoreDomainIntroduced(virConnectPtr conn, + const char *path, + const char *token, + void *opaque); +int xenStoreDomainReleased(virConnectPtr conn, + const char *path, + const char *token, + void *opaque); + +int xenStoreDomainEventEmitted(virDomainEventType evt); #endif /* __VIR_XS_INTERNAL_H__ */ -- |: Red Hat, Engineering, London -o- http://people.redhat.com/berrange/ :| |: http://libvirt.org -o- http://virt-manager.org -o- http://ovirt.org :| |: http://autobuild.org -o- http://search.cpan.org/~danberr/ :| |: GnuPG: 7D3B9505 -o- F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|