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 :|