[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [libvirt] PATCH: 4/11: Move code out of hash.c into datatypes.h



Following Daniel's feedback yesterday, instead of moving the virGetDomain
& related functions from hash.c into libvirt.c, I create a new file to
deal with all our public datatypes. I call it datatypes.h, datatypes.c

A bunch of stuff moves out of hash.c and internal.h into these two files.
Quite a few internal driver files need updates to add an extra #include
line. There should be no functional changes here

 b/src/datatypes.c        |  772 +++++++++++++++++++++++++++++++++++++++++++++++
 b/src/datatypes.h        |  212 ++++++++++++
 b/src/libvirt_internal.h |   64 +++
 po/POTFILES.in           |    2 
 proxy/libvirt_proxy.c    |    2 
 qemud/qemud.c            |    2 
 qemud/remote.c           |    3 
 src/Makefile.am          |    3 
 src/domain_conf.c        |    1 
 src/domain_conf.h        |    4 
 src/driver.h             |    3 
 src/hash.c               |  725 --------------------------------------------
 src/internal.h           |  206 ------------
 src/libvirt.c            |    6 
 src/lxc_driver.c         |    1 
 src/network_conf.c       |    1 
 src/network_conf.h       |    4 
 src/network_driver.c     |    1 
 src/openvz_driver.c      |    1 
 src/proxy_internal.c     |    1 
 src/proxy_internal.h     |    2 
 src/qemu_driver.c        |    1 
 src/qparams.c            |    2 
 src/remote_internal.c    |    1 
 src/stats_linux.c        |    1 
 src/storage_conf.c       |    6 
 src/storage_conf.h       |    5 
 src/storage_driver.c     |    1 
 src/test.c               |    1 
 src/uuid.c               |    1 
 src/veth.c               |    1 
 src/virterror.c          |    1 
 src/xen_internal.c       |    1 
 src/xen_internal.h       |    2 
 src/xen_unified.c        |    2 
 src/xen_unified.h        |    3 
 src/xend_internal.c      |    1 
 src/xend_internal.h      |    1 
 src/xm_internal.c        |    1 
 src/xs_internal.c        |    1 
 tests/xmconfigtest.c     |    1 
 41 files changed, 1102 insertions(+), 948 deletions(-)

Daniel

diff -r 10d728ae8445 po/POTFILES.in
--- a/po/POTFILES.in	Wed Oct 29 20:09:50 2008 +0000
+++ b/po/POTFILES.in	Wed Oct 29 20:10:40 2008 +0000
@@ -3,8 +3,8 @@
 qemud/remote.c
 src/conf.c
 src/console.c
+src/datatypes.c
 src/domain_conf.c
-src/hash.c
 src/iptables.c
 src/libvirt.c
 src/lxc_container.c
diff -r 10d728ae8445 proxy/libvirt_proxy.c
--- a/proxy/libvirt_proxy.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/proxy/libvirt_proxy.c	Wed Oct 29 20:10:40 2008 +0000
@@ -24,7 +24,7 @@
 #include <locale.h>
 
 #include "internal.h"
-
+#include "datatypes.h"
 #include "proxy_internal.h"
 #include "util.h"
 #include "xen_internal.h"
diff -r 10d728ae8445 qemud/qemud.c
--- a/qemud/qemud.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/qemud/qemud.c	Wed Oct 29 20:10:40 2008 +0000
@@ -49,7 +49,7 @@
 #include <signal.h>
 #include <netdb.h>
 
-#include "internal.h"
+#include "libvirt_internal.h"
 
 #include "qemud.h"
 #include "util.h"
diff -r 10d728ae8445 qemud/remote.c
--- a/qemud/remote.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/qemud/remote.c	Wed Oct 29 20:10:40 2008 +0000
@@ -48,7 +48,8 @@
 #include <polkit-dbus/polkit-dbus.h>
 #endif
 
-#include "internal.h"
+#include "libvirt_internal.h"
+#include "datatypes.h"
 #include "qemud.h"
 #include "memory.h"
 
diff -r 10d728ae8445 src/Makefile.am
--- a/src/Makefile.am	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/Makefile.am	Wed Oct 29 20:10:40 2008 +0000
@@ -44,6 +44,7 @@
 		buf.c buf.h					\
 		conf.c conf.h					\
 		event.c event.h					\
+		hash.c hash.h					\
 		iptables.c iptables.h				\
 		memory.c memory.h				\
 		qparams.c qparams.h				\
@@ -147,8 +148,8 @@
 
 libvirt_la_SOURCES =						\
 		driver.h					\
-		hash.c hash.h					\
 		internal.h					\
+		datatypes.c datatypes.h				\
 		libvirt.c libvirt_internal.h			\
 		$(GENERIC_LIB_SOURCES)				\
 		$(DOMAIN_CONF_SOURCES)				\
diff -r 10d728ae8445 src/datatypes.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/datatypes.c	Wed Oct 29 20:10:40 2008 +0000
@@ -0,0 +1,772 @@
+/*
+ * datatypes.h: management of structs for public data types
+ *
+ * Copyright (C) 2006-2008 Red Hat, Inc.
+ *
+ * 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 <config.h>
+
+#include "datatypes.h"
+#include "virterror_internal.h"
+#include "memory.h"
+
+/************************************************************************
+ *									*
+ *			Domain and Connections allocations		*
+ *									*
+ ************************************************************************/
+/**
+ * virLibConnError:
+ * @conn: the connection if available
+ * @error: the error number
+ * @info: extra information string
+ *
+ * Handle an error at the connection level
+ */
+static void
+virLibConnError(virConnectPtr conn, virErrorNumber error, const char *info)
+{
+    const char *errmsg;
+
+    if (error == VIR_ERR_OK)
+        return;
+
+    errmsg = virErrorMsg(error, info);
+    virRaiseError(conn, NULL, NULL, VIR_FROM_NONE, error, VIR_ERR_ERROR,
+                  errmsg, info, NULL, 0, 0, errmsg, info);
+}
+
+/**
+ * virDomainFreeName:
+ * @domain: a domain object
+ *
+ * Destroy the domain object, this is just used by the domain hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virDomainFreeName(virDomainPtr domain, const char *name ATTRIBUTE_UNUSED)
+{
+    return (virDomainFree(domain));
+}
+
+/**
+ * virNetworkFreeName:
+ * @network: a network object
+ *
+ * Destroy the network object, this is just used by the network hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virNetworkFreeName(virNetworkPtr network, const char *name ATTRIBUTE_UNUSED)
+{
+    return (virNetworkFree(network));
+}
+
+/**
+ * virStoragePoolFreeName:
+ * @pool: a pool object
+ *
+ * Destroy the pool object, this is just used by the pool hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virStoragePoolFreeName(virStoragePoolPtr pool, const char *name ATTRIBUTE_UNUSED)
+{
+    return (virStoragePoolFree(pool));
+}
+
+/**
+ * virStorageVolFreeName:
+ * @vol: a vol object
+ *
+ * Destroy the vol object, this is just used by the vol hash callback.
+ *
+ * Returns 0 in case of success and -1 in case of failure.
+ */
+static int
+virStorageVolFreeName(virStorageVolPtr vol, const char *name ATTRIBUTE_UNUSED)
+{
+    return (virStorageVolFree(vol));
+}
+
+/**
+ * virGetConnect:
+ *
+ * Allocates a new hypervisor connection structure
+ *
+ * Returns a new pointer or NULL in case of error.
+ */
+virConnectPtr
+virGetConnect(void) {
+    virConnectPtr ret;
+
+    if (VIR_ALLOC(ret) < 0) {
+        virLibConnError(NULL, VIR_ERR_NO_MEMORY, _("allocating connection"));
+        goto failed;
+    }
+    ret->magic = VIR_CONNECT_MAGIC;
+    ret->driver = NULL;
+    ret->networkDriver = NULL;
+    ret->privateData = NULL;
+    ret->networkPrivateData = NULL;
+    ret->domains = virHashCreate(20);
+    if (ret->domains == NULL)
+        goto failed;
+    ret->networks = virHashCreate(20);
+    if (ret->networks == NULL)
+        goto failed;
+    ret->storagePools = virHashCreate(20);
+    if (ret->storagePools == NULL)
+        goto failed;
+    ret->storageVols = virHashCreate(20);
+    if (ret->storageVols == NULL)
+        goto failed;
+
+    pthread_mutex_init(&ret->lock, NULL);
+
+    ret->refs = 1;
+    return(ret);
+
+failed:
+    if (ret != NULL) {
+        if (ret->domains != NULL)
+            virHashFree(ret->domains, (virHashDeallocator) virDomainFreeName);
+        if (ret->networks != NULL)
+            virHashFree(ret->networks, (virHashDeallocator) virNetworkFreeName);
+        if (ret->storagePools != NULL)
+            virHashFree(ret->storagePools, (virHashDeallocator) virStoragePoolFreeName);
+        if (ret->storageVols != NULL)
+            virHashFree(ret->storageVols, (virHashDeallocator) virStorageVolFreeName);
+
+        pthread_mutex_destroy(&ret->lock);
+        VIR_FREE(ret);
+    }
+    return(NULL);
+}
+
+/**
+ * virReleaseConnect:
+ * @conn: the hypervisor connection to release
+ *
+ * Unconditionally release all memory associated with a connection.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The connection obj must not
+ * be used once this method returns.
+ */
+static void
+virReleaseConnect(virConnectPtr conn) {
+    DEBUG("release connection %p %s", conn, conn->name);
+    if (conn->domains != NULL)
+        virHashFree(conn->domains, (virHashDeallocator) virDomainFreeName);
+    if (conn->networks != NULL)
+        virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName);
+    if (conn->storagePools != NULL)
+        virHashFree(conn->storagePools, (virHashDeallocator) virStoragePoolFreeName);
+    if (conn->storageVols != NULL)
+        virHashFree(conn->storageVols, (virHashDeallocator) virStorageVolFreeName);
+
+    virResetError(&conn->err);
+    if (virLastErr.conn == conn)
+        virLastErr.conn = NULL;
+
+    VIR_FREE(conn->name);
+
+    pthread_mutex_unlock(&conn->lock);
+    pthread_mutex_destroy(&conn->lock);
+    VIR_FREE(conn);
+}
+
+/**
+ * virUnrefConnect:
+ * @conn: the hypervisor connection to unreference
+ *
+ * Unreference the connection. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefConnect(virConnectPtr conn) {
+    int refs;
+
+    if ((!VIR_IS_CONNECT(conn))) {
+        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(-1);
+    }
+    pthread_mutex_lock(&conn->lock);
+    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
+    conn->refs--;
+    refs = conn->refs;
+    if (refs == 0) {
+        virReleaseConnect(conn);
+        /* Already unlocked mutex */
+        return (0);
+    }
+    pthread_mutex_unlock(&conn->lock);
+    return (refs);
+}
+
+/**
+ * virGetDomain:
+ * @conn: the hypervisor connection
+ * @name: pointer to the domain name
+ * @uuid: pointer to the uuid
+ *
+ * Lookup if the domain is already registered for that connection,
+ * if yes return a new pointer to it, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virUnrefDomain() is needed to not leak data.
+ *
+ * Returns a pointer to the domain, or NULL in case of failure
+ */
+virDomainPtr
+__virGetDomain(virConnectPtr conn, const char *name, const unsigned char *uuid) {
+    virDomainPtr ret = NULL;
+
+    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
+        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(NULL);
+    }
+    pthread_mutex_lock(&conn->lock);
+
+    /* TODO search by UUID first as they are better differenciators */
+
+    ret = (virDomainPtr) virHashLookup(conn->domains, name);
+    /* TODO check the UUID */
+    if (ret == NULL) {
+        if (VIR_ALLOC(ret) < 0) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+            goto error;
+        }
+        ret->name = strdup(name);
+        if (ret->name == NULL) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating domain"));
+            goto error;
+        }
+        ret->magic = VIR_DOMAIN_MAGIC;
+        ret->conn = conn;
+        ret->id = -1;
+        if (uuid != NULL)
+            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
+
+        if (virHashAddEntry(conn->domains, name, ret) < 0) {
+            virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                            _("failed to add domain to connection hash table"));
+            goto error;
+        }
+        conn->refs++;
+        DEBUG("New hash entry %p", ret);
+    } else {
+        DEBUG("Existing hash entry %p: refs now %d", ret, ret->refs+1);
+    }
+    ret->refs++;
+    pthread_mutex_unlock(&conn->lock);
+    return(ret);
+
+ error:
+    pthread_mutex_unlock(&conn->lock);
+    if (ret != NULL) {
+        VIR_FREE(ret->name);
+        VIR_FREE(ret);
+    }
+    return(NULL);
+}
+
+/**
+ * virReleaseDomain:
+ * @domain: the domain to release
+ *
+ * Unconditionally release all memory associated with a domain.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The domain obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseDomain(virDomainPtr domain) {
+    virConnectPtr conn = domain->conn;
+    DEBUG("release domain %p %s", domain, domain->name);
+
+    /* TODO search by UUID first as they are better differenciators */
+    if (virHashRemoveEntry(conn->domains, domain->name, NULL) < 0)
+        virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                        _("domain missing from connection hash table"));
+
+    if (conn->err.dom == domain)
+        conn->err.dom = NULL;
+    if (virLastErr.dom == domain)
+        virLastErr.dom = NULL;
+    domain->magic = -1;
+    domain->id = -1;
+    VIR_FREE(domain->name);
+    VIR_FREE(domain);
+
+    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
+    conn->refs--;
+    if (conn->refs == 0) {
+        virReleaseConnect(conn);
+        /* Already unlocked mutex */
+        return;
+    }
+
+    pthread_mutex_unlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefDomain:
+ * @domain: the domain to unreference
+ *
+ * Unreference the domain. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefDomain(virDomainPtr domain) {
+    int refs;
+
+    if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
+        virLibConnError(domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(-1);
+    }
+    pthread_mutex_lock(&domain->conn->lock);
+    DEBUG("unref domain %p %s %d", domain, domain->name, domain->refs);
+    domain->refs--;
+    refs = domain->refs;
+    if (refs == 0) {
+        virReleaseDomain(domain);
+        /* Already unlocked mutex */
+        return (0);
+    }
+
+    pthread_mutex_unlock(&domain->conn->lock);
+    return (refs);
+}
+
+/**
+ * virGetNetwork:
+ * @conn: the hypervisor connection
+ * @name: pointer to the network name
+ * @uuid: pointer to the uuid
+ *
+ * Lookup if the network is already registered for that connection,
+ * if yes return a new pointer to it, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virUnrefNetwork() is needed to not leak data.
+ *
+ * Returns a pointer to the network, or NULL in case of failure
+ */
+virNetworkPtr
+__virGetNetwork(virConnectPtr conn, const char *name, const unsigned char *uuid) {
+    virNetworkPtr ret = NULL;
+
+    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
+        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(NULL);
+    }
+    pthread_mutex_lock(&conn->lock);
+
+    /* TODO search by UUID first as they are better differenciators */
+
+    ret = (virNetworkPtr) virHashLookup(conn->networks, name);
+    /* TODO check the UUID */
+    if (ret == NULL) {
+        if (VIR_ALLOC(ret) < 0) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+            goto error;
+        }
+        ret->name = strdup(name);
+        if (ret->name == NULL) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating network"));
+            goto error;
+        }
+        ret->magic = VIR_NETWORK_MAGIC;
+        ret->conn = conn;
+        if (uuid != NULL)
+            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
+
+        if (virHashAddEntry(conn->networks, name, ret) < 0) {
+            virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                            _("failed to add network to connection hash table"));
+            goto error;
+        }
+        conn->refs++;
+    }
+    ret->refs++;
+    pthread_mutex_unlock(&conn->lock);
+    return(ret);
+
+ error:
+    pthread_mutex_unlock(&conn->lock);
+    if (ret != NULL) {
+        VIR_FREE(ret->name);
+        VIR_FREE(ret);
+    }
+    return(NULL);
+}
+
+/**
+ * virReleaseNetwork:
+ * @network: the network to release
+ *
+ * Unconditionally release all memory associated with a network.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The network obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseNetwork(virNetworkPtr network) {
+    virConnectPtr conn = network->conn;
+    DEBUG("release network %p %s", network, network->name);
+
+    /* TODO search by UUID first as they are better differenciators */
+    if (virHashRemoveEntry(conn->networks, network->name, NULL) < 0)
+        virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                        _("network missing from connection hash table"));
+
+    if (conn->err.net == network)
+        conn->err.net = NULL;
+    if (virLastErr.net == network)
+        virLastErr.net = NULL;
+
+    network->magic = -1;
+    VIR_FREE(network->name);
+    VIR_FREE(network);
+
+    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
+    conn->refs--;
+    if (conn->refs == 0) {
+        virReleaseConnect(conn);
+        /* Already unlocked mutex */
+        return;
+    }
+
+    pthread_mutex_unlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefNetwork:
+ * @network: the network to unreference
+ *
+ * Unreference the network. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefNetwork(virNetworkPtr network) {
+    int refs;
+
+    if (!VIR_IS_CONNECTED_NETWORK(network)) {
+        virLibConnError(network->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(-1);
+    }
+    pthread_mutex_lock(&network->conn->lock);
+    DEBUG("unref network %p %s %d", network, network->name, network->refs);
+    network->refs--;
+    refs = network->refs;
+    if (refs == 0) {
+        virReleaseNetwork(network);
+        /* Already unlocked mutex */
+        return (0);
+    }
+
+    pthread_mutex_unlock(&network->conn->lock);
+    return (refs);
+}
+
+
+/**
+ * virGetStoragePool:
+ * @conn: the hypervisor connection
+ * @name: pointer to the storage pool name
+ * @uuid: pointer to the uuid
+ *
+ * Lookup if the storage pool is already registered for that connection,
+ * if yes return a new pointer to it, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virFreeStoragePool() is needed to not leak data.
+ *
+ * Returns a pointer to the network, or NULL in case of failure
+ */
+virStoragePoolPtr
+__virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid) {
+    virStoragePoolPtr ret = NULL;
+
+    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
+        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(NULL);
+    }
+    pthread_mutex_lock(&conn->lock);
+
+    /* TODO search by UUID first as they are better differenciators */
+
+    ret = (virStoragePoolPtr) virHashLookup(conn->storagePools, name);
+    /* TODO check the UUID */
+    if (ret == NULL) {
+        if (VIR_ALLOC(ret) < 0) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+            goto error;
+        }
+        ret->name = strdup(name);
+        if (ret->name == NULL) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage pool"));
+            goto error;
+        }
+        ret->magic = VIR_STORAGE_POOL_MAGIC;
+        ret->conn = conn;
+        if (uuid != NULL)
+            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
+
+        if (virHashAddEntry(conn->storagePools, name, ret) < 0) {
+            virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                            _("failed to add storage pool to connection hash table"));
+            goto error;
+        }
+        conn->refs++;
+    }
+    ret->refs++;
+    pthread_mutex_unlock(&conn->lock);
+    return(ret);
+
+error:
+    pthread_mutex_unlock(&conn->lock);
+    if (ret != NULL) {
+        VIR_FREE(ret->name);
+        VIR_FREE(ret);
+    }
+    return(NULL);
+}
+
+
+/**
+ * virReleaseStoragePool:
+ * @pool: the pool to release
+ *
+ * Unconditionally release all memory associated with a pool.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The pool obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseStoragePool(virStoragePoolPtr pool) {
+    virConnectPtr conn = pool->conn;
+    DEBUG("release pool %p %s", pool, pool->name);
+
+    /* TODO search by UUID first as they are better differenciators */
+    if (virHashRemoveEntry(conn->storagePools, pool->name, NULL) < 0)
+        virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                        _("pool missing from connection hash table"));
+
+    pool->magic = -1;
+    VIR_FREE(pool->name);
+    VIR_FREE(pool);
+
+    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
+    conn->refs--;
+    if (conn->refs == 0) {
+        virReleaseConnect(conn);
+        /* Already unlocked mutex */
+        return;
+    }
+
+    pthread_mutex_unlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefStoragePool:
+ * @pool: the pool to unreference
+ *
+ * Unreference the pool. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefStoragePool(virStoragePoolPtr pool) {
+    int refs;
+
+    if (!VIR_IS_CONNECTED_STORAGE_POOL(pool)) {
+        virLibConnError(pool->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(-1);
+    }
+    pthread_mutex_lock(&pool->conn->lock);
+    DEBUG("unref pool %p %s %d", pool, pool->name, pool->refs);
+    pool->refs--;
+    refs = pool->refs;
+    if (refs == 0) {
+        virReleaseStoragePool(pool);
+        /* Already unlocked mutex */
+        return (0);
+    }
+
+    pthread_mutex_unlock(&pool->conn->lock);
+    return (refs);
+}
+
+
+/**
+ * virGetStorageVol:
+ * @conn: the hypervisor connection
+ * @pool: pool owning the volume
+ * @name: pointer to the storage vol name
+ * @uuid: pointer to the uuid
+ *
+ * Lookup if the storage vol is already registered for that connection,
+ * if yes return a new pointer to it, if no allocate a new structure,
+ * and register it in the table. In any case a corresponding call to
+ * virFreeStorageVol() is needed to not leak data.
+ *
+ * Returns a pointer to the storage vol, or NULL in case of failure
+ */
+virStorageVolPtr
+__virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key) {
+    virStorageVolPtr ret = NULL;
+
+    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (key == NULL)) {
+        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(NULL);
+    }
+    pthread_mutex_lock(&conn->lock);
+
+    ret = (virStorageVolPtr) virHashLookup(conn->storageVols, key);
+    if (ret == NULL) {
+        if (VIR_ALLOC(ret) < 0) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+            goto error;
+        }
+        ret->pool = strdup(pool);
+        if (ret->pool == NULL) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+            goto error;
+        }
+        ret->name = strdup(name);
+        if (ret->name == NULL) {
+            virLibConnError(conn, VIR_ERR_NO_MEMORY, _("allocating storage vol"));
+            goto error;
+        }
+        strncpy(ret->key, key, sizeof(ret->key)-1);
+        ret->key[sizeof(ret->key)-1] = '\0';
+        ret->magic = VIR_STORAGE_VOL_MAGIC;
+        ret->conn = conn;
+
+        if (virHashAddEntry(conn->storageVols, key, ret) < 0) {
+            virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                            _("failed to add storage vol to connection hash table"));
+            goto error;
+        }
+        conn->refs++;
+    }
+    ret->refs++;
+    pthread_mutex_unlock(&conn->lock);
+    return(ret);
+
+error:
+    pthread_mutex_unlock(&conn->lock);
+    if (ret != NULL) {
+        VIR_FREE(ret->name);
+        VIR_FREE(ret->pool);
+        VIR_FREE(ret);
+    }
+    return(NULL);
+}
+
+
+/**
+ * virReleaseStorageVol:
+ * @vol: the vol to release
+ *
+ * Unconditionally release all memory associated with a vol.
+ * The conn.lock mutex must be held prior to calling this, and will
+ * be released prior to this returning. The vol obj must not
+ * be used once this method returns.
+ *
+ * It will also unreference the associated connection object,
+ * which may also be released if its ref count hits zero.
+ */
+static void
+virReleaseStorageVol(virStorageVolPtr vol) {
+    virConnectPtr conn = vol->conn;
+    DEBUG("release vol %p %s", vol, vol->name);
+
+    /* TODO search by UUID first as they are better differenciators */
+    if (virHashRemoveEntry(conn->storageVols, vol->key, NULL) < 0)
+        virLibConnError(conn, VIR_ERR_INTERNAL_ERROR,
+                        _("vol missing from connection hash table"));
+
+    vol->magic = -1;
+    VIR_FREE(vol->name);
+    VIR_FREE(vol->pool);
+    VIR_FREE(vol);
+
+    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
+    conn->refs--;
+    if (conn->refs == 0) {
+        virReleaseConnect(conn);
+        /* Already unlocked mutex */
+        return;
+    }
+
+    pthread_mutex_unlock(&conn->lock);
+}
+
+
+/**
+ * virUnrefStorageVol:
+ * @vol: the vol to unreference
+ *
+ * Unreference the vol. If the use count drops to zero, the structure is
+ * actually freed.
+ *
+ * Returns the reference count or -1 in case of failure.
+ */
+int
+virUnrefStorageVol(virStorageVolPtr vol) {
+    int refs;
+
+    if (!VIR_IS_CONNECTED_STORAGE_VOL(vol)) {
+        virLibConnError(vol->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
+        return(-1);
+    }
+    pthread_mutex_lock(&vol->conn->lock);
+    DEBUG("unref vol %p %s %d", vol, vol->name, vol->refs);
+    vol->refs--;
+    refs = vol->refs;
+    if (refs == 0) {
+        virReleaseStorageVol(vol);
+        /* Already unlocked mutex */
+        return (0);
+    }
+
+    pthread_mutex_unlock(&vol->conn->lock);
+    return (refs);
+}
diff -r 10d728ae8445 src/datatypes.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/datatypes.h	Wed Oct 29 20:10:40 2008 +0000
@@ -0,0 +1,212 @@
+/*
+ * datatypes.h: management of structs for public data types
+ *
+ * Copyright (C) 2006-2008 Red Hat, Inc.
+ *
+ * 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 __VIRT_DATATYPES_H_
+#define __VIRT_DATATYPES_H_
+
+#include "internal.h"
+
+#include "hash.h"
+#include "driver.h"
+
+
+/**
+ * VIR_CONNECT_MAGIC:
+ *
+ * magic value used to protect the API when pointers to connection structures
+ * are passed down by the uers.
+ */
+#define VIR_CONNECT_MAGIC 	0x4F23DEAD
+#define VIR_IS_CONNECT(obj)	((obj) && (obj)->magic==VIR_CONNECT_MAGIC)
+
+
+/**
+ * VIR_DOMAIN_MAGIC:
+ *
+ * magic value used to protect the API when pointers to domain structures
+ * are passed down by the users.
+ */
+#define VIR_DOMAIN_MAGIC		0xDEAD4321
+#define VIR_IS_DOMAIN(obj)		((obj) && (obj)->magic==VIR_DOMAIN_MAGIC)
+#define VIR_IS_CONNECTED_DOMAIN(obj)	(VIR_IS_DOMAIN(obj) && VIR_IS_CONNECT((obj)->conn))
+
+/**
+ * VIR_NETWORK_MAGIC:
+ *
+ * magic value used to protect the API when pointers to network structures
+ * are passed down by the users.
+ */
+#define VIR_NETWORK_MAGIC		0xDEAD1234
+#define VIR_IS_NETWORK(obj)		((obj) && (obj)->magic==VIR_NETWORK_MAGIC)
+#define VIR_IS_CONNECTED_NETWORK(obj)	(VIR_IS_NETWORK(obj) && VIR_IS_CONNECT((obj)->conn))
+
+/**
+ * VIR_STORAGE_POOL_MAGIC:
+ *
+ * magic value used to protect the API when pointers to storage pool structures
+ * are passed down by the users.
+ */
+#define VIR_STORAGE_POOL_MAGIC		0xDEAD5678
+#define VIR_IS_STORAGE_POOL(obj)		((obj) && (obj)->magic==VIR_STORAGE_POOL_MAGIC)
+#define VIR_IS_CONNECTED_STORAGE_POOL(obj)	(VIR_IS_STORAGE_POOL(obj) && VIR_IS_CONNECT((obj)->conn))
+
+/**
+ * VIR_STORAGE_VOL_MAGIC:
+ *
+ * magic value used to protect the API when pointers to storage vol structures
+ * are passed down by the users.
+ */
+#define VIR_STORAGE_VOL_MAGIC		0xDEAD8765
+#define VIR_IS_STORAGE_VOL(obj)		((obj) && (obj)->magic==VIR_STORAGE_VOL_MAGIC)
+#define VIR_IS_CONNECTED_STORAGE_VOL(obj)	(VIR_IS_STORAGE_VOL(obj) && VIR_IS_CONNECT((obj)->conn))
+
+
+/**
+ * _virConnect:
+ *
+ * Internal structure associated to a connection
+ */
+struct _virConnect {
+    unsigned int magic;     /* specific value to check */
+    int flags;              /* a set of connection flags */
+    char *name;                 /* connection URI */
+
+    /* The underlying hypervisor driver and network driver. */
+    virDriverPtr      driver;
+    virNetworkDriverPtr networkDriver;
+    virStorageDriverPtr storageDriver;
+
+    /* Private data pointer which can be used by driver and
+     * network driver as they wish.
+     * NB: 'private' is a reserved word in C++.
+     */
+    void *            privateData;
+    void *            networkPrivateData;
+    void *            storagePrivateData;
+
+    /* Per-connection error. */
+    virError err;           /* the last error */
+    virErrorFunc handler;   /* associated handlet */
+    void *userData;         /* the user data */
+
+    /*
+     * The lock mutex must be acquired before accessing/changing
+     * any of members following this point, or changing the ref
+     * count of any virDomain/virNetwork object associated with
+     * this connection
+     */
+    PTHREAD_MUTEX_T (lock);
+    virHashTablePtr domains;  /* hash table for known domains */
+    virHashTablePtr networks; /* hash table for known domains */
+    virHashTablePtr storagePools;/* hash table for known storage pools */
+    virHashTablePtr storageVols;/* hash table for known storage vols */
+    int refs;                 /* reference count */
+};
+
+/**
+* _virDomain:
+*
+* Internal structure associated to a domain
+*/
+struct _virDomain {
+    unsigned int magic;                  /* specific value to check */
+    int refs;                            /* reference count */
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *name;                          /* the domain external name */
+    int id;                              /* the domain ID */
+    unsigned char uuid[VIR_UUID_BUFLEN]; /* the domain unique identifier */
+};
+
+/**
+* _virNetwork:
+*
+* Internal structure associated to a domain
+*/
+struct _virNetwork {
+    unsigned int magic;                  /* specific value to check */
+    int refs;                            /* reference count */
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *name;                          /* the network external name */
+    unsigned char uuid[VIR_UUID_BUFLEN]; /* the network unique identifier */
+};
+
+/**
+* _virStoragePool:
+*
+* Internal structure associated to a storage pool
+*/
+struct _virStoragePool {
+    unsigned int magic;                  /* specific value to check */
+    int refs;                            /* reference count */
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *name;                          /* the storage pool external name */
+    unsigned char uuid[VIR_UUID_BUFLEN]; /* the storage pool unique identifier */
+};
+
+/**
+* _virStorageVol:
+*
+* Internal structure associated to a storage volume
+*/
+struct _virStorageVol {
+    unsigned int magic;                  /* specific value to check */
+    int refs;                            /* reference count */
+    virConnectPtr conn;                  /* pointer back to the connection */
+    char *pool;                          /* Pool name of owner */
+    char *name;                          /* the storage vol external name */
+    /* XXX currently abusing path for this. Ought not to be so evil */
+    char key[PATH_MAX];                  /* unique key for storage vol */
+};
+
+/************************************************************************
+ *									*
+ *	API for domain/connections (de)allocations and lookups		*
+ *									*
+ ************************************************************************/
+
+virConnectPtr virGetConnect(void);
+int virUnrefConnect(virConnectPtr conn);
+virDomainPtr __virGetDomain(virConnectPtr conn,
+                            const char *name,
+                            const unsigned char *uuid);
+int virUnrefDomain(virDomainPtr domain);
+virNetworkPtr __virGetNetwork(virConnectPtr conn,
+                              const char *name,
+                              const unsigned char *uuid);
+int virUnrefNetwork(virNetworkPtr network);
+
+virStoragePoolPtr __virGetStoragePool(virConnectPtr conn,
+                                      const char *name,
+                                      const unsigned char *uuid);
+int virUnrefStoragePool(virStoragePoolPtr pool);
+virStorageVolPtr __virGetStorageVol(virConnectPtr conn,
+                                     const char *pool,
+                                    const char *name,
+                                    const char *key);
+int virUnrefStorageVol(virStorageVolPtr vol);
+
+#define virGetDomain(c,n,u) __virGetDomain((c),(n),(u))
+#define virGetNetwork(c,n,u) __virGetNetwork((c),(n),(u))
+#define virGetStoragePool(c,n,u) __virGetStoragePool((c),(n),(u))
+#define virGetStorageVol(c,p,n,u) __virGetStorageVol((c),(p),(n),(u))
+
+
+#endif
diff -r 10d728ae8445 src/domain_conf.c
--- a/src/domain_conf.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/domain_conf.c	Wed Oct 29 20:10:40 2008 +0000
@@ -30,6 +30,7 @@
 #include <dirent.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "domain_conf.h"
 #include "memory.h"
 #include "verify.h"
diff -r 10d728ae8445 src/domain_conf.h
--- a/src/domain_conf.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/domain_conf.h	Wed Oct 29 20:10:40 2008 +0000
@@ -24,7 +24,9 @@
 #ifndef __DOMAIN_CONF_H
 #define __DOMAIN_CONF_H
 
-#include <config.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
 
 #include "internal.h"
 #include "capabilities.h"
diff -r 10d728ae8445 src/driver.h
--- a/src/driver.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/driver.h	Wed Oct 29 20:10:40 2008 +0000
@@ -5,9 +5,6 @@
 
 #ifndef __VIR_DRIVER_H__
 #define __VIR_DRIVER_H__
-
-#include "libvirt/libvirt.h"
-#include "libvirt/virterror.h"
 
 #include <libxml/uri.h>
 
diff -r 10d728ae8445 src/hash.c
--- a/src/hash.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/hash.c	Wed Oct 29 20:10:40 2008 +0000
@@ -594,728 +594,3 @@
     return (NULL);
 }
 
