#include "util.h"
#include "event.h"
-/* Per-connection private data. */
-#define MAGIC 999 /* private_data->magic if OK */
-#define DEAD 998 /* private_data->magic if dead/closed */
-
static int inside_daemon = 0;
struct private_data {
- int magic; /* Should be MAGIC or DEAD. */
int sock; /* Socket. */
int watch; /* File handle watch */
pid_t pid; /* PID of tunnel process */
int eventFlushTimer;
};
-#define GET_PRIVATE(conn,retcode) \
- struct private_data *priv = (struct private_data *) (conn)->privateData; \
- if (!priv || priv->magic != MAGIC) { \
- error (conn, VIR_ERR_INVALID_ARG, \
- _("tried to use a closed or uninitialised handle")); \
- return (retcode); \
- }
-
-#define GET_NETWORK_PRIVATE(conn,retcode) \
- struct private_data *priv = (struct private_data *) (conn)->networkPrivateData; \
- if (!priv || priv->magic != MAGIC) { \
- error (conn, VIR_ERR_INVALID_ARG, \
- _("tried to use a closed or uninitialised handle")); \
- 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); \
- }
-
-#define GET_DEVMON_PRIVATE(conn,retcode) \
- struct private_data *priv = (struct private_data *) (conn)->devMonPrivateData; \
- if (!priv || priv->magic != MAGIC) { \
- error (conn, VIR_ERR_INVALID_ARG, \
- _("tried to use a closed or uninitialised handle")); \
- return (retcode); \
- }
-
-
enum {
REMOTE_CALL_IN_OPEN = 1,
REMOTE_CALL_QUIET_MISSING_RPC = 2,
}
}
- priv->magic = DEAD;
priv->sock = -1;
ret = doRemoteOpen(conn, priv, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->privateData = NULL;
VIR_FREE(priv);
} else {
- priv->magic = MAGIC;
conn->privateData = priv;
}
return ret;
/* See comment for remoteType. */
free (priv->type);
- /* Free private data. */
- priv->magic = DEAD;
-
/* Free callback list */
virDomainEventCallbackListFree(priv->callbackList);
remoteClose (virConnectPtr conn)
{
int ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
ret = doRemoteClose(conn, priv);
- free (priv);
+ VIR_FREE (priv);
conn->privateData = NULL;
return ret;
{
remote_supports_feature_args args;
remote_supports_feature_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
/* VIR_DRV_FEATURE_REMOTE* features are handled directly. */
if (feature == VIR_DRV_FEATURE_REMOTE) return 1;
remoteType (virConnectPtr conn)
{
remote_get_type_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
/* Cached? */
if (priv->type) return priv->type;
remoteGetVersion (virConnectPtr conn, unsigned long *hvVer)
{
remote_get_version_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_GET_VERSION,
remoteGetHostname (virConnectPtr conn)
{
remote_get_hostname_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_GET_HOSTNAME,
{
remote_get_max_vcpus_args args;
remote_get_max_vcpus_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
args.type = type == NULL ? NULL : (char **) &type;
remoteNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info)
{
remote_node_get_info_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_INFO,
remoteGetCapabilities (virConnectPtr conn)
{
remote_get_capabilities_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_GET_CAPABILITIES,
remote_node_get_cells_free_memory_args args;
remote_node_get_cells_free_memory_ret ret;
int i;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
if (maxCells > REMOTE_NODE_MAX_CELLS) {
errorf (conn, VIR_ERR_RPC,
remoteNodeGetFreeMemory (virConnectPtr conn)
{
remote_node_get_free_memory_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
int i;
remote_list_domains_args args;
remote_list_domains_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
if (maxids > REMOTE_DOMAIN_ID_LIST_MAX) {
errorf (conn, VIR_ERR_RPC,
remoteNumOfDomains (virConnectPtr conn)
{
remote_num_of_domains_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DOMAINS,
virDomainPtr dom;
remote_domain_create_xml_args args;
remote_domain_create_xml_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
args.xml_desc = (char *) xmlDesc;
args.flags = flags;
virDomainPtr dom;
remote_domain_lookup_by_id_args args;
remote_domain_lookup_by_id_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
args.id = id;
virDomainPtr dom;
remote_domain_lookup_by_uuid_args args;
remote_domain_lookup_by_uuid_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
virDomainPtr dom;
remote_domain_lookup_by_name_args args;
remote_domain_lookup_by_name_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
args.name = (char *) name;
remoteDomainSuspend (virDomainPtr domain)
{
remote_domain_suspend_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainResume (virDomainPtr domain)
{
remote_domain_resume_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainShutdown (virDomainPtr domain)
{
remote_domain_shutdown_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainReboot (virDomainPtr domain, unsigned int flags)
{
remote_domain_reboot_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.flags = flags;
remoteDomainDestroy (virDomainPtr domain)
{
remote_domain_destroy_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
{
remote_domain_get_os_type_args args;
remote_domain_get_os_type_ret ret;
- GET_PRIVATE (domain->conn, NULL);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
{
remote_domain_get_max_memory_args args;
remote_domain_get_max_memory_ret ret;
- GET_PRIVATE (domain->conn, 0);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainSetMaxMemory (virDomainPtr domain, unsigned long memory)
{
remote_domain_set_max_memory_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.memory = memory;
remoteDomainSetMemory (virDomainPtr domain, unsigned long memory)
{
remote_domain_set_memory_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.memory = memory;
{
remote_domain_get_info_args args;
remote_domain_get_info_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainSave (virDomainPtr domain, const char *to)
{
remote_domain_save_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.to = (char *) to;
remoteDomainRestore (virConnectPtr conn, const char *from)
{
remote_domain_restore_args args;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
args.from = (char *) from;
remoteDomainCoreDump (virDomainPtr domain, const char *to, int flags)
{
remote_domain_core_dump_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.to = (char *) to;
remoteDomainSetVcpus (virDomainPtr domain, unsigned int nvcpus)
{
remote_domain_set_vcpus_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.nvcpus = nvcpus;
int maplen)
{
remote_domain_pin_vcpu_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
if (maplen > REMOTE_CPUMAP_MAX) {
errorf (domain->conn, VIR_ERR_RPC,
int i;
remote_domain_get_vcpus_args args;
remote_domain_get_vcpus_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
if (maxinfo > REMOTE_VCPUINFO_MAX) {
errorf (domain->conn, VIR_ERR_RPC,
{
remote_domain_get_max_vcpus_args args;
remote_domain_get_max_vcpus_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
{
remote_domain_dump_xml_args args;
remote_domain_dump_xml_ret ret;
- GET_PRIVATE (domain->conn, NULL);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.flags = flags;
{
remote_domain_migrate_prepare_args args;
remote_domain_migrate_prepare_ret ret;
- GET_PRIVATE (dconn, -1);
+ struct private_data *priv = dconn->privateData;
args.uri_in = uri_in == NULL ? NULL : (char **) &uri_in;
args.flags = flags;
unsigned long resource)
{
remote_domain_migrate_perform_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.cookie.cookie_len = cookielen;
virDomainPtr ddom;
remote_domain_migrate_finish_args args;
remote_domain_migrate_finish_ret ret;
- GET_PRIVATE (dconn, NULL);
+ struct private_data *priv = dconn->privateData;
args.dname = (char *) dname;
args.cookie.cookie_len = cookielen;
{
remote_domain_migrate_prepare2_args args;
remote_domain_migrate_prepare2_ret ret;
- GET_PRIVATE (dconn, -1);
+ struct private_data *priv = dconn->privateData;
args.uri_in = uri_in == NULL ? NULL : (char **) &uri_in;
args.flags = flags;
virDomainPtr ddom;
remote_domain_migrate_finish2_args args;
remote_domain_migrate_finish2_ret ret;
- GET_PRIVATE (dconn, NULL);
+ struct private_data *priv = dconn->privateData;
args.dname = (char *) dname;
args.cookie.cookie_len = cookielen;
int i;
remote_list_defined_domains_args args;
remote_list_defined_domains_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
if (maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
errorf (conn, VIR_ERR_RPC,
remoteNumOfDefinedDomains (virConnectPtr conn)
{
remote_num_of_defined_domains_ret ret;
- GET_PRIVATE (conn, -1);
+ struct private_data *priv = conn->privateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_DOMAINS,
remoteDomainCreate (virDomainPtr domain)
{
remote_domain_create_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
virDomainPtr dom;
remote_domain_define_xml_args args;
remote_domain_define_xml_ret ret;
- GET_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->privateData;
args.xml = (char *) xml;
remoteDomainUndefine (virDomainPtr domain)
{
remote_domain_undefine_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainAttachDevice (virDomainPtr domain, const char *xml)
{
remote_domain_attach_device_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.xml = (char *) xml;
remoteDomainDetachDevice (virDomainPtr domain, const char *xml)
{
remote_domain_detach_device_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.xml = (char *) xml;
{
remote_domain_get_autostart_args args;
remote_domain_get_autostart_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remoteDomainSetAutostart (virDomainPtr domain, int autostart)
{
remote_domain_set_autostart_args args;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.autostart = autostart;
{
remote_domain_get_scheduler_type_args args;
remote_domain_get_scheduler_type_ret ret;
- GET_PRIVATE (domain->conn, NULL);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
remote_domain_get_scheduler_parameters_args args;
remote_domain_get_scheduler_parameters_ret ret;
int i;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.nparams = *nparams;
{
remote_domain_set_scheduler_parameters_args args;
int i, do_error;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
{
remote_domain_block_stats_args args;
remote_domain_block_stats_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.path = (char *) path;
{
remote_domain_interface_stats_args args;
remote_domain_interface_stats_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
make_nonnull_domain (&args.dom, domain);
args.path = (char *) path;
{
remote_domain_block_peek_args args;
remote_domain_block_peek_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
errorf (domain->conn, VIR_ERR_RPC,
{
remote_domain_memory_peek_args args;
remote_domain_memory_peek_ret ret;
- GET_PRIVATE (domain->conn, -1);
+ struct private_data *priv = domain->conn->privateData;
if (size > REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX) {
errorf (domain->conn, VIR_ERR_RPC,
rflags |= VIR_DRV_OPEN_REMOTE_RO;
rflags |= VIR_DRV_OPEN_REMOTE_UNIX;
- priv->magic = DEAD;
priv->sock = -1;
ret = doRemoteOpen(conn, priv, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->networkPrivateData = NULL;
VIR_FREE(priv);
} else {
- priv->magic = MAGIC;
priv->localUses = 1;
conn->networkPrivateData = priv;
}
remoteNetworkClose (virConnectPtr conn)
{
int ret = 0;
- GET_NETWORK_PRIVATE (conn, -1);
+ struct private_data *priv = conn->networkPrivateData;
+
if (priv->localUses) {
priv->localUses--;
if (!priv->localUses) {
remoteNumOfNetworks (virConnectPtr conn)
{
remote_num_of_networks_ret ret;
- GET_NETWORK_PRIVATE (conn, -1);
+ struct private_data *priv = conn->networkPrivateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_NETWORKS,
int i;
remote_list_networks_args args;
remote_list_networks_ret ret;
- GET_NETWORK_PRIVATE (conn, -1);
+ struct private_data *priv = conn->networkPrivateData;
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
errorf (conn, VIR_ERR_RPC,
remoteNumOfDefinedNetworks (virConnectPtr conn)
{
remote_num_of_defined_networks_ret ret;
- GET_NETWORK_PRIVATE (conn, -1);
+ struct private_data *priv = conn->networkPrivateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_NETWORKS,
int i;
remote_list_defined_networks_args args;
remote_list_defined_networks_ret ret;
- GET_NETWORK_PRIVATE (conn, -1);
+ struct private_data *priv = conn->networkPrivateData;
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
errorf (conn, VIR_ERR_RPC,
virNetworkPtr net;
remote_network_lookup_by_uuid_args args;
remote_network_lookup_by_uuid_ret ret;
- GET_NETWORK_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->networkPrivateData;
memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
virNetworkPtr net;
remote_network_lookup_by_name_args args;
remote_network_lookup_by_name_ret ret;
- GET_NETWORK_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->networkPrivateData;
args.name = (char *) name;
virNetworkPtr net;
remote_network_create_xml_args args;
remote_network_create_xml_ret ret;
- GET_NETWORK_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->networkPrivateData;
args.xml = (char *) xmlDesc;
virNetworkPtr net;
remote_network_define_xml_args args;
remote_network_define_xml_ret ret;
- GET_NETWORK_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->networkPrivateData;
args.xml = (char *) xml;
remoteNetworkUndefine (virNetworkPtr network)
{
remote_network_undefine_args args;
- GET_NETWORK_PRIVATE (network->conn, -1);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
remoteNetworkCreate (virNetworkPtr network)
{
remote_network_create_args args;
- GET_NETWORK_PRIVATE (network->conn, -1);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
remoteNetworkDestroy (virNetworkPtr network)
{
remote_network_destroy_args args;
- GET_NETWORK_PRIVATE (network->conn, -1);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
{
remote_network_dump_xml_args args;
remote_network_dump_xml_ret ret;
- GET_NETWORK_PRIVATE (network->conn, NULL);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
args.flags = flags;
{
remote_network_get_bridge_name_args args;
remote_network_get_bridge_name_ret ret;
- GET_NETWORK_PRIVATE (network->conn, NULL);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
{
remote_network_get_autostart_args args;
remote_network_get_autostart_ret ret;
- GET_NETWORK_PRIVATE (network->conn, -1);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
remoteNetworkSetAutostart (virNetworkPtr network, int autostart)
{
remote_network_set_autostart_args args;
- GET_NETWORK_PRIVATE (network->conn, -1);
+ struct private_data *priv = network->conn->networkPrivateData;
make_nonnull_network (&args.net, network);
args.autostart = autostart;
rflags |= VIR_DRV_OPEN_REMOTE_RO;
rflags |= VIR_DRV_OPEN_REMOTE_UNIX;
- priv->magic = DEAD;
priv->sock = -1;
ret = doRemoteOpen(conn, priv, auth, rflags);
if (ret != VIR_DRV_OPEN_SUCCESS) {
conn->storagePrivateData = NULL;
VIR_FREE(priv);
} else {
- priv->magic = MAGIC;
priv->localUses = 1;
conn->storagePrivateData = priv;
}
remoteStorageClose (virConnectPtr conn)
{
int ret = 0;
- GET_STORAGE_PRIVATE (conn, -1);
+ struct private_data *priv = conn->storagePrivateData;
+
if (priv->localUses) {
priv->localUses--;
if (!priv->localUses) {
remoteNumOfStoragePools (virConnectPtr conn)
{
remote_num_of_storage_pools_ret ret;
- GET_STORAGE_PRIVATE (conn, -1);
+ struct private_data *priv = conn->storagePrivateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
int i;
remote_list_storage_pools_args args;
remote_list_storage_pools_ret ret;
- GET_STORAGE_PRIVATE (conn, -1);
+ struct private_data *priv = conn->storagePrivateData;
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
remoteNumOfDefinedStoragePools (virConnectPtr conn)
{
remote_num_of_defined_storage_pools_ret ret;
- GET_STORAGE_PRIVATE (conn, -1);
+ struct private_data *priv = conn->storagePrivateData;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
int i;
remote_list_defined_storage_pools_args args;
remote_list_defined_storage_pools_ret ret;
- GET_STORAGE_PRIVATE (conn, -1);
+ struct private_data *priv = conn->storagePrivateData;
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
error (conn, VIR_ERR_RPC, _("too many storage pools requested"));
{
remote_find_storage_pool_sources_args args;
remote_find_storage_pool_sources_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
const char *emptyString = "";
char *retval;
virStoragePoolPtr pool;
remote_storage_pool_lookup_by_uuid_args args;
remote_storage_pool_lookup_by_uuid_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
virStoragePoolPtr pool;
remote_storage_pool_lookup_by_name_args args;
remote_storage_pool_lookup_by_name_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
args.name = (char *) name;
virStoragePoolPtr pool;
remote_storage_pool_lookup_by_volume_args args;
remote_storage_pool_lookup_by_volume_ret ret;
- GET_STORAGE_PRIVATE (vol->conn, NULL);
+ struct private_data *priv = vol->conn->storagePrivateData;
make_nonnull_storage_vol (&args.vol, vol);
virStoragePoolPtr pool;
remote_storage_pool_create_xml_args args;
remote_storage_pool_create_xml_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
args.xml = (char *) xmlDesc;
args.flags = flags;
virStoragePoolPtr pool;
remote_storage_pool_define_xml_args args;
remote_storage_pool_define_xml_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
args.xml = (char *) xml;
args.flags = flags;
remoteStoragePoolUndefine (virStoragePoolPtr pool)
{
remote_storage_pool_undefine_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
remoteStoragePoolCreate (virStoragePoolPtr pool, unsigned int flags)
{
remote_storage_pool_create_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.flags = flags;
unsigned int flags)
{
remote_storage_pool_build_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.flags = flags;
remoteStoragePoolDestroy (virStoragePoolPtr pool)
{
remote_storage_pool_destroy_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
unsigned int flags)
{
remote_storage_pool_delete_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.flags = flags;
unsigned int flags)
{
remote_storage_pool_refresh_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.flags = flags;
{
remote_storage_pool_get_info_args args;
remote_storage_pool_get_info_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
{
remote_storage_pool_dump_xml_args args;
remote_storage_pool_dump_xml_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, NULL);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.flags = flags;
{
remote_storage_pool_get_autostart_args args;
remote_storage_pool_get_autostart_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
remoteStoragePoolSetAutostart (virStoragePoolPtr pool, int autostart)
{
remote_storage_pool_set_autostart_args args;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.autostart = autostart;
{
remote_storage_pool_num_of_volumes_args args;
remote_storage_pool_num_of_volumes_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool(&args.pool, pool);
int i;
remote_storage_pool_list_volumes_args args;
remote_storage_pool_list_volumes_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, -1);
+ struct private_data *priv = pool->conn->storagePrivateData;
if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
error (pool->conn, VIR_ERR_RPC, _("too many storage volumes requested"));
virStorageVolPtr vol;
remote_storage_vol_lookup_by_name_args args;
remote_storage_vol_lookup_by_name_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, NULL);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool(&args.pool, pool);
args.name = (char *) name;
virStorageVolPtr vol;
remote_storage_vol_lookup_by_key_args args;
remote_storage_vol_lookup_by_key_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
args.key = (char *) key;
virStorageVolPtr vol;
remote_storage_vol_lookup_by_path_args args;
remote_storage_vol_lookup_by_path_ret ret;
- GET_STORAGE_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->storagePrivateData;
args.path = (char *) path;
virStorageVolPtr vol;
remote_storage_vol_create_xml_args args;
remote_storage_vol_create_xml_ret ret;
- GET_STORAGE_PRIVATE (pool->conn, NULL);
+ struct private_data *priv = pool->conn->storagePrivateData;
make_nonnull_storage_pool (&args.pool, pool);
args.xml = (char *) xmlDesc;
unsigned int flags)
{
remote_storage_vol_delete_args args;
- GET_STORAGE_PRIVATE (vol->conn, -1);
+ struct private_data *priv = vol->conn->storagePrivateData;
make_nonnull_storage_vol (&args.vol, vol);
args.flags = flags;
{
remote_storage_vol_get_info_args args;
remote_storage_vol_get_info_ret ret;
- GET_STORAGE_PRIVATE (vol->conn, -1);
+ struct private_data *priv = vol->conn->storagePrivateData;
make_nonnull_storage_vol (&args.vol, vol);
{
remote_storage_vol_dump_xml_args args;
remote_storage_vol_dump_xml_ret ret;
- GET_STORAGE_PRIVATE (vol->conn, NULL);
+ struct private_data *priv = vol->conn->storagePrivateData;
make_nonnull_storage_vol (&args.vol, vol);
args.flags = flags;
{
remote_storage_vol_get_path_args args;
remote_storage_vol_get_path_ret ret;
- GET_STORAGE_PRIVATE (vol->conn, NULL);
+ struct private_data *priv = vol->conn->storagePrivateData;
make_nonnull_storage_vol (&args.vol, vol);
static int remoteDevMonClose(virConnectPtr conn)
{
int ret = 0;
- GET_DEVMON_PRIVATE (conn, -1);
+ struct private_data *priv = conn->devMonPrivateData;
+
if (priv->localUses) {
priv->localUses--;
if (!priv->localUses) {
{
remote_node_num_of_devices_args args;
remote_node_num_of_devices_ret ret;
- GET_DEVMON_PRIVATE (conn, -1);
+ struct private_data *priv = conn->devMonPrivateData;
args.cap = cap ? (char **)&cap : NULL;
args.flags = flags;
int i;
remote_node_list_devices_args args;
remote_node_list_devices_ret ret;
- GET_DEVMON_PRIVATE (conn, -1);
+ struct private_data *priv = conn->devMonPrivateData;
if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
error (conn, VIR_ERR_RPC, _("too many device names requested"));
remote_node_device_lookup_by_name_args args;
remote_node_device_lookup_by_name_ret ret;
virNodeDevicePtr dev;
- GET_DEVMON_PRIVATE (conn, NULL);
+ struct private_data *priv = conn->devMonPrivateData;
args.name = (char *)name;
{
remote_node_device_dump_xml_args args;
remote_node_device_dump_xml_ret ret;
- GET_DEVMON_PRIVATE (dev->conn, NULL);
+ struct private_data *priv = dev->conn->devMonPrivateData;
args.name = dev->name;
args.flags = flags;
{
remote_node_device_get_parent_args args;
remote_node_device_get_parent_ret ret;
- GET_DEVMON_PRIVATE (dev->conn, NULL);
+ struct private_data *priv = dev->conn->devMonPrivateData;
args.name = dev->name;
{
remote_node_device_num_of_caps_args args;
remote_node_device_num_of_caps_ret ret;
- GET_DEVMON_PRIVATE (dev->conn, -1);
+ struct private_data *priv = dev->conn->devMonPrivateData;
args.name = dev->name;
int i;
remote_node_device_list_caps_args args;
remote_node_device_list_caps_ret ret;
- GET_DEVMON_PRIVATE (dev->conn, -1);
+ struct private_data *priv = dev->conn->devMonPrivateData;
if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) {
error (dev->conn, VIR_ERR_RPC, _("too many capability names requested"));