External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-10-01 20:05:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move some API declarations out of internal.h & hash.c into dedicated files

Browse Source
This commit is contained in:
Daniel P. Berrange 2008-11-04 23:22:06 +00:00
parent 2f19b24a03
commit 6ace5a39c3
42 changed files with 1127 additions and 948 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
ChangeLog
View File

@ -1,3 +1,28 @@
Tue Nov 4 23:08:31 UTC 2008 Daniel P. Berrange <berrange@redhat.com>
Move internal API declarations from generic internal.h file
* src/Makefile.am, src/datatypes.c, src/datatypes.h: Add
internal struct definitions for public objects, and helper
methods.
* src/hash.c: Remove helper methods for public objects
* src/libvirt_internal.h: Add definition of semi-secret
public APIs for migration & stateful drivers.
* src/internal.h: Remove internal API declarations for
migration & stateful drivers.
* po/POTFILES.in, proxy/libvirt_proxy.c, qemud/qemud.c,
qemud/remote.c, src/domain_conf.c, src/domain_conf.h,
src/driver.h, src/libvirt.c, src/lxc_driver.c,
src/network_conf.c, src/network_conf.h, src/network_driver.c,
src/openvz_driver.c, src/proxy_internal.c,
src/proxy_internal.h, src/qemu_driver.c, src/qparams.c,
src/remote_internal.c, src/stats_linux.c, src/storage_conf.c,
src/storage_conf.h, src/storage_driver.c, src/test.c,
src/uuid.c, src/veth.c, src/virterror.c, src/xen_internal.c,
src/xen_internal.h, src/xen_unified.c, src/xen_unified.h,
src/xend_internal.c, src/xend_internal.h, src/xm_internal.c,
src/xs_internal.c, tests/xmconfigtest.c: Add includes for
libvirt_internal.h and datatypes.h where required
Tue Nov 4 22:52:31 UTC 2008 Daniel P. Berrange <berrange@redhat.com>
* qemud/qemud.c, src/driver.h, src/internal.h, src/libvirt.c

2
po/POTFILES.in
View File

@ -3,8 +3,8 @@ qemud/qemud.c
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

2
proxy/libvirt_proxy.c
View File

@ -24,7 +24,7 @@
#include <locale.h>
#include "internal.h"
#include "datatypes.h"
#include "proxy_internal.h"
#include "util.h"
#include "xen_internal.h"

2
qemud/qemud.c
View File

@ -49,7 +49,7 @@
#include <signal.h>
#include <netdb.h>
#include "internal.h"
#include "libvirt_internal.h"
#include "qemud.h"
#include "util.h"

3
qemud/remote.c
View File

@ -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"

3
src/Makefile.am
View File

@ -44,6 +44,7 @@ GENERIC_LIB_SOURCES = \
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 @@ STORAGE_HELPER_DISK_SOURCES = \
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) \

772
src/datatypes.c Normal file
View File

@ -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);
}

212
src/datatypes.h Normal file
View File

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

1
src/domain_conf.c
View File

@ -30,6 +30,7 @@
#include <dirent.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "domain_conf.h"
#include "memory.h"
#include "verify.h"

4
src/domain_conf.h
View File

@ -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"

3
src/driver.h
View File

@ -6,9 +6,6 @@
#ifndef __VIR_DRIVER_H__
#define __VIR_DRIVER_H__
#include "libvirt/libvirt.h"
#include "libvirt/virterror.h"
#include <libxml/uri.h>
/*

725
src/hash.c
View File

@ -594,728 +594,3 @@ void *virHashSearch(virHashTablePtr table, virHashSearcher iter, const void *dat
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);
}

206
src/internal.h
View File

@ -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
@ -141,210 +139,6 @@ extern int debugFlag;
fprintf(stderr, "Unimplemented block at %s:%d\n", \
__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
*/

6
src/libvirt.c
View File

@ -32,6 +32,8 @@
#endif
#include "virterror_internal.h"
#include "datatypes.h"
#include "libvirt_internal.h"
#include "driver.h"
#include "uuid.h"
@ -67,6 +69,8 @@
* - use reference counting to guarantee coherent pointer state ?
*/
#define MAX_DRIVERS 10
static virDriverPtr virDriverTab[MAX_DRIVERS];
static int virDriverTabCount = 0;
static virNetworkDriverPtr virNetworkDriverTab[MAX_DRIVERS];
@ -5560,3 +5564,5 @@ __virDomainEventCallbackQueuePush(virDomainEventQueuePtr evtQueue,
return 0;
}