-/************************************************************************
- *									*
- *			Domain and Connections allocations		*
- *									*
- ************************************************************************/
-
-/**
- * virDomainFreeName:
- * @domain: a domain object
- *
- * Destroy the domain object, this is just used by the domain hash callback.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-static int
-virDomainFreeName(virDomainPtr domain, const char *name ATTRIBUTE_UNUSED)
-{
-    return (virDomainFree(domain));
-}
-
-/**
- * virNetworkFreeName:
- * @network: a network object
- *
- * Destroy the network object, this is just used by the network hash callback.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-static int
-virNetworkFreeName(virNetworkPtr network, const char *name ATTRIBUTE_UNUSED)
-{
-    return (virNetworkFree(network));
-}
-
-/**
- * virStoragePoolFreeName:
- * @pool: a pool object
- *
- * Destroy the pool object, this is just used by the pool hash callback.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-static int
-virStoragePoolFreeName(virStoragePoolPtr pool, const char *name ATTRIBUTE_UNUSED)
-{
-    return (virStoragePoolFree(pool));
-}
-
-/**
- * virStorageVolFreeName:
- * @vol: a vol object
- *
- * Destroy the vol object, this is just used by the vol hash callback.
- *
- * Returns 0 in case of success and -1 in case of failure.
- */
-static int
-virStorageVolFreeName(virStorageVolPtr vol, const char *name ATTRIBUTE_UNUSED)
-{
-    return (virStorageVolFree(vol));
-}
-
-/**
- * virGetConnect:
- *
- * Allocates a new hypervisor connection structure
- *
- * Returns a new pointer or NULL in case of error.
- */
-virConnectPtr
-virGetConnect(void) {
-    virConnectPtr ret;
-
-    if (VIR_ALLOC(ret) < 0) {
-        virHashError(NULL, VIR_ERR_NO_MEMORY, "%s", _("allocating connection"));
-        goto failed;
-    }
-    ret->magic = VIR_CONNECT_MAGIC;
-    ret->driver = NULL;
-    ret->networkDriver = NULL;
-    ret->privateData = NULL;
-    ret->networkPrivateData = NULL;
-    ret->domains = virHashCreate(20);
-    if (ret->domains == NULL)
-        goto failed;
-    ret->networks = virHashCreate(20);
-    if (ret->networks == NULL)
-        goto failed;
-    ret->storagePools = virHashCreate(20);
-    if (ret->storagePools == NULL)
-        goto failed;
-    ret->storageVols = virHashCreate(20);
-    if (ret->storageVols == NULL)
-        goto failed;
-
-    pthread_mutex_init(&ret->lock, NULL);
-
-    ret->refs = 1;
-    return(ret);
-
-failed:
-    if (ret != NULL) {
-        if (ret->domains != NULL)
-            virHashFree(ret->domains, (virHashDeallocator) virDomainFreeName);
-        if (ret->networks != NULL)
-            virHashFree(ret->networks, (virHashDeallocator) virNetworkFreeName);
-        if (ret->storagePools != NULL)
-            virHashFree(ret->storagePools, (virHashDeallocator) virStoragePoolFreeName);
-        if (ret->storageVols != NULL)
-            virHashFree(ret->storageVols, (virHashDeallocator) virStorageVolFreeName);
-
-        pthread_mutex_destroy(&ret->lock);
-        VIR_FREE(ret);
-    }
-    return(NULL);
-}
-
-/**
- * virReleaseConnect:
- * @conn: the hypervisor connection to release
- *
- * Unconditionally release all memory associated with a connection.
- * The conn.lock mutex must be held prior to calling this, and will
- * be released prior to this returning. The connection obj must not
- * be used once this method returns.
- */
-static void
-virReleaseConnect(virConnectPtr conn) {
-    DEBUG("release connection %p %s", conn, conn->name);
-    if (conn->domains != NULL)
-        virHashFree(conn->domains, (virHashDeallocator) virDomainFreeName);
-    if (conn->networks != NULL)
-        virHashFree(conn->networks, (virHashDeallocator) virNetworkFreeName);
-    if (conn->storagePools != NULL)
-        virHashFree(conn->storagePools, (virHashDeallocator) virStoragePoolFreeName);
-    if (conn->storageVols != NULL)
-        virHashFree(conn->storageVols, (virHashDeallocator) virStorageVolFreeName);
-
-    virResetError(&conn->err);
-    if (virLastErr.conn == conn)
-        virLastErr.conn = NULL;
-
-    VIR_FREE(conn->name);
-
-    pthread_mutex_unlock(&conn->lock);
-    pthread_mutex_destroy(&conn->lock);
-    VIR_FREE(conn);
-}
-
-/**
- * virUnrefConnect:
- * @conn: the hypervisor connection to unreference
- *
- * Unreference the connection. If the use count drops to zero, the structure is
- * actually freed.
- *
- * Returns the reference count or -1 in case of failure.
- */
-int
-virUnrefConnect(virConnectPtr conn) {
-    int refs;
-
-    if ((!VIR_IS_CONNECT(conn))) {
-        virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(-1);
-    }
-    pthread_mutex_lock(&conn->lock);
-    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
-    conn->refs--;
-    refs = conn->refs;
-    if (refs == 0) {
-        virReleaseConnect(conn);
-        /* Already unlocked mutex */
-        return (0);
-    }
-    pthread_mutex_unlock(&conn->lock);
-    return (refs);
-}
-
-/**
- * virGetDomain:
- * @conn: the hypervisor connection
- * @name: pointer to the domain name
- * @uuid: pointer to the uuid
- *
- * Lookup if the domain is already registered for that connection,
- * if yes return a new pointer to it, if no allocate a new structure,
- * and register it in the table. In any case a corresponding call to
- * virUnrefDomain() is needed to not leak data.
- *
- * Returns a pointer to the domain, or NULL in case of failure
- */
-virDomainPtr
-__virGetDomain(virConnectPtr conn, const char *name, const unsigned char *uuid) {
-    virDomainPtr ret = NULL;
-
-    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
-        virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(NULL);
-    }
-    pthread_mutex_lock(&conn->lock);
-
-    /* TODO search by UUID first as they are better differenciators */
-
-    ret = (virDomainPtr) virHashLookup(conn->domains, name);
-    /* TODO check the UUID */
-    if (ret == NULL) {
-        if (VIR_ALLOC(ret) < 0) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating domain"));
-            goto error;
-        }
-        ret->name = strdup(name);
-        if (ret->name == NULL) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating domain"));
-            goto error;
-        }
-        ret->magic = VIR_DOMAIN_MAGIC;
-        ret->conn = conn;
-        ret->id = -1;
-        if (uuid != NULL)
-            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
-
-        if (virHashAddEntry(conn->domains, name, ret) < 0) {
-            virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("failed to add domain to connection hash table"));
-            goto error;
-        }
-        conn->refs++;
-        DEBUG("New hash entry %p", ret);
-    } else {
-        DEBUG("Existing hash entry %p: refs now %d", ret, ret->refs+1);
-    }
-    ret->refs++;
-    pthread_mutex_unlock(&conn->lock);
-    return(ret);
-
- error:
-    pthread_mutex_unlock(&conn->lock);
-    if (ret != NULL) {
-        VIR_FREE(ret->name);
-        VIR_FREE(ret);
-    }
-    return(NULL);
-}
-
-/**
- * virReleaseDomain:
- * @domain: the domain to release
- *
- * Unconditionally release all memory associated with a domain.
- * The conn.lock mutex must be held prior to calling this, and will
- * be released prior to this returning. The domain obj must not
- * be used once this method returns.
- *
- * It will also unreference the associated connection object,
- * which may also be released if its ref count hits zero.
- */
-static void
-virReleaseDomain(virDomainPtr domain) {
-    virConnectPtr conn = domain->conn;
-    DEBUG("release domain %p %s", domain, domain->name);
-
-    /* TODO search by UUID first as they are better differenciators */
-    if (virHashRemoveEntry(conn->domains, domain->name, NULL) < 0)
-        virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                     "%s", _("domain missing from connection hash table"));
-
-    if (conn->err.dom == domain)
-        conn->err.dom = NULL;
-    if (virLastErr.dom == domain)
-        virLastErr.dom = NULL;
-    domain->magic = -1;
-    domain->id = -1;
-    VIR_FREE(domain->name);
-    VIR_FREE(domain);
-
-    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
-    conn->refs--;
-    if (conn->refs == 0) {
-        virReleaseConnect(conn);
-        /* Already unlocked mutex */
-        return;
-    }
-
-    pthread_mutex_unlock(&conn->lock);
-}
-
-
-/**
- * virUnrefDomain:
- * @domain: the domain to unreference
- *
- * Unreference the domain. If the use count drops to zero, the structure is
- * actually freed.
- *
- * Returns the reference count or -1 in case of failure.
- */
-int
-virUnrefDomain(virDomainPtr domain) {
-    int refs;
-
-    if (!VIR_IS_CONNECTED_DOMAIN(domain)) {
-        virHashError(domain->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(-1);
-    }
-    pthread_mutex_lock(&domain->conn->lock);
-    DEBUG("unref domain %p %s %d", domain, domain->name, domain->refs);
-    domain->refs--;
-    refs = domain->refs;
-    if (refs == 0) {
-        virReleaseDomain(domain);
-        /* Already unlocked mutex */
-        return (0);
-    }
-
-    pthread_mutex_unlock(&domain->conn->lock);
-    return (refs);
-}
-
-/**
- * virGetNetwork:
- * @conn: the hypervisor connection
- * @name: pointer to the network name
- * @uuid: pointer to the uuid
- *
- * Lookup if the network is already registered for that connection,
- * if yes return a new pointer to it, if no allocate a new structure,
- * and register it in the table. In any case a corresponding call to
- * virUnrefNetwork() is needed to not leak data.
- *
- * Returns a pointer to the network, or NULL in case of failure
- */
-virNetworkPtr
-__virGetNetwork(virConnectPtr conn, const char *name, const unsigned char *uuid) {
-    virNetworkPtr ret = NULL;
-
-    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
-        virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(NULL);
-    }
-    pthread_mutex_lock(&conn->lock);
-
-    /* TODO search by UUID first as they are better differenciators */
-
-    ret = (virNetworkPtr) virHashLookup(conn->networks, name);
-    /* TODO check the UUID */
-    if (ret == NULL) {
-        if (VIR_ALLOC(ret) < 0) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating network"));
-            goto error;
-        }
-        ret->name = strdup(name);
-        if (ret->name == NULL) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating network"));
-            goto error;
-        }
-        ret->magic = VIR_NETWORK_MAGIC;
-        ret->conn = conn;
-        if (uuid != NULL)
-            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
-
-        if (virHashAddEntry(conn->networks, name, ret) < 0) {
-            virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("failed to add network to connection hash table"));
-            goto error;
-        }
-        conn->refs++;
-    }
-    ret->refs++;
-    pthread_mutex_unlock(&conn->lock);
-    return(ret);
-
- error:
-    pthread_mutex_unlock(&conn->lock);
-    if (ret != NULL) {
-        VIR_FREE(ret->name);
-        VIR_FREE(ret);
-    }
-    return(NULL);
-}
-
-/**
- * virReleaseNetwork:
- * @network: the network to release
- *
- * Unconditionally release all memory associated with a network.
- * The conn.lock mutex must be held prior to calling this, and will
- * be released prior to this returning. The network obj must not
- * be used once this method returns.
- *
- * It will also unreference the associated connection object,
- * which may also be released if its ref count hits zero.
- */
-static void
-virReleaseNetwork(virNetworkPtr network) {
-    virConnectPtr conn = network->conn;
-    DEBUG("release network %p %s", network, network->name);
-
-    /* TODO search by UUID first as they are better differenciators */
-    if (virHashRemoveEntry(conn->networks, network->name, NULL) < 0)
-        virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                     "%s", _("network missing from connection hash table"));
-
-    if (conn->err.net == network)
-        conn->err.net = NULL;
-    if (virLastErr.net == network)
-        virLastErr.net = NULL;
-
-    network->magic = -1;
-    VIR_FREE(network->name);
-    VIR_FREE(network);
-
-    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
-    conn->refs--;
-    if (conn->refs == 0) {
-        virReleaseConnect(conn);
-        /* Already unlocked mutex */
-        return;
-    }
-
-    pthread_mutex_unlock(&conn->lock);
-}
-
-
-/**
- * virUnrefNetwork:
- * @network: the network to unreference
- *
- * Unreference the network. If the use count drops to zero, the structure is
- * actually freed.
- *
- * Returns the reference count or -1 in case of failure.
- */
-int
-virUnrefNetwork(virNetworkPtr network) {
-    int refs;
-
-    if (!VIR_IS_CONNECTED_NETWORK(network)) {
-        virHashError(network->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(-1);
-    }
-    pthread_mutex_lock(&network->conn->lock);
-    DEBUG("unref network %p %s %d", network, network->name, network->refs);
-    network->refs--;
-    refs = network->refs;
-    if (refs == 0) {
-        virReleaseNetwork(network);
-        /* Already unlocked mutex */
-        return (0);
-    }
-
-    pthread_mutex_unlock(&network->conn->lock);
-    return (refs);
-}
-
-
-/**
- * virGetStoragePool:
- * @conn: the hypervisor connection
- * @name: pointer to the storage pool name
- * @uuid: pointer to the uuid
- *
- * Lookup if the storage pool is already registered for that connection,
- * if yes return a new pointer to it, if no allocate a new structure,
- * and register it in the table. In any case a corresponding call to
- * virFreeStoragePool() is needed to not leak data.
- *
- * Returns a pointer to the network, or NULL in case of failure
- */
-virStoragePoolPtr
-__virGetStoragePool(virConnectPtr conn, const char *name, const unsigned char *uuid) {
-    virStoragePoolPtr ret = NULL;
-
-    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (uuid == NULL)) {
-        virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(NULL);
-    }
-    pthread_mutex_lock(&conn->lock);
-
-    /* TODO search by UUID first as they are better differenciators */
-
-    ret = (virStoragePoolPtr) virHashLookup(conn->storagePools, name);
-    /* TODO check the UUID */
-    if (ret == NULL) {
-        if (VIR_ALLOC(ret) < 0) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage pool"));
-            goto error;
-        }
-        ret->name = strdup(name);
-        if (ret->name == NULL) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage pool"));
-            goto error;
-        }
-        ret->magic = VIR_STORAGE_POOL_MAGIC;
-        ret->conn = conn;
-        if (uuid != NULL)
-            memcpy(&(ret->uuid[0]), uuid, VIR_UUID_BUFLEN);
-
-        if (virHashAddEntry(conn->storagePools, name, ret) < 0) {
-            virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("failed to add storage pool to connection hash table"));
-            goto error;
-        }
-        conn->refs++;
-    }
-    ret->refs++;
-    pthread_mutex_unlock(&conn->lock);
-    return(ret);
-
-error:
-    pthread_mutex_unlock(&conn->lock);
-    if (ret != NULL) {
-        VIR_FREE(ret->name);
-        VIR_FREE(ret);
-    }
-    return(NULL);
-}
-
-
-/**
- * virReleaseStoragePool:
- * @pool: the pool to release
- *
- * Unconditionally release all memory associated with a pool.
- * The conn.lock mutex must be held prior to calling this, and will
- * be released prior to this returning. The pool obj must not
- * be used once this method returns.
- *
- * It will also unreference the associated connection object,
- * which may also be released if its ref count hits zero.
- */
-static void
-virReleaseStoragePool(virStoragePoolPtr pool) {
-    virConnectPtr conn = pool->conn;
-    DEBUG("release pool %p %s", pool, pool->name);
-
-    /* TODO search by UUID first as they are better differenciators */
-    if (virHashRemoveEntry(conn->storagePools, pool->name, NULL) < 0)
-        virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                     "%s", _("pool missing from connection hash table"));
-
-    pool->magic = -1;
-    VIR_FREE(pool->name);
-    VIR_FREE(pool);
-
-    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
-    conn->refs--;
-    if (conn->refs == 0) {
-        virReleaseConnect(conn);
-        /* Already unlocked mutex */
-        return;
-    }
-
-    pthread_mutex_unlock(&conn->lock);
-}
-
-
-/**
- * virUnrefStoragePool:
- * @pool: the pool to unreference
- *
- * Unreference the pool. If the use count drops to zero, the structure is
- * actually freed.
- *
- * Returns the reference count or -1 in case of failure.
- */
-int
-virUnrefStoragePool(virStoragePoolPtr pool) {
-    int refs;
-
-    if (!VIR_IS_CONNECTED_STORAGE_POOL(pool)) {
-        virHashError(pool->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(-1);
-    }
-    pthread_mutex_lock(&pool->conn->lock);
-    DEBUG("unref pool %p %s %d", pool, pool->name, pool->refs);
-    pool->refs--;
-    refs = pool->refs;
-    if (refs == 0) {
-        virReleaseStoragePool(pool);
-        /* Already unlocked mutex */
-        return (0);
-    }
-
-    pthread_mutex_unlock(&pool->conn->lock);
-    return (refs);
-}
-
-
-/**
- * virGetStorageVol:
- * @conn: the hypervisor connection
- * @pool: pool owning the volume
- * @name: pointer to the storage vol name
- * @uuid: pointer to the uuid
- *
- * Lookup if the storage vol is already registered for that connection,
- * if yes return a new pointer to it, if no allocate a new structure,
- * and register it in the table. In any case a corresponding call to
- * virFreeStorageVol() is needed to not leak data.
- *
- * Returns a pointer to the storage vol, or NULL in case of failure
- */
-virStorageVolPtr
-__virGetStorageVol(virConnectPtr conn, const char *pool, const char *name, const char *key) {
-    virStorageVolPtr ret = NULL;
-
-    if ((!VIR_IS_CONNECT(conn)) || (name == NULL) || (key == NULL)) {
-        virHashError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(NULL);
-    }
-    pthread_mutex_lock(&conn->lock);
-
-    ret = (virStorageVolPtr) virHashLookup(conn->storageVols, key);
-    if (ret == NULL) {
-        if (VIR_ALLOC(ret) < 0) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
-            goto error;
-        }
-        ret->pool = strdup(pool);
-        if (ret->pool == NULL) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
-            goto error;
-        }
-        ret->name = strdup(name);
-        if (ret->name == NULL) {
-            virHashError(conn, VIR_ERR_NO_MEMORY, "%s", _("allocating storage vol"));
-            goto error;
-        }
-        strncpy(ret->key, key, sizeof(ret->key)-1);
-        ret->key[sizeof(ret->key)-1] = '\0';
-        ret->magic = VIR_STORAGE_VOL_MAGIC;
-        ret->conn = conn;
-
-        if (virHashAddEntry(conn->storageVols, key, ret) < 0) {
-            virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                         "%s", _("failed to add storage vol to connection hash table"));
-            goto error;
-        }
-        conn->refs++;
-    }
-    ret->refs++;
-    pthread_mutex_unlock(&conn->lock);
-    return(ret);
-
-error:
-    pthread_mutex_unlock(&conn->lock);
-    if (ret != NULL) {
-        VIR_FREE(ret->name);
-        VIR_FREE(ret->pool);
-        VIR_FREE(ret);
-    }
-    return(NULL);
-}
-
-
-/**
- * virReleaseStorageVol:
- * @vol: the vol to release
- *
- * Unconditionally release all memory associated with a vol.
- * The conn.lock mutex must be held prior to calling this, and will
- * be released prior to this returning. The vol obj must not
- * be used once this method returns.
- *
- * It will also unreference the associated connection object,
- * which may also be released if its ref count hits zero.
- */
-static void
-virReleaseStorageVol(virStorageVolPtr vol) {
-    virConnectPtr conn = vol->conn;
-    DEBUG("release vol %p %s", vol, vol->name);
-
-    /* TODO search by UUID first as they are better differenciators */
-    if (virHashRemoveEntry(conn->storageVols, vol->key, NULL) < 0)
-        virHashError(conn, VIR_ERR_INTERNAL_ERROR,
-                     "%s", _("vol missing from connection hash table"));
-
-    vol->magic = -1;
-    VIR_FREE(vol->name);
-    VIR_FREE(vol->pool);
-    VIR_FREE(vol);
-
-    DEBUG("unref connection %p %s %d", conn, conn->name, conn->refs);
-    conn->refs--;
-    if (conn->refs == 0) {
-        virReleaseConnect(conn);
-        /* Already unlocked mutex */
-        return;
-    }
-
-    pthread_mutex_unlock(&conn->lock);
-}
-
-
-/**
- * virUnrefStorageVol:
- * @vol: the vol to unreference
- *
- * Unreference the vol. If the use count drops to zero, the structure is
- * actually freed.
- *
- * Returns the reference count or -1 in case of failure.
- */
-int
-virUnrefStorageVol(virStorageVolPtr vol) {
-    int refs;
-
-    if (!VIR_IS_CONNECTED_STORAGE_VOL(vol)) {
-        virHashError(vol->conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
-        return(-1);
-    }
-    pthread_mutex_lock(&vol->conn->lock);
-    DEBUG("unref vol %p %s %d", vol, vol->name, vol->refs);
-    vol->refs--;
-    refs = vol->refs;
-    if (refs == 0) {
-        virReleaseStorageVol(vol);
-        /* Already unlocked mutex */
-        return (0);
-    }
-
-    pthread_mutex_unlock(&vol->conn->lock);
-    return (refs);
-}
diff -r 10d728ae8445 src/internal.h
--- a/src/internal.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/internal.h	Wed Oct 29 20:10:40 2008 +0000
@@ -33,10 +33,8 @@
 
 #include "gettext.h"
 
-#include "hash.h"
 #include "libvirt/libvirt.h"
 #include "libvirt/virterror.h"
-#include "driver.h"
 
 /* On architectures which lack these limits, define them (ie. Cygwin).
  * Note that the libvirt code should be robust enough to handle the
@@ -142,210 +140,6 @@
             __FILE__, __LINE__);
 
 /**
- * VIR_CONNECT_MAGIC:
- *
- * magic value used to protect the API when pointers to connection structures
- * are passed down by the uers.
- */
-#define VIR_CONNECT_MAGIC 	0x4F23DEAD
-#define VIR_IS_CONNECT(obj)	((obj) && (obj)->magic==VIR_CONNECT_MAGIC)
-
-
-/**
- * VIR_DOMAIN_MAGIC:
- *
- * magic value used to protect the API when pointers to domain structures
- * are passed down by the users.
- */
-#define VIR_DOMAIN_MAGIC		0xDEAD4321
-#define VIR_IS_DOMAIN(obj)		((obj) && (obj)->magic==VIR_DOMAIN_MAGIC)
-#define VIR_IS_CONNECTED_DOMAIN(obj)	(VIR_IS_DOMAIN(obj) && VIR_IS_CONNECT((obj)->conn))
-
-/**
- * VIR_NETWORK_MAGIC:
- *
- * magic value used to protect the API when pointers to network structures
- * are passed down by the users.
- */
-#define VIR_NETWORK_MAGIC		0xDEAD1234
-#define VIR_IS_NETWORK(obj)		((obj) && (obj)->magic==VIR_NETWORK_MAGIC)
-#define VIR_IS_CONNECTED_NETWORK(obj)	(VIR_IS_NETWORK(obj) && VIR_IS_CONNECT((obj)->conn))
-
-/**
- * VIR_STORAGE_POOL_MAGIC:
- *
- * magic value used to protect the API when pointers to storage pool structures
- * are passed down by the users.
- */
-#define VIR_STORAGE_POOL_MAGIC		0xDEAD5678
-#define VIR_IS_STORAGE_POOL(obj)		((obj) && (obj)->magic==VIR_STORAGE_POOL_MAGIC)
-#define VIR_IS_CONNECTED_STORAGE_POOL(obj)	(VIR_IS_STORAGE_POOL(obj) && VIR_IS_CONNECT((obj)->conn))
-
-/**
- * VIR_STORAGE_VOL_MAGIC:
- *
- * magic value used to protect the API when pointers to storage vol structures
- * are passed down by the users.
- */
-#define VIR_STORAGE_VOL_MAGIC		0xDEAD8765
-#define VIR_IS_STORAGE_VOL(obj)		((obj) && (obj)->magic==VIR_STORAGE_VOL_MAGIC)
-#define VIR_IS_CONNECTED_STORAGE_VOL(obj)	(VIR_IS_STORAGE_VOL(obj) && VIR_IS_CONNECT((obj)->conn))
-
-/*
- * arbitrary limitations
- */
-#define MAX_DRIVERS 10
-#define MIN_XEN_GUEST_SIZE 64  /* 64 megabytes */
-
-/**
- * _virConnect:
- *
- * Internal structure associated to a connection
- */
-struct _virConnect {
-    unsigned int magic;     /* specific value to check */
-    int flags;              /* a set of connection flags */
-    char *name;                 /* connection URI */
-
-    /* The underlying hypervisor driver and network driver. */
-    virDriverPtr      driver;
-    virNetworkDriverPtr networkDriver;
-    virStorageDriverPtr storageDriver;
-
-    /* Private data pointer which can be used by driver and
-     * network driver as they wish.
-     * NB: 'private' is a reserved word in C++.
-     */
-    void *            privateData;
-    void *            networkPrivateData;
-    void *            storagePrivateData;
-
-    /* Per-connection error. */
-    virError err;           /* the last error */
-    virErrorFunc handler;   /* associated handlet */
-    void *userData;         /* the user data */
-
-    /*
-     * The lock mutex must be acquired before accessing/changing
-     * any of members following this point, or changing the ref
-     * count of any virDomain/virNetwork object associated with
-     * this connection
-     */
-    PTHREAD_MUTEX_T (lock);
-    virHashTablePtr domains;  /* hash table for known domains */
-    virHashTablePtr networks; /* hash table for known domains */
-    virHashTablePtr storagePools;/* hash table for known storage pools */
-    virHashTablePtr storageVols;/* hash table for known storage vols */
-    int refs;                 /* reference count */
-};
-
-/**
-* _virDomain:
-*
-* Internal structure associated to a domain
-*/
-struct _virDomain {
-    unsigned int magic;                  /* specific value to check */
-    int refs;                            /* reference count */
-    virConnectPtr conn;                  /* pointer back to the connection */
-    char *name;                          /* the domain external name */
-    int id;                              /* the domain ID */
-    unsigned char uuid[VIR_UUID_BUFLEN]; /* the domain unique identifier */
-};
-
-/**
-* _virNetwork:
-*
-* Internal structure associated to a domain
-*/
-struct _virNetwork {
-    unsigned int magic;                  /* specific value to check */
-    int refs;                            /* reference count */
-    virConnectPtr conn;                  /* pointer back to the connection */
-    char *name;                          /* the network external name */
-    unsigned char uuid[VIR_UUID_BUFLEN]; /* the network unique identifier */
-};
-
-/**
-* _virStoragePool:
-*
-* Internal structure associated to a storage pool
-*/
-struct _virStoragePool {
-    unsigned int magic;                  /* specific value to check */
-    int refs;                            /* reference count */
-    virConnectPtr conn;                  /* pointer back to the connection */
-    char *name;                          /* the storage pool external name */
-    unsigned char uuid[VIR_UUID_BUFLEN]; /* the storage pool unique identifier */
-};
-
-/**
-* _virStorageVol:
-*
-* Internal structure associated to a storage volume
-*/
-struct _virStorageVol {
-    unsigned int magic;                  /* specific value to check */
-    int refs;                            /* reference count */
-    virConnectPtr conn;                  /* pointer back to the connection */
-    char *pool;                          /* Pool name of owner */
-    char *name;                          /* the storage vol external name */
-    /* XXX currently abusing path for this. Ought not to be so evil */
-    char key[PATH_MAX];                  /* unique key for storage vol */
-};
-
-
-
-/************************************************************************
- *									*
- *	API for domain/connections (de)allocations and lookups		*
- *									*
- ************************************************************************/
-
-virConnectPtr  virGetConnect   (void);
-int            virUnrefConnect (virConnectPtr conn);
-virDomainPtr   __virGetDomain  (virConnectPtr conn,
-                                const char *name,
-                                const unsigned char *uuid);
-int            virUnrefDomain  (virDomainPtr domain);
-virNetworkPtr  __virGetNetwork (virConnectPtr conn,
-                                const char *name,
-                                const unsigned char *uuid);
-int           virUnrefNetwork  (virNetworkPtr network);
-
-virStoragePoolPtr __virGetStoragePool (virConnectPtr conn,
-                                       const char *name,
-                                       const unsigned char *uuid);
-int               virUnrefStoragePool (virStoragePoolPtr pool);
-virStorageVolPtr  __virGetStorageVol  (virConnectPtr conn,
-                                       const char *pool,
-                                       const char *name,
-                                       const char *key);
-int               virUnrefStorageVol  (virStorageVolPtr vol);
-
-#define virGetDomain(c,n,u) __virGetDomain((c),(n),(u))
-#define virGetNetwork(c,n,u) __virGetNetwork((c),(n),(u))
-#define virGetStoragePool(c,n,u) __virGetStoragePool((c),(n),(u))
-#define virGetStorageVol(c,p,n,u) __virGetStorageVol((c),(p),(n),(u))
-
-#ifdef WITH_LIBVIRTD
-int __virStateInitialize(void);
-int __virStateCleanup(void);
-int __virStateReload(void);
-int __virStateActive(void);
-#define virStateInitialize() __virStateInitialize()
-#define virStateCleanup() __virStateCleanup()
-#define virStateReload() __virStateReload()
-#define virStateActive() __virStateActive()
-#endif
-
-int __virDrvSupportsFeature (virConnectPtr conn, int feature);
-
-int __virDomainMigratePrepare (virConnectPtr dconn, char **cookie, int *cookielen, const char *uri_in, char **uri_out, unsigned long flags, const char *dname, unsigned long bandwidth);
-int __virDomainMigratePerform (virDomainPtr domain, const char *cookie, int cookielen, const char *uri, unsigned long flags, const char *dname, unsigned long bandwidth);
-virDomainPtr __virDomainMigrateFinish (virConnectPtr dconn, const char *dname, const char *cookie, int cookielen, const char *uri, unsigned long flags);
-
-/**
  * Domain Event Notification
  */
 
diff -r 10d728ae8445 src/libvirt.c
--- a/src/libvirt.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/libvirt.c	Wed Oct 29 20:10:40 2008 +0000
@@ -32,6 +32,8 @@
 #endif
 
 #include "virterror_internal.h"
+#include "datatypes.h"
+#include "libvirt_internal.h"
 #include "driver.h"
 
 #include "uuid.h"
@@ -66,6 +68,8 @@
  * - use lock to protect against concurrent accesses ?
  * - use reference counting to guarantee coherent pointer state ?
  */
+
+#define MAX_DRIVERS 10
 
 static virDriverPtr virDriverTab[MAX_DRIVERS];
 static int virDriverTabCount = 0;
@@ -5560,3 +5564,5 @@
     return 0;
 }
 
