mirror of
https://gitlab.com/libvirt/libvirt.git
synced 2024-08-26 18:41:17 +00:00
Add storage APIs to remote driver
This commit is contained in:
parent
f48160cfb4
commit
661c5c4476
@ -1,3 +1,9 @@
|
|||||||
|
Wed Feb 20 10:18:27 EST 2008 Daniel P. Berrange <berrange@redhat.com>
|
||||||
|
|
||||||
|
* src/remote_internal.c: Implement storage APIs in remote
|
||||||
|
driver. Replace memset+malloc with calloc. Replace strcmp
|
||||||
|
with STREQ
|
||||||
|
|
||||||
Wed Feb 20 10:17:27 EST 2008 Daniel P. Berrange <berrange@redhat.com>
|
Wed Feb 20 10:17:27 EST 2008 Daniel P. Berrange <berrange@redhat.com>
|
||||||
|
|
||||||
* qemud/remote.c: Add binding for storage APIs
|
* qemud/remote.c: Add binding for storage APIs
|
||||||
|
@ -89,7 +89,7 @@ struct private_data {
|
|||||||
gnutls_session_t session; /* GnuTLS session (if uses_tls != 0). */
|
gnutls_session_t session; /* GnuTLS session (if uses_tls != 0). */
|
||||||
char *type; /* Cached return from remoteType. */
|
char *type; /* Cached return from remoteType. */
|
||||||
int counter; /* Generates serial numbers for RPC. */
|
int counter; /* Generates serial numbers for RPC. */
|
||||||
int networkOnly; /* Only used for network API */
|
int localUses; /* Ref count for private data */
|
||||||
char *hostname; /* Original hostname */
|
char *hostname; /* Original hostname */
|
||||||
FILE *debugLog; /* Debug remote protocol */
|
FILE *debugLog; /* Debug remote protocol */
|
||||||
#if HAVE_SASL
|
#if HAVE_SASL
|
||||||
@ -116,6 +116,15 @@ struct private_data {
|
|||||||
return (retcode); \
|
return (retcode); \
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#define GET_STORAGE_PRIVATE(conn,retcode) \
|
||||||
|
struct private_data *priv = (struct private_data *) (conn)->storagePrivateData; \
|
||||||
|
if (!priv || priv->magic != MAGIC) { \
|
||||||
|
error (conn, VIR_ERR_INVALID_ARG, \
|
||||||
|
"tried to use a closed or uninitialised handle"); \
|
||||||
|
return (retcode); \
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
enum {
|
enum {
|
||||||
REMOTE_CALL_IN_OPEN = 1,
|
REMOTE_CALL_IN_OPEN = 1,
|
||||||
REMOTE_CALL_QUIET_MISSING_RPC = 2,
|
REMOTE_CALL_QUIET_MISSING_RPC = 2,
|
||||||
@ -140,8 +149,12 @@ static void error (virConnectPtr conn, virErrorNumber code, const char *info);
|
|||||||
static void server_error (virConnectPtr conn, remote_error *err);
|
static void server_error (virConnectPtr conn, remote_error *err);
|
||||||
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
|
static virDomainPtr get_nonnull_domain (virConnectPtr conn, remote_nonnull_domain domain);
|
||||||
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
|
static virNetworkPtr get_nonnull_network (virConnectPtr conn, remote_nonnull_network network);
|
||||||
|
static virStoragePoolPtr get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool);
|
||||||
|
static virStorageVolPtr get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol);
|
||||||
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
|
static void make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src);
|
||||||
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
|
static void make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src);
|
||||||
|
static void make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr vol_src);
|
||||||
|
static void make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src);
|
||||||
|
|
||||||
/*----------------------------------------------------------------------*/
|
/*----------------------------------------------------------------------*/
|
||||||
|
|
||||||
@ -797,7 +810,7 @@ remoteOpen (virConnectPtr conn,
|
|||||||
if (inside_daemon)
|
if (inside_daemon)
|
||||||
return VIR_DRV_OPEN_DECLINED;
|
return VIR_DRV_OPEN_DECLINED;
|
||||||
|
|
||||||
priv = malloc (sizeof(*priv));
|
priv = calloc (1, sizeof(*priv));
|
||||||
if (!priv) {
|
if (!priv) {
|
||||||
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
|
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
|
||||||
return VIR_DRV_OPEN_ERROR;
|
return VIR_DRV_OPEN_ERROR;
|
||||||
@ -823,7 +836,6 @@ remoteOpen (virConnectPtr conn,
|
|||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
memset(priv, 0, sizeof(struct private_data));
|
|
||||||
priv->magic = DEAD;
|
priv->magic = DEAD;
|
||||||
priv->sock = -1;
|
priv->sock = -1;
|
||||||
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
|
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
|
||||||
@ -2292,7 +2304,7 @@ remoteNetworkOpen (virConnectPtr conn,
|
|||||||
|
|
||||||
if (conn &&
|
if (conn &&
|
||||||
conn->driver &&
|
conn->driver &&
|
||||||
strcmp (conn->driver->name, "remote") == 0) {
|
STREQ (conn->driver->name, "remote")) {
|
||||||
/* If we're here, the remote driver is already
|
/* If we're here, the remote driver is already
|
||||||
* in use due to a) a QEMU uri, or b) a remote
|
* in use due to a) a QEMU uri, or b) a remote
|
||||||
* URI. So we can re-use existing connection
|
* URI. So we can re-use existing connection
|
||||||
@ -2305,7 +2317,7 @@ remoteNetworkOpen (virConnectPtr conn,
|
|||||||
* use the UNIX transport. This handles Xen driver
|
* use the UNIX transport. This handles Xen driver
|
||||||
* which doesn't have its own impl of the network APIs.
|
* which doesn't have its own impl of the network APIs.
|
||||||
*/
|
*/
|
||||||
struct private_data *priv = malloc (sizeof(*priv));
|
struct private_data *priv = calloc (1, sizeof(*priv));
|
||||||
int ret, rflags = 0;
|
int ret, rflags = 0;
|
||||||
if (!priv) {
|
if (!priv) {
|
||||||
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
|
error (conn, VIR_ERR_NO_MEMORY, _("struct private_data"));
|
||||||
@ -2315,7 +2327,6 @@ remoteNetworkOpen (virConnectPtr conn,
|
|||||||
rflags |= VIR_DRV_OPEN_REMOTE_RO;
|
rflags |= VIR_DRV_OPEN_REMOTE_RO;
|
||||||
rflags |= VIR_DRV_OPEN_REMOTE_UNIX;
|
rflags |= VIR_DRV_OPEN_REMOTE_UNIX;
|
||||||
|
|
||||||
memset(priv, 0, sizeof(struct private_data));
|
|
||||||
priv->magic = DEAD;
|
priv->magic = DEAD;
|
||||||
priv->sock = -1;
|
priv->sock = -1;
|
||||||
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
|
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
|
||||||
@ -2324,7 +2335,7 @@ remoteNetworkOpen (virConnectPtr conn,
|
|||||||
free(priv);
|
free(priv);
|
||||||
} else {
|
} else {
|
||||||
priv->magic = MAGIC;
|
priv->magic = MAGIC;
|
||||||
priv->networkOnly = 1;
|
priv->localUses = 1;
|
||||||
conn->networkPrivateData = priv;
|
conn->networkPrivateData = priv;
|
||||||
}
|
}
|
||||||
return ret;
|
return ret;
|
||||||
@ -2336,10 +2347,13 @@ remoteNetworkClose (virConnectPtr conn)
|
|||||||
{
|
{
|
||||||
int ret = 0;
|
int ret = 0;
|
||||||
GET_NETWORK_PRIVATE (conn, -1);
|
GET_NETWORK_PRIVATE (conn, -1);
|
||||||
if (priv->networkOnly) {
|
if (priv->localUses) {
|
||||||
ret = doRemoteClose(conn, priv);
|
priv->localUses--;
|
||||||
free(priv);
|
if (!priv->localUses) {
|
||||||
conn->networkPrivateData = NULL;
|
ret = doRemoteClose(conn, priv);
|
||||||
|
free(priv);
|
||||||
|
conn->networkPrivateData = NULL;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
return ret;
|
return ret;
|
||||||
}
|
}
|
||||||
@ -2667,6 +2681,726 @@ remoteNetworkSetAutostart (virNetworkPtr network, int autostart)
|
|||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/*----------------------------------------------------------------------*/
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStorageOpen (virConnectPtr conn,
|
||||||
|
xmlURIPtr uri,
|
||||||
|
virConnectAuthPtr auth,
|
||||||
|
int flags)
|
||||||
|
{
|
||||||
|
if (inside_daemon)
|
||||||
|
return VIR_DRV_OPEN_DECLINED;
|
||||||
|
|
||||||
|
if (conn &&
|
||||||
|
conn->driver &&
|
||||||
|
STREQ (conn->driver->name, "remote")) {
|
||||||
|
/* If we're here, the remote driver is already
|
||||||
|
* in use due to a) a QEMU uri, or b) a remote
|
||||||
|
* URI. So we can re-use existing connection
|
||||||
|
*/
|
||||||
|
conn->storagePrivateData = conn->privateData;
|
||||||
|
return VIR_DRV_OPEN_SUCCESS;
|
||||||
|
} else if (conn->networkDriver &&
|
||||||
|
STREQ (conn->networkDriver->name, "remote")) {
|
||||||
|
conn->storagePrivateData = conn->networkPrivateData;
|
||||||
|
((struct private_data *)conn->storagePrivateData)->localUses++;
|
||||||
|
return VIR_DRV_OPEN_SUCCESS;
|
||||||
|
} else {
|
||||||
|
/* Using a non-remote driver, so we need to open a
|
||||||
|
* new connection for network APIs, forcing it to
|
||||||
|
* use the UNIX transport. This handles Xen driver
|
||||||
|
* which doesn't have its own impl of the network APIs.
|
||||||
|
*/
|
||||||
|
struct private_data *priv = calloc (1, sizeof(struct private_data));
|
||||||
|
int ret, rflags = 0;
|
||||||
|
if (!priv) {
|
||||||
|
error (NULL, VIR_ERR_NO_MEMORY, _("struct private_data"));
|
||||||
|
return VIR_DRV_OPEN_ERROR;
|
||||||
|
}
|
||||||
|
if (flags & VIR_CONNECT_RO)
|
||||||
|
rflags |= VIR_DRV_OPEN_REMOTE_RO;
|
||||||
|
rflags |= VIR_DRV_OPEN_REMOTE_UNIX;
|
||||||
|
|
||||||
|
priv->magic = DEAD;
|
||||||
|
priv->sock = -1;
|
||||||
|
ret = doRemoteOpen(conn, priv, uri, auth, rflags);
|
||||||
|
if (ret != VIR_DRV_OPEN_SUCCESS) {
|
||||||
|
conn->storagePrivateData = NULL;
|
||||||
|
free(priv);
|
||||||
|
} else {
|
||||||
|
priv->magic = MAGIC;
|
||||||
|
priv->localUses = 1;
|
||||||
|
conn->storagePrivateData = priv;
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStorageClose (virConnectPtr conn)
|
||||||
|
{
|
||||||
|
int ret = 0;
|
||||||
|
GET_STORAGE_PRIVATE (conn, -1);
|
||||||
|
if (priv->localUses) {
|
||||||
|
priv->localUses--;
|
||||||
|
if (!priv->localUses) {
|
||||||
|
ret = doRemoteClose(conn, priv);
|
||||||
|
free(priv);
|
||||||
|
conn->storagePrivateData = NULL;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteNumOfStoragePools (virConnectPtr conn)
|
||||||
|
{
|
||||||
|
remote_num_of_storage_pools_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, -1);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL,
|
||||||
|
(xdrproc_t) xdr_remote_num_of_storage_pools_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return ret.num;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteListStoragePools (virConnectPtr conn, char **const names, int maxnames)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
remote_list_storage_pools_args args;
|
||||||
|
remote_list_storage_pools_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, -1);
|
||||||
|
|
||||||
|
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
|
||||||
|
error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
args.maxnames = maxnames;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS,
|
||||||
|
(xdrproc_t) xdr_remote_list_storage_pools_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (ret.names.names_len > maxnames) {
|
||||||
|
error (conn, VIR_ERR_RPC, _("too many storage pools received"));
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* This call is caller-frees (although that isn't clear from
|
||||||
|
* the documentation). However xdr_free will free up both the
|
||||||
|
* names and the list of pointers, so we have to strdup the
|
||||||
|
* names here.
|
||||||
|
*/
|
||||||
|
for (i = 0; i < ret.names.names_len; ++i)
|
||||||
|
names[i] = strdup (ret.names.names_val[i]);
|
||||||
|
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return ret.names.names_len;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteNumOfDefinedStoragePools (virConnectPtr conn)
|
||||||
|
{
|
||||||
|
remote_num_of_defined_storage_pools_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, -1);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL,
|
||||||
|
(xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return ret.num;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteListDefinedStoragePools (virConnectPtr conn,
|
||||||
|
char **const names, int maxnames)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
remote_list_defined_storage_pools_args args;
|
||||||
|
remote_list_defined_storage_pools_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, -1);
|
||||||
|
|
||||||
|
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
|
||||||
|
error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
args.maxnames = maxnames;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS,
|
||||||
|
(xdrproc_t) xdr_remote_list_defined_storage_pools_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (ret.names.names_len > maxnames) {
|
||||||
|
error (conn, VIR_ERR_RPC, _("too many storage pools received"));
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* This call is caller-frees (although that isn't clear from
|
||||||
|
* the documentation). However xdr_free will free up both the
|
||||||
|
* names and the list of pointers, so we have to strdup the
|
||||||
|
* names here.
|
||||||
|
*/
|
||||||
|
for (i = 0; i < ret.names.names_len; ++i)
|
||||||
|
names[i] = strdup (ret.names.names_val[i]);
|
||||||
|
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return ret.names.names_len;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
remoteStoragePoolLookupByUUID (virConnectPtr conn,
|
||||||
|
const unsigned char *uuid)
|
||||||
|
{
|
||||||
|
virStoragePoolPtr pool;
|
||||||
|
remote_storage_pool_lookup_by_uuid_args args;
|
||||||
|
remote_storage_pool_lookup_by_uuid_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_UUID,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_uuid_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
pool = get_nonnull_storage_pool (conn, ret.pool);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_uuid_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return pool;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
remoteStoragePoolLookupByName (virConnectPtr conn,
|
||||||
|
const char *name)
|
||||||
|
{
|
||||||
|
virStoragePoolPtr pool;
|
||||||
|
remote_storage_pool_lookup_by_name_args args;
|
||||||
|
remote_storage_pool_lookup_by_name_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
args.name = (char *) name;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_NAME,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_name_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_name_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
pool = get_nonnull_storage_pool (conn, ret.pool);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_name_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return pool;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
remoteStoragePoolLookupByVolume (virStorageVolPtr vol)
|
||||||
|
{
|
||||||
|
virStoragePoolPtr pool;
|
||||||
|
remote_storage_pool_lookup_by_volume_args args;
|
||||||
|
remote_storage_pool_lookup_by_volume_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (vol->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_vol (&args.vol, vol);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LOOKUP_BY_VOLUME,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_lookup_by_volume_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
pool = get_nonnull_storage_pool (vol->conn, ret.pool);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_volume_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return pool;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
|
||||||
|
{
|
||||||
|
virStoragePoolPtr pool;
|
||||||
|
remote_storage_pool_create_xml_args args;
|
||||||
|
remote_storage_pool_create_xml_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
args.xml = (char *) xmlDesc;
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE_XML,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_create_xml_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_create_xml_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
pool = get_nonnull_storage_pool (conn, ret.pool);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_pool_create_xml_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return pool;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
remoteStoragePoolDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
|
||||||
|
{
|
||||||
|
virStoragePoolPtr pool;
|
||||||
|
remote_storage_pool_define_xml_args args;
|
||||||
|
remote_storage_pool_define_xml_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
args.xml = (char *) xml;
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DEFINE_XML,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_define_xml_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_define_xml_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
pool = get_nonnull_storage_pool (conn, ret.pool);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_pool_define_xml_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return pool;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolUndefine (virStoragePoolPtr pool)
|
||||||
|
{
|
||||||
|
remote_storage_pool_undefine_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_UNDEFINE,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_undefine_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolCreate (virStoragePoolPtr pool, unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_pool_create_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_create_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolBuild (virStoragePoolPtr pool,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_pool_build_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_build_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolDestroy (virStoragePoolPtr pool)
|
||||||
|
{
|
||||||
|
remote_storage_pool_destroy_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DESTROY,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_destroy_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolDelete (virStoragePoolPtr pool,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_pool_delete_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_delete_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolRefresh (virStoragePoolPtr pool,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_pool_refresh_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_refresh_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
|
||||||
|
{
|
||||||
|
remote_storage_pool_get_info_args args;
|
||||||
|
remote_storage_pool_get_info_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_INFO,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_get_info_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_get_info_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
info->state = ret.state;
|
||||||
|
info->capacity = ret.capacity;
|
||||||
|
info->allocation = ret.allocation;
|
||||||
|
info->available = ret.available;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
remoteStoragePoolDumpXML (virStoragePoolPtr pool,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_pool_dump_xml_args args;
|
||||||
|
remote_storage_pool_dump_xml_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DUMP_XML,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_dump_xml_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_dump_xml_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* Caller frees. */
|
||||||
|
return ret.xml;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolGetAutostart (virStoragePoolPtr pool, int *autostart)
|
||||||
|
{
|
||||||
|
remote_storage_pool_get_autostart_args args;
|
||||||
|
remote_storage_pool_get_autostart_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_GET_AUTOSTART,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_get_autostart_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_get_autostart_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (autostart) *autostart = ret.autostart;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolSetAutostart (virStoragePoolPtr pool, int autostart)
|
||||||
|
{
|
||||||
|
remote_storage_pool_set_autostart_args args;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.autostart = autostart;
|
||||||
|
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_set_autostart_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolNumOfVolumes (virStoragePoolPtr pool)
|
||||||
|
{
|
||||||
|
remote_storage_pool_num_of_volumes_args args;
|
||||||
|
remote_storage_pool_num_of_volumes_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool(&args.pool, pool);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return ret.num;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStoragePoolListVolumes (virStoragePoolPtr pool, char **const names, int maxnames)
|
||||||
|
{
|
||||||
|
int i;
|
||||||
|
remote_storage_pool_list_volumes_args args;
|
||||||
|
remote_storage_pool_list_volumes_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, -1);
|
||||||
|
|
||||||
|
if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
|
||||||
|
error (pool->conn, VIR_ERR_RPC, _("too many storage volumes requested"));
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
args.maxnames = maxnames;
|
||||||
|
make_nonnull_storage_pool(&args.pool, pool);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_list_volumes_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (ret.names.names_len > maxnames) {
|
||||||
|
error (pool->conn, VIR_ERR_RPC, _("too many storage volumes received"));
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret);
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* This call is caller-frees (although that isn't clear from
|
||||||
|
* the documentation). However xdr_free will free up both the
|
||||||
|
* names and the list of pointers, so we have to strdup the
|
||||||
|
* names here.
|
||||||
|
*/
|
||||||
|
for (i = 0; i < ret.names.names_len; ++i)
|
||||||
|
names[i] = strdup (ret.names.names_val[i]);
|
||||||
|
|
||||||
|
xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return ret.names.names_len;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
static virStorageVolPtr
|
||||||
|
remoteStorageVolLookupByName (virStoragePoolPtr pool,
|
||||||
|
const char *name)
|
||||||
|
{
|
||||||
|
virStorageVolPtr vol;
|
||||||
|
remote_storage_vol_lookup_by_name_args args;
|
||||||
|
remote_storage_vol_lookup_by_name_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool(&args.pool, pool);
|
||||||
|
args.name = (char *) name;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_NAME,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_name_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_name_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
vol = get_nonnull_storage_vol (pool->conn, ret.vol);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_name_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return vol;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStorageVolPtr
|
||||||
|
remoteStorageVolLookupByKey (virConnectPtr conn,
|
||||||
|
const char *key)
|
||||||
|
{
|
||||||
|
virStorageVolPtr vol;
|
||||||
|
remote_storage_vol_lookup_by_key_args args;
|
||||||
|
remote_storage_vol_lookup_by_key_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
args.key = (char *) key;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_KEY,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_key_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_key_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
vol = get_nonnull_storage_vol (conn, ret.vol);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_key_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return vol;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStorageVolPtr
|
||||||
|
remoteStorageVolLookupByPath (virConnectPtr conn,
|
||||||
|
const char *path)
|
||||||
|
{
|
||||||
|
virStorageVolPtr vol;
|
||||||
|
remote_storage_vol_lookup_by_path_args args;
|
||||||
|
remote_storage_vol_lookup_by_path_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (conn, NULL);
|
||||||
|
|
||||||
|
args.path = (char *) path;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (conn, priv, 0, REMOTE_PROC_STORAGE_VOL_LOOKUP_BY_PATH,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_path_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_lookup_by_path_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
vol = get_nonnull_storage_vol (conn, ret.vol);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_path_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return vol;
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStorageVolPtr
|
||||||
|
remoteStorageVolCreateXML (virStoragePoolPtr pool, const char *xmlDesc,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
virStorageVolPtr vol;
|
||||||
|
remote_storage_vol_create_xml_args args;
|
||||||
|
remote_storage_vol_create_xml_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (pool->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_pool (&args.pool, pool);
|
||||||
|
args.xml = (char *) xmlDesc;
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_create_xml_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_create_xml_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
vol = get_nonnull_storage_vol (pool->conn, ret.vol);
|
||||||
|
xdr_free ((xdrproc_t) &xdr_remote_storage_vol_create_xml_ret, (char *) &ret);
|
||||||
|
|
||||||
|
return vol;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStorageVolDelete (virStorageVolPtr vol,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_vol_delete_args args;
|
||||||
|
GET_STORAGE_PRIVATE (vol->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_vol (&args.vol, vol);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_delete_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_void, (char *) NULL) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static int
|
||||||
|
remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
|
||||||
|
{
|
||||||
|
remote_storage_vol_get_info_args args;
|
||||||
|
remote_storage_vol_get_info_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (vol->conn, -1);
|
||||||
|
|
||||||
|
make_nonnull_storage_vol (&args.vol, vol);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_INFO,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_get_info_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_get_info_ret, (char *) &ret) == -1)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
info->type = ret.type;
|
||||||
|
info->capacity = ret.capacity;
|
||||||
|
info->allocation = ret.allocation;
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
remoteStorageVolDumpXML (virStorageVolPtr vol,
|
||||||
|
unsigned int flags)
|
||||||
|
{
|
||||||
|
remote_storage_vol_dump_xml_args args;
|
||||||
|
remote_storage_vol_dump_xml_ret ret;
|
||||||
|
GET_STORAGE_PRIVATE (vol->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_vol (&args.vol, vol);
|
||||||
|
args.flags = flags;
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DUMP_XML,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_dump_xml_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_dump_xml_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* Caller frees. */
|
||||||
|
return ret.xml;
|
||||||
|
}
|
||||||
|
|
||||||
|
static char *
|
||||||
|
remoteStorageVolGetPath (virStorageVolPtr vol)
|
||||||
|
{
|
||||||
|
remote_storage_vol_get_path_args args;
|
||||||
|
remote_storage_vol_get_path_ret ret;
|
||||||
|
GET_NETWORK_PRIVATE (vol->conn, NULL);
|
||||||
|
|
||||||
|
make_nonnull_storage_vol (&args.vol, vol);
|
||||||
|
|
||||||
|
memset (&ret, 0, sizeof ret);
|
||||||
|
if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_PATH,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_get_path_args, (char *) &args,
|
||||||
|
(xdrproc_t) xdr_remote_storage_vol_get_path_ret, (char *) &ret) == -1)
|
||||||
|
return NULL;
|
||||||
|
|
||||||
|
/* Caller frees. */
|
||||||
|
return ret.name;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
/*----------------------------------------------------------------------*/
|
/*----------------------------------------------------------------------*/
|
||||||
|
|
||||||
static int
|
static int
|
||||||
@ -3816,6 +4550,18 @@ get_nonnull_network (virConnectPtr conn, remote_nonnull_network network)
|
|||||||
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
|
return virGetNetwork (conn, network.name, BAD_CAST network.uuid);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static virStoragePoolPtr
|
||||||
|
get_nonnull_storage_pool (virConnectPtr conn, remote_nonnull_storage_pool pool)
|
||||||
|
{
|
||||||
|
return virGetStoragePool (conn, pool.name, BAD_CAST pool.uuid);
|
||||||
|
}
|
||||||
|
|
||||||
|
static virStorageVolPtr
|
||||||
|
get_nonnull_storage_vol (virConnectPtr conn, remote_nonnull_storage_vol vol)
|
||||||
|
{
|
||||||
|
return virGetStorageVol (conn, vol.pool, vol.name, vol.key);
|
||||||
|
}
|
||||||
|
|
||||||
/* Make remote_nonnull_domain and remote_nonnull_network. */
|
/* Make remote_nonnull_domain and remote_nonnull_network. */
|
||||||
static void
|
static void
|
||||||
make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
|
make_nonnull_domain (remote_nonnull_domain *dom_dst, virDomainPtr dom_src)
|
||||||
@ -3832,6 +4578,21 @@ make_nonnull_network (remote_nonnull_network *net_dst, virNetworkPtr net_src)
|
|||||||
memcpy (net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
|
memcpy (net_dst->uuid, net_src->uuid, VIR_UUID_BUFLEN);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
make_nonnull_storage_pool (remote_nonnull_storage_pool *pool_dst, virStoragePoolPtr pool_src)
|
||||||
|
{
|
||||||
|
pool_dst->name = pool_src->name;
|
||||||
|
memcpy (pool_dst->uuid, pool_src->uuid, VIR_UUID_BUFLEN);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void
|
||||||
|
make_nonnull_storage_vol (remote_nonnull_storage_vol *vol_dst, virStorageVolPtr vol_src)
|
||||||
|
{
|
||||||
|
vol_dst->pool = vol_src->pool;
|
||||||
|
vol_dst->name = vol_src->name;
|
||||||
|
vol_dst->key = vol_src->key;
|
||||||
|
}
|
||||||
|
|
||||||
/*----------------------------------------------------------------------*/
|
/*----------------------------------------------------------------------*/
|
||||||
|
|
||||||
static virDriver driver = {
|
static virDriver driver = {
|
||||||
@ -3912,6 +4673,42 @@ static virNetworkDriver network_driver = {
|
|||||||
.networkSetAutostart = remoteNetworkSetAutostart,
|
.networkSetAutostart = remoteNetworkSetAutostart,
|
||||||
};
|
};
|
||||||
|
|
||||||
|
static virStorageDriver storage_driver = {
|
||||||
|
.name = "remote",
|
||||||
|
.open = remoteStorageOpen,
|
||||||
|
.close = remoteStorageClose,
|
||||||
|
.numOfPools = remoteNumOfStoragePools,
|
||||||
|
.listPools = remoteListStoragePools,
|
||||||
|
.numOfDefinedPools = remoteNumOfDefinedStoragePools,
|
||||||
|
.listDefinedPools = remoteListDefinedStoragePools,
|
||||||
|
.poolLookupByUUID = remoteStoragePoolLookupByUUID,
|
||||||
|
.poolLookupByName = remoteStoragePoolLookupByName,
|
||||||
|
.poolLookupByVolume = remoteStoragePoolLookupByVolume,
|
||||||
|
.poolCreateXML = remoteStoragePoolCreateXML,
|
||||||
|
.poolDefineXML = remoteStoragePoolDefineXML,
|
||||||
|
.poolUndefine = remoteStoragePoolUndefine,
|
||||||
|
.poolCreate = remoteStoragePoolCreate,
|
||||||
|
.poolBuild = remoteStoragePoolBuild,
|
||||||
|
.poolDestroy = remoteStoragePoolDestroy,
|
||||||
|
.poolDelete = remoteStoragePoolDelete,
|
||||||
|
.poolRefresh = remoteStoragePoolRefresh,
|
||||||
|
.poolGetInfo = remoteStoragePoolGetInfo,
|
||||||
|
.poolGetXMLDesc = remoteStoragePoolDumpXML,
|
||||||
|
.poolGetAutostart = remoteStoragePoolGetAutostart,
|
||||||
|
.poolSetAutostart = remoteStoragePoolSetAutostart,
|
||||||
|
.poolNumOfVolumes = remoteStoragePoolNumOfVolumes,
|
||||||
|
.poolListVolumes = remoteStoragePoolListVolumes,
|
||||||
|
|
||||||
|
.volLookupByName = remoteStorageVolLookupByName,
|
||||||
|
.volLookupByKey = remoteStorageVolLookupByKey,
|
||||||
|
.volLookupByPath = remoteStorageVolLookupByPath,
|
||||||
|
.volCreateXML = remoteStorageVolCreateXML,
|
||||||
|
.volDelete = remoteStorageVolDelete,
|
||||||
|
.volGetInfo = remoteStorageVolGetInfo,
|
||||||
|
.volGetXMLDesc = remoteStorageVolDumpXML,
|
||||||
|
.volGetPath = remoteStorageVolGetPath,
|
||||||
|
};
|
||||||
|
|
||||||
static virStateDriver state_driver = {
|
static virStateDriver state_driver = {
|
||||||
remoteStartup,
|
remoteStartup,
|
||||||
NULL,
|
NULL,
|
||||||
@ -3931,6 +4728,7 @@ remoteRegister (void)
|
|||||||
{
|
{
|
||||||
if (virRegisterDriver (&driver) == -1) return -1;
|
if (virRegisterDriver (&driver) == -1) return -1;
|
||||||
if (virRegisterNetworkDriver (&network_driver) == -1) return -1;
|
if (virRegisterNetworkDriver (&network_driver) == -1) return -1;
|
||||||
|
if (virRegisterStorageDriver (&storage_driver) == -1) return -1;
|
||||||
if (virRegisterStateDriver (&state_driver) == -1) return -1;
|
if (virRegisterStateDriver (&state_driver) == -1) return -1;
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
|
Loading…
Reference in New Issue
Block a user