64
src/libvirt_internal.h Normal file
View File

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

1
src/lxc_driver.c
View File

@ -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"

1
src/network_conf.c
View File

@ -34,6 +34,7 @@
#include <dirent.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "network_conf.h"
#include "memory.h"
#include "xml.h"

4
src/network_conf.h
View File

@ -24,6 +24,10 @@
#ifndef __NETWORK_CONF_H__
#define __NETWORK_CONF_H__
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xpath.h>
#include "internal.h"
/* 2 possible types of forwarding */

1
src/network_driver.c
View File

@ -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"

1
src/openvz_driver.c
View File

@ -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"

1
src/proxy_internal.c
View File

@ -23,6 +23,7 @@
#include <string.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "driver.h"
#include "proxy_internal.h"
#include "util.h"

2
src/proxy_internal.h
View File

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

1
src/qemu_driver.c
View File

@ -53,6 +53,7 @@
#endif
#include "virterror_internal.h"
#include "datatypes.h"
#include "qemu_driver.h"
#include "qemu_conf.h"
#include "c-ctype.h"

2
src/qparams.c
View File

@ -26,6 +26,8 @@
#include <stdlib.h>
#include <stdarg.h>
#include <libxml/uri.h>
#include "virterror_internal.h"
#include "buf.h"
#include "memory.h"

1
src/remote_internal.c
View File

@ -74,6 +74,7 @@
#endif
#include "virterror_internal.h"
#include "datatypes.h"
#include "driver.h"
#include "buf.h"
#include "qparams.h"

1
src/stats_linux.c
View File

@ -25,6 +25,7 @@
#endif
#include "virterror_internal.h"
#include "datatypes.h"
#include "util.h"
#include "xen_unified.h"
#include "stats_linux.h"

6
src/storage_conf.c
View File

@ -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"

5
src/storage_conf.h
View File

@ -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 */

1
src/storage_driver.c
View File

@ -33,6 +33,7 @@
#include <string.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "driver.h"
#include "util.h"
#include "storage_driver.h"

1
src/test.c
View File

@ -33,6 +33,7 @@
#include "virterror_internal.h"
#include "datatypes.h"
#include "test.h"
#include "buf.h"
#include "util.h"

1
src/uuid.c
View File

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

1
src/veth.c
View File

@ -12,6 +12,7 @@
#include <config.h>
#include <string.h>
#include <stdio.h>
#include "veth.h"
#include "internal.h"

1
src/virterror.c
View File

@ -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,

1
src/xen_internal.c
View File

@ -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"

2
src/xen_internal.h
View File

@ -11,6 +11,8 @@
#ifndef __VIR_XEN_INTERNAL_H__
#define __VIR_XEN_INTERNAL_H__
#include <libxml/uri.h>
#include "internal.h"
#include "capabilities.h"

2
src/xen_unified.c
View File

@ -28,7 +28,7 @@
#include <libxml/uri.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "xen_unified.h"
#include "xen_internal.h"

3
src/xen_unified.h
View File

@ -13,6 +13,7 @@
#include "internal.h"
#include "capabilities.h"
#include "driver.h"
#ifndef HAVE_WINSOCK2_H
#include <sys/un.h>
@ -30,6 +31,8 @@ extern int xenUnifiedRegister (void);
#define XEN_UNIFIED_XM_OFFSET 4
#define XEN_UNIFIED_NR_DRIVERS 5
#define MIN_XEN_GUEST_SIZE 64 /* 64 megabytes */
/* _xenUnifiedDriver:
*
* Entry points into the underlying Xen drivers. This structure

1
src/xend_internal.c
View File

@ -33,6 +33,7 @@
#include <errno.h>
#include "virterror_internal.h"
#include "datatypes.h"
#include "xend_internal.h"
#include "driver.h"
#include "util.h"

1
src/xend_internal.h
View File

@ -19,6 +19,7 @@
#include <sys/types.h>
#include <stdint.h>
#include <stdbool.h>
#include <libxml/uri.h>
#include "internal.h"
#include "capabilities.h"

1
src/xm_internal.c
View File

@ -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"

1
src/xs_internal.c
View File

@ -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"

1
tests/xmconfigtest.c
View File

@ -30,6 +30,7 @@
#ifdef WITH_XEN
#include "internal.h"
#include "datatypes.h"
#include "xen_unified.h"
#include "xm_internal.h"
#include "testutils.h"