+
+
diff -r 10d728ae8445 src/libvirt_internal.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/libvirt_internal.h	Wed Oct 29 20:10:40 2008 +0000
@@ -0,0 +1,64 @@
+/*
+ * libvirt.h: publically exported APIs, not for public use
+ *
+ * Copyright (C) 2006-2008 Red Hat, Inc.
+ *
+ * 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 __LIBVIRT_H_
+#define __LIBVIRT_H_
+
+#include "internal.h"
+
+
+#ifdef WITH_LIBVIRTD
+int __virStateInitialize(void);
+int __virStateCleanup(void);
+int __virStateReload(void);
+int __virStateActive(void);
+#define virStateInitialize() __virStateInitialize()
+#define virStateCleanup() __virStateCleanup()
+#define virStateReload() __virStateReload()
+#define virStateActive() __virStateActive()
+#endif
+
+int __virDrvSupportsFeature (virConnectPtr conn, int feature);
+
+int __virDomainMigratePrepare (virConnectPtr dconn,
+                               char **cookie,
+                               int *cookielen,
+                               const char *uri_in,
+                               char **uri_out,
+                               unsigned long flags,
+                               const char *dname,
+                               unsigned long bandwidth);
+int __virDomainMigratePerform (virDomainPtr domain,
+                               const char *cookie,
+                               int cookielen,
+                               const char *uri,
+                               unsigned long flags,
+                               const char *dname,
+                               unsigned long bandwidth);
+virDomainPtr __virDomainMigrateFinish (virConnectPtr dconn,
+                                       const char *dname,
+                                       const char *cookie,
+                                       int cookielen,
+                                       const char *uri,
+                                       unsigned long flags);
+
+
+#endif
diff -r 10d728ae8445 src/lxc_driver.c
--- a/src/lxc_driver.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/lxc_driver.c	Wed Oct 29 20:10:40 2008 +0000
@@ -36,6 +36,7 @@
 #include <wait.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "lxc_conf.h"
 #include "lxc_container.h"
 #include "lxc_driver.h"
diff -r 10d728ae8445 src/network_conf.c
--- a/src/network_conf.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/network_conf.c	Wed Oct 29 20:10:40 2008 +0000
@@ -34,6 +34,7 @@
 #include <dirent.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "network_conf.h"
 #include "memory.h"
 #include "xml.h"
diff -r 10d728ae8445 src/network_conf.h
--- a/src/network_conf.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/network_conf.h	Wed Oct 29 20:10:40 2008 +0000
@@ -23,6 +23,10 @@
 
 #ifndef __NETWORK_CONF_H__
 #define __NETWORK_CONF_H__
+
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
 
 #include "internal.h"
 
diff -r 10d728ae8445 src/network_driver.c
--- a/src/network_driver.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/network_driver.c	Wed Oct 29 20:10:40 2008 +0000
@@ -45,6 +45,7 @@
 #include <sys/ioctl.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "network_driver.h"
 #include "network_conf.h"
 #include "driver.h"
diff -r 10d728ae8445 src/openvz_driver.c
--- a/src/openvz_driver.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/openvz_driver.c	Wed Oct 29 20:10:40 2008 +0000
@@ -48,6 +48,7 @@
 #include <sys/wait.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "openvz_driver.h"
 #include "event.h"
 #include "buf.h"
diff -r 10d728ae8445 src/proxy_internal.c
--- a/src/proxy_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/proxy_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -23,6 +23,7 @@
 #include <string.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "driver.h"
 #include "proxy_internal.h"
 #include "util.h"
diff -r 10d728ae8445 src/proxy_internal.h
--- a/src/proxy_internal.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/proxy_internal.h	Wed Oct 29 20:10:40 2008 +0000
@@ -12,7 +12,7 @@
 #ifndef __LIBVIR_PROXY_H__
 #define __LIBVIR_PROXY_H__
 
-#include "libvirt/libvirt.h"
+#include "internal.h"
 
 #define PROXY_SOCKET_PATH "/tmp/livirt_proxy_conn"
 #define PROXY_PROTO_VERSION 1
diff -r 10d728ae8445 src/qemu_driver.c
--- a/src/qemu_driver.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/qemu_driver.c	Wed Oct 29 20:10:40 2008 +0000
@@ -53,6 +53,7 @@
 #endif
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "qemu_driver.h"
 #include "qemu_conf.h"
 #include "c-ctype.h"
diff -r 10d728ae8445 src/qparams.c
--- a/src/qparams.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/qparams.c	Wed Oct 29 20:10:40 2008 +0000
@@ -25,6 +25,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
+
+#include <libxml/uri.h>
 
 #include "virterror_internal.h"
 #include "buf.h"
diff -r 10d728ae8445 src/remote_internal.c
--- a/src/remote_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/remote_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -74,6 +74,7 @@
 #endif
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "driver.h"
 #include "buf.h"
 #include "qparams.h"
diff -r 10d728ae8445 src/stats_linux.c
--- a/src/stats_linux.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/stats_linux.c	Wed Oct 29 20:10:40 2008 +0000
@@ -25,6 +25,7 @@
 #endif
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "util.h"
 #include "xen_unified.h"
 #include "stats_linux.h"
diff -r 10d728ae8445 src/storage_conf.c
--- a/src/storage_conf.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/storage_conf.c	Wed Oct 29 20:10:40 2008 +0000
@@ -23,11 +23,6 @@
 
 #include <config.h>
 
-#include <libxml/parser.h>
-#include <libxml/tree.h>
-#include <libxml/xpath.h>
-#include <libxml/uri.h>
-
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -39,6 +34,7 @@
 #include <string.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "storage_conf.h"
 #include "storage_backend.h"
 #include "xml.h"
diff -r 10d728ae8445 src/storage_conf.h
--- a/src/storage_conf.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/storage_conf.h	Wed Oct 29 20:10:40 2008 +0000
@@ -24,7 +24,10 @@
 #ifndef __VIR_STORAGE_CONF_H__
 #define __VIR_STORAGE_CONF_H__
 
-#include <libvirt/libvirt.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+#include <libxml/xpath.h>
+
 #include "internal.h"
 
 /* Shared structs */
diff -r 10d728ae8445 src/storage_driver.c
--- a/src/storage_driver.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/storage_driver.c	Wed Oct 29 20:10:40 2008 +0000
@@ -33,6 +33,7 @@
 #include <string.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "driver.h"
 #include "util.h"
 #include "storage_driver.h"
diff -r 10d728ae8445 src/test.c
--- a/src/test.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/test.c	Wed Oct 29 20:10:40 2008 +0000
@@ -32,6 +32,7 @@
 
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "test.h"
 #include "buf.h"
 #include "util.h"
diff -r 10d728ae8445 src/uuid.c
--- a/src/uuid.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/uuid.c	Wed Oct 29 20:10:40 2008 +0000
@@ -26,6 +26,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
diff -r 10d728ae8445 src/veth.c
--- a/src/veth.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/veth.c	Wed Oct 29 20:10:40 2008 +0000
@@ -12,6 +12,7 @@
 #include <config.h>
 
 #include <string.h>
+#include <stdio.h>
 
 #include "veth.h"
 #include "internal.h"
diff -r 10d728ae8445 src/virterror.c
--- a/src/virterror.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/virterror.c	Wed Oct 29 20:10:40 2008 +0000
@@ -16,6 +16,7 @@
 #include <stdarg.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 
 virError virLastErr =       /* the last error */
   { .code = 0, .domain = 0, .message = NULL, .level = VIR_ERR_NONE,
diff -r 10d728ae8445 src/xen_internal.c
--- a/src/xen_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xen_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -41,6 +41,7 @@
 #include <xen/sched.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "driver.h"
 #include "util.h"
 #include "xen_unified.h"
diff -r 10d728ae8445 src/xen_internal.h
--- a/src/xen_internal.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xen_internal.h	Wed Oct 29 20:10:40 2008 +0000
@@ -10,6 +10,8 @@
 
 #ifndef __VIR_XEN_INTERNAL_H__
 #define __VIR_XEN_INTERNAL_H__
+
+#include <libxml/uri.h>
 
 #include "internal.h"
 #include "capabilities.h"
diff -r 10d728ae8445 src/xen_unified.c
--- a/src/xen_unified.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xen_unified.c	Wed Oct 29 20:10:40 2008 +0000
@@ -28,7 +28,7 @@
 #include <libxml/uri.h>
 
 #include "virterror_internal.h"
-
+#include "datatypes.h"
 #include "xen_unified.h"
 
 #include "xen_internal.h"
diff -r 10d728ae8445 src/xen_unified.h
--- a/src/xen_unified.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xen_unified.h	Wed Oct 29 20:10:40 2008 +0000
@@ -13,6 +13,7 @@
 
 #include "internal.h"
 #include "capabilities.h"
+#include "driver.h"
 
 #ifndef HAVE_WINSOCK2_H
 #include <sys/un.h>
@@ -29,6 +30,8 @@
 #define XEN_UNIFIED_XS_OFFSET 3
 #define XEN_UNIFIED_XM_OFFSET 4
 #define XEN_UNIFIED_NR_DRIVERS 5
+
+#define MIN_XEN_GUEST_SIZE 64  /* 64 megabytes */
 
 /* _xenUnifiedDriver:
  *
diff -r 10d728ae8445 src/xend_internal.c
--- a/src/xend_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xend_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -33,6 +33,7 @@
 #include <errno.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "xend_internal.h"
 #include "driver.h"
 #include "util.h"
diff -r 10d728ae8445 src/xend_internal.h
--- a/src/xend_internal.h	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xend_internal.h	Wed Oct 29 20:10:40 2008 +0000
@@ -19,6 +19,7 @@
 #include <sys/types.h>
 #include <stdint.h>
 #include <stdbool.h>
+#include <libxml/uri.h>
 
 #include "internal.h"
 #include "capabilities.h"
diff -r 10d728ae8445 src/xm_internal.c
--- a/src/xm_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xm_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -36,6 +36,7 @@
 #include <xen/dom0_ops.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "xm_internal.h"
 #include "xen_unified.h"
 #include "xend_internal.h"
diff -r 10d728ae8445 src/xs_internal.c
--- a/src/xs_internal.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/src/xs_internal.c	Wed Oct 29 20:10:40 2008 +0000
@@ -27,6 +27,7 @@
 #include <xs.h>
 
 #include "virterror_internal.h"
+#include "datatypes.h"
 #include "driver.h"
 #include "xen_unified.h"
 #include "xs_internal.h"
diff -r 10d728ae8445 tests/xmconfigtest.c
--- a/tests/xmconfigtest.c	Wed Oct 29 20:09:50 2008 +0000
+++ b/tests/xmconfigtest.c	Wed Oct 29 20:10:40 2008 +0000
@@ -30,6 +30,7 @@
 #ifdef WITH_XEN
 
 #include "internal.h"
+#include "datatypes.h"
 #include "xen_unified.h"
 #include "xm_internal.h"
 #include "testutils.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 :|


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]