[libvirt] [PATCH 17/22] remote generator, client: Handle functions with wrapped return values
Matthias Bolte
matthias.bolte at googlemail.com
Sun Apr 24 09:14:04 UTC 2011
---
daemon/remote_generator.pl | 88 ++--
src/remote/remote_client_bodies.c | 987 +++++++++++++++++++++++++++++++++++--
src/remote/remote_driver.c | 996 -------------------------------------
3 files changed, 993 insertions(+), 1078 deletions(-)
diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl
index a973b21..5045b7f 100755
--- a/daemon/remote_generator.pl
+++ b/daemon/remote_generator.pl
@@ -753,82 +753,44 @@ elsif ($opt_k) {
"CPUBaseline",
"DomainBlockStats",
"DomainCreate",
- "DomainCreateXML",
- "DomainDefineXML",
"DomainDestroy",
"DomainGetAutostart",
"DomainGetBlockInfo",
"DomainGetInfo",
- "StoragePoolLookupByUUID",
- "NodeDeviceCreateXML",
"DomainGetJobInfo",
"DomainInterfaceStats",
- "DomainLookupByID",
- "DomainLookupByName",
- "DomainLookupByUIID",
"DomainMigrateFinish",
- "NWFilterDefineXML",
- "NWFilterLookupByName",
- "NWFilterLookupByUUID",
- "SecretLookupByUUID",
- "SecretLookupByUsage",
- "StoragePoolCreateXML",
- "DomainLookupByUUID",
+ "NWFilterDefineXML", # public API and XDR protocol mismatch
"DomainMigratePerform",
"DomainMigrateFinish2",
- "DomainSnapshotCreateXML",
- "DomainSnapshotCurrent",
"DomainSnapshotListNames",
"GetLibVersion",
- "GetMaxVcpus",
- "DomainSnapshotLookupByName",
- "DomainXMLFromNative",
"FindStoragePoolSources",
"GetVersion",
- "GetLibVersion",
- "InterfaceDefineXML",
- "InterfaceLookupByName",
"IsSecure",
"ListDefinedDomains",
"ListDefinedInterfaces",
"ListNWFilters",
- "NetworkCreateXML",
"SupportsFeature",
- "StorageVolLookupByPath",
"StorageVolGetInfo",
- "StorageVolCreateXML",
- "StorageVolLookupByName",
- "StorageVolLookupByKey",
"StoragePoolGetInfo",
- "StorageVolCreateXMLFrom",
- "StoragePoolLookupByName",
"NodeListDevices",
"NodeGetCellsFreeMemory",
"ListDefinedNetworks",
- "DomainXMLToNative",
"StoragePoolListVolumes",
- "SecretDefineXML",
"ListDomains",
"ListStoragePools",
"NetworkGetAutostart",
- "StoragePoolLookupByVolume",
"StoragePoolGetAutostart",
"SecretSetValue",
- "StoragePoolDefineXML",
"NodeGetInfo",
"GetURI",
- "InterfaceLookupByMACString",
"ListInterfaces",
- "NetworkDefineXML",
- "NetworkLookupByName",
"ListDefinedStoragePools",
"NodeDeviceDettach",
- "NodeDeviceLookupByName",
- "NodeGetFreeMemory",
"ListNetworks",
"NodeDeviceListCaps",
"NodeDeviceReset",
- "NetworkLookupByUUID",
"NodeDeviceReAttach",
"ListSecrets",
@@ -889,7 +851,9 @@ elsif ($opt_k) {
my $has_node_device = 0;
# node device is special
- if ($call->{args} =~ m/^remote_node_/) {
+ if ($call->{args} =~ m/^remote_node_/ and
+ !($call->{args} =~ m/^remote_node_device_lookup_by_name_/) and
+ !($call->{args} =~ m/^remote_node_device_create_xml_/)) {
$has_node_device = 1;
$priv_name = "devMonPrivateData";
}
@@ -901,13 +865,14 @@ elsif ($opt_k) {
push(@setters_list, "args.name = dev->name;");
} elsif ($args_member =~ m/^remote_nonnull_(domain|network|storage_pool|storage_vol|interface|secret|nwfilter|domain_snapshot) (\S+);/) {
my $name = $1;
+ my $arg_name = $2;
my $type_name = name_to_ProcName($name);
if ($is_first_arg) {
if ($name eq "domain_snapshot") {
- $priv_src = "$2->domain->conn";
+ $priv_src = "$arg_name->domain->conn";
} else {
- $priv_src = "$2->conn";
+ $priv_src = "$arg_name->conn";
}
if ($name =~ m/^storage_/) {
@@ -917,8 +882,11 @@ elsif ($opt_k) {
}
}
- push(@args_list, "vir${type_name}Ptr $2");
- push(@setters_list, "make_nonnull_$1(&args.$2, $2);");
+ push(@args_list, "vir${type_name}Ptr $arg_name");
+ push(@setters_list, "make_nonnull_$1(&args.$arg_name, $arg_name);");
+ } elsif ($args_member =~ m/^remote_uuid (\S+);/) {
+ push(@args_list, "const unsigned char *$1");
+ push(@setters_list, "memcpy(args.$1, $1, VIR_UUID_BUFLEN);");
} elsif ($args_member =~ m/^remote_string (\S+);/) {
push(@args_list, "const char *$1");
push(@setters_list, "args.$1 = $1 ? (char **)&$1 : NULL;");
@@ -988,14 +956,42 @@ elsif ($opt_k) {
push(@ret_list, "rv = ret.$1;");
$single_ret_var = "char *rv = NULL";
$single_ret_type = "char *";
+ } elsif ($ret_member =~ m/remote_nonnull_(domain|network|storage_pool|storage_vol|node_device|interface|secret|nwfilter|domain_snapshot) (\S+);/) {
+ my $name = $1;
+ my $arg_name = $2;
+ my $type_name = name_to_ProcName($name);
+
+ if ($name eq "node_device") {
+ $priv_name = "devMonPrivateData";
+ } elsif ($name =~ m/^storage_/) {
+ $priv_name = "storagePrivateData";
+ } elsif (!($name =~ m/^domain/)) {
+ $priv_name = "${name}PrivateData";
+ }
+
+ if ($name eq "domain_snapshot") {
+ push(@ret_list, "rv = get_nonnull_$name(dom, ret.$arg_name);");
+ } else {
+ push(@ret_list, "rv = get_nonnull_$name($priv_src, ret.$arg_name);");
+ }
+
+ push(@ret_list, "xdr_free((xdrproc_t)xdr_$call->{ret}, (char *)&ret);");
+ $single_ret_var = "vir${type_name}Ptr rv = NULL";
+ $single_ret_type = "vir${type_name}Ptr";
} elsif ($ret_member =~ m/^int (\S+);/) {
push(@ret_list, "rv = ret.$1;");
$single_ret_var = "int rv = -1";
$single_ret_type = "int";
} elsif ($ret_member =~ m/hyper (\S+);/) {
push(@ret_list, "rv = ret.$1;");
- $single_ret_var = "unsigned long rv = 0";
- $single_ret_type = "unsigned long";
+
+ if ($call->{ProcName} eq "NodeGetFreeMemory") {
+ $single_ret_var = "unsigned long long rv = 0";
+ $single_ret_type = "unsigned long long";
+ } else {
+ $single_ret_var = "unsigned long rv = 0";
+ $single_ret_type = "unsigned long";
+ }
} else {
die "unhandled type for return value: $ret_member";
}
diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c
index b878832..5471c1b 100644
--- a/src/remote/remote_client_bodies.c
+++ b/src/remote/remote_client_bodies.c
@@ -148,9 +148,60 @@ done:
/* remoteDispatchDomainCreateWithFlags has to be implemented manually */
-/* remoteDispatchDomainCreateXML has to be implemented manually */
+static virDomainPtr
+remoteDomainCreateXML(virConnectPtr conn, const char *xml_desc, unsigned int flags)
+{
+ virDomainPtr rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_create_xml_args args;
+ remote_domain_create_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml_desc = (char *)xml_desc;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_XML,
+ (xdrproc_t)xdr_remote_domain_create_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_create_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain(conn, ret.dom);
+ xdr_free((xdrproc_t)xdr_remote_domain_create_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virDomainPtr
+remoteDomainDefineXML(virConnectPtr conn, const char *xml)
+{
+ virDomainPtr rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_define_xml_args args;
+ remote_domain_define_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_DEFINE_XML,
+ (xdrproc_t)xdr_remote_domain_define_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_define_xml_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchDomainDefineXML has to be implemented manually */
+ rv = get_nonnull_domain(conn, ret.dom);
+ xdr_free((xdrproc_t)xdr_remote_domain_define_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainDestroy has to be implemented manually */
@@ -497,11 +548,86 @@ done:
return rv;
}
-/* remoteDispatchDomainLookupByID has to be implemented manually */
+static virDomainPtr
+remoteDomainLookupByID(virConnectPtr conn, int id)
+{
+ virDomainPtr rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_lookup_by_id_args args;
+ remote_domain_lookup_by_id_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.id = id;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_ID,
+ (xdrproc_t)xdr_remote_domain_lookup_by_id_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_lookup_by_id_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain(conn, ret.dom);
+ xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_id_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virDomainPtr
+remoteDomainLookupByName(virConnectPtr conn, const char *name)
+{
+ virDomainPtr rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_lookup_by_name_args args;
+ remote_domain_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *)name;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_domain_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain(conn, ret.dom);
+ xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virDomainPtr
+remoteDomainLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ virDomainPtr rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_lookup_by_uuid_args args;
+ remote_domain_lookup_by_uuid_ret ret;
+
+ remoteDriverLock(priv);
+
+ memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
+ (xdrproc_t)xdr_remote_domain_lookup_by_uuid_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_lookup_by_uuid_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchDomainLookupByName has to be implemented manually */
+ rv = get_nonnull_domain(conn, ret.dom);
+ xdr_free((xdrproc_t)xdr_remote_domain_lookup_by_uuid_ret, (char *)&ret);
-/* remoteDispatchDomainLookupByUUID has to be implemented manually */
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteDomainManagedSave(virDomainPtr dom, unsigned int flags)
@@ -914,9 +1040,62 @@ done:
return rv;
}
-/* remoteDispatchDomainSnapshotCreateXML has to be implemented manually */
+static virDomainSnapshotPtr
+remoteDomainSnapshotCreateXML(virDomainPtr dom, const char *xml_desc, unsigned int flags)
+{
+ virDomainSnapshotPtr rv = NULL;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_snapshot_create_xml_args args;
+ remote_domain_snapshot_create_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml_desc = (char *)xml_desc;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
+ (xdrproc_t)xdr_remote_domain_snapshot_create_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_snapshot_create_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain_snapshot(dom, ret.snap);
+ xdr_free((xdrproc_t)xdr_remote_domain_snapshot_create_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virDomainSnapshotPtr
+remoteDomainSnapshotCurrent(virDomainPtr dom, unsigned int flags)
+{
+ virDomainSnapshotPtr rv = NULL;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_snapshot_current_args args;
+ remote_domain_snapshot_current_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchDomainSnapshotCurrent has to be implemented manually */
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
+ (xdrproc_t)xdr_remote_domain_snapshot_current_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_snapshot_current_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain_snapshot(dom, ret.snap);
+ xdr_free((xdrproc_t)xdr_remote_domain_snapshot_current_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteDomainSnapshotDelete(virDomainSnapshotPtr snap, unsigned int flags)
@@ -971,7 +1150,34 @@ done:
/* remoteDispatchDomainSnapshotListNames has to be implemented manually */
-/* remoteDispatchDomainSnapshotLookupByName has to be implemented manually */
+static virDomainSnapshotPtr
+remoteDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags)
+{
+ virDomainSnapshotPtr rv = NULL;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_snapshot_lookup_by_name_args args;
+ remote_domain_snapshot_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.name = (char *)name;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_domain_snapshot(dom, ret.snap);
+ xdr_free((xdrproc_t)xdr_remote_domain_snapshot_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteDomainSnapshotNum(virDomainPtr dom, unsigned int flags)
@@ -1071,9 +1277,61 @@ done:
return rv;
}
-/* remoteDispatchDomainXMLFromNative has to be implemented manually */
+static char *
+remoteDomainXMLFromNative(virConnectPtr conn, const char *nativeFormat, const char *nativeConfig, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_xml_from_native_args args;
+ remote_domain_xml_from_native_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.nativeFormat = (char *)nativeFormat;
+ args.nativeConfig = (char *)nativeConfig;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_FROM_NATIVE,
+ (xdrproc_t)xdr_remote_domain_xml_from_native_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_xml_from_native_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.domainXml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static char *
+remoteDomainXMLToNative(virConnectPtr conn, const char *nativeFormat, const char *domainXml, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_domain_xml_to_native_args args;
+ remote_domain_xml_to_native_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.nativeFormat = (char *)nativeFormat;
+ args.domainXml = (char *)domainXml;
+ args.flags = flags;
-/* remoteDispatchDomainXMLToNative has to be implemented manually */
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_XML_TO_NATIVE,
+ (xdrproc_t)xdr_remote_domain_xml_to_native_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_xml_to_native_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.nativeConfig;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchFindStoragePoolSources has to be implemented manually */
@@ -1125,7 +1383,31 @@ done:
/* remoteDispatchGetLibVersion has to be implemented manually */
-/* remoteDispatchGetMaxVcpus has to be implemented manually */
+static int
+remoteGetMaxVcpus(virConnectPtr conn, const char *type)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_get_max_vcpus_args args;
+ remote_get_max_vcpus_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.type = type ? (char **)&type : NULL;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_GET_MAX_VCPUS,
+ (xdrproc_t)xdr_remote_get_max_vcpus_args, (char *)&args,
+ (xdrproc_t)xdr_remote_get_max_vcpus_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.max_vcpus;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static char *
remoteGetSysinfo(virConnectPtr conn, unsigned int flags)
@@ -1183,7 +1465,33 @@ done:
return rv;
}
-/* remoteDispatchInterfaceDefineXML has to be implemented manually */
+static virInterfacePtr
+remoteInterfaceDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+ virInterfacePtr rv = NULL;
+ struct private_data *priv = conn->interfacePrivateData;
+ remote_interface_define_xml_args args;
+ remote_interface_define_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
+ (xdrproc_t)xdr_remote_interface_define_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_interface_define_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_interface(conn, ret.iface);
+ xdr_free((xdrproc_t)xdr_remote_interface_define_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteInterfaceDestroy(virInterfacePtr iface, unsigned int flags)
@@ -1262,9 +1570,59 @@ done:
return rv;
}
-/* remoteDispatchInterfaceLookupByMACString has to be implemented manually */
+static virInterfacePtr
+remoteInterfaceLookupByMACString(virConnectPtr conn, const char *mac)
+{
+ virInterfacePtr rv = NULL;
+ struct private_data *priv = conn->interfacePrivateData;
+ remote_interface_lookup_by_mac_string_args args;
+ remote_interface_lookup_by_mac_string_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.mac = (char *)mac;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING,
+ (xdrproc_t)xdr_remote_interface_lookup_by_mac_string_args, (char *)&args,
+ (xdrproc_t)xdr_remote_interface_lookup_by_mac_string_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_interface(conn, ret.iface);
+ xdr_free((xdrproc_t)xdr_remote_interface_lookup_by_mac_string_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virInterfacePtr
+remoteInterfaceLookupByName(virConnectPtr conn, const char *name)
+{
+ virInterfacePtr rv = NULL;
+ struct private_data *priv = conn->interfacePrivateData;
+ remote_interface_lookup_by_name_args args;
+ remote_interface_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *)name;
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchInterfaceLookupByName has to be implemented manually */
+ if (call(conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_interface_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_interface_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_interface(conn, ret.iface);
+ xdr_free((xdrproc_t)xdr_remote_interface_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteInterfaceUndefine(virInterfacePtr iface)
@@ -1334,9 +1692,59 @@ done:
return rv;
}
-/* remoteDispatchNetworkCreateXML has to be implemented manually */
+static virNetworkPtr
+remoteNetworkCreateXML(virConnectPtr conn, const char *xml)
+{
+ virNetworkPtr rv = NULL;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_network_create_xml_args args;
+ remote_network_create_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NETWORK_CREATE_XML,
+ (xdrproc_t)xdr_remote_network_create_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_create_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_network(conn, ret.net);
+ xdr_free((xdrproc_t)xdr_remote_network_create_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virNetworkPtr
+remoteNetworkDefineXML(virConnectPtr conn, const char *xml)
+{
+ virNetworkPtr rv = NULL;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_network_define_xml_args args;
+ remote_network_define_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NETWORK_DEFINE_XML,
+ (xdrproc_t)xdr_remote_network_define_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_define_xml_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchNetworkDefineXML has to be implemented manually */
+ rv = get_nonnull_network(conn, ret.net);
+ xdr_free((xdrproc_t)xdr_remote_network_define_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteNetworkDestroy(virNetworkPtr net)
@@ -1468,9 +1876,59 @@ done:
return rv;
}
-/* remoteDispatchNetworkLookupByName has to be implemented manually */
+static virNetworkPtr
+remoteNetworkLookupByName(virConnectPtr conn, const char *name)
+{
+ virNetworkPtr rv = NULL;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_network_lookup_by_name_args args;
+ remote_network_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *)name;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_network_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_network(conn, ret.net);
+ xdr_free((xdrproc_t)xdr_remote_network_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virNetworkPtr
+remoteNetworkLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ virNetworkPtr rv = NULL;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_network_lookup_by_uuid_args args;
+ remote_network_lookup_by_uuid_ret ret;
+
+ remoteDriverLock(priv);
+
+ memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
-/* remoteDispatchNetworkLookupByUUID has to be implemented manually */
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_UUID,
+ (xdrproc_t)xdr_remote_network_lookup_by_uuid_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_lookup_by_uuid_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_network(conn, ret.net);
+ xdr_free((xdrproc_t)xdr_remote_network_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteNetworkSetAutostart(virNetworkPtr net, int autostart)
@@ -1519,7 +1977,33 @@ done:
return rv;
}
-/* remoteDispatchNodeDeviceCreateXML has to be implemented manually */
+static virNodeDevicePtr
+remoteNodeDeviceCreateXML(virConnectPtr conn, const char *xml_desc, unsigned int flags)
+{
+ virNodeDevicePtr rv = NULL;
+ struct private_data *priv = conn->devMonPrivateData;
+ remote_node_device_create_xml_args args;
+ remote_node_device_create_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml_desc = (char *)xml_desc;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_CREATE_XML,
+ (xdrproc_t)xdr_remote_node_device_create_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_node_device_create_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_node_device(conn, ret.dev);
+ xdr_free((xdrproc_t)xdr_remote_node_device_create_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteNodeDeviceDestroy(virNodeDevicePtr dev)
@@ -1577,7 +2061,32 @@ done:
/* remoteDispatchNodeDeviceListCaps has to be implemented manually */
-/* remoteDispatchNodeDeviceLookupByName has to be implemented manually */
+static virNodeDevicePtr
+remoteNodeDeviceLookupByName(virConnectPtr conn, const char *name)
+{
+ virNodeDevicePtr rv = NULL;
+ struct private_data *priv = conn->devMonPrivateData;
+ remote_node_device_lookup_by_name_args args;
+ remote_node_device_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *)name;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_node_device_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_node_device_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_node_device(conn, ret.dev);
+ xdr_free((xdrproc_t)xdr_remote_node_device_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteNodeDeviceNumOfCaps(virNodeDevicePtr dev)
@@ -1611,7 +2120,28 @@ done:
/* remoteDispatchNodeGetCellsFreeMemory has to be implemented manually */
-/* remoteDispatchNodeGetFreeMemory has to be implemented manually */
+static unsigned long long
+remoteNodeGetFreeMemory(virConnectPtr conn)
+{
+ unsigned long long rv = 0;
+ struct private_data *priv = conn->privateData;
+ remote_node_get_free_memory_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_node_get_free_memory_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.freeMem;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNodeGetInfo has to be implemented manually */
@@ -1905,9 +2435,59 @@ done:
return rv;
}
-/* remoteDispatchNWFilterLookupByName has to be implemented manually */
+static virNWFilterPtr
+remoteNWFilterLookupByName(virConnectPtr conn, const char *name)
+{
+ virNWFilterPtr rv = NULL;
+ struct private_data *priv = conn->nwfilterPrivateData;
+ remote_nwfilter_lookup_by_name_args args;
+ remote_nwfilter_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = (char *)name;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME,
+ (xdrproc_t)xdr_remote_nwfilter_lookup_by_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_nwfilter_lookup_by_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_nwfilter(conn, ret.nwfilter);
+ xdr_free((xdrproc_t)xdr_remote_nwfilter_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virNWFilterPtr
+remoteNWFilterLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ virNWFilterPtr rv = NULL;
+ struct private_data *priv = conn->nwfilterPrivateData;
+ remote_nwfilter_lookup_by_uuid_args args;
+ remote_nwfilter_lookup_by_uuid_ret ret;
+
+ remoteDriverLock(priv);
+
+ memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID,
+ (xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_args, (char *)&args,
+ (xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchNWFilterLookupByUUID has to be implemented manually */
+ rv = get_nonnull_nwfilter(conn, ret.nwfilter);
+ xdr_free((xdrproc_t)xdr_remote_nwfilter_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteNWFilterUndefine(virNWFilterPtr nwfilter)
@@ -1934,7 +2514,33 @@ done:
/* remoteDispatchOpen has to be implemented manually */
-/* remoteDispatchSecretDefineXML has to be implemented manually */
+static virSecretPtr
+remoteSecretDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+ virSecretPtr rv = NULL;
+ struct private_data *priv = conn->secretPrivateData;
+ remote_secret_define_xml_args args;
+ remote_secret_define_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_SECRET_DEFINE_XML,
+ (xdrproc_t)xdr_remote_secret_define_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_secret_define_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_secret(conn, ret.secret);
+ xdr_free((xdrproc_t)xdr_remote_secret_define_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchSecretGetValue has to be implemented manually */
@@ -1965,9 +2571,60 @@ done:
return rv;
}
-/* remoteDispatchSecretLookupByUsage has to be implemented manually */
+static virSecretPtr
+remoteSecretLookupByUsage(virConnectPtr conn, int usageType, const char *usageID)
+{
+ virSecretPtr rv = NULL;
+ struct private_data *priv = conn->secretPrivateData;
+ remote_secret_lookup_by_usage_args args;
+ remote_secret_lookup_by_usage_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.usageType = usageType;
+ args.usageID = (char *)usageID;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_USAGE,
+ (xdrproc_t)xdr_remote_secret_lookup_by_usage_args, (char *)&args,
+ (xdrproc_t)xdr_remote_secret_lookup_by_usage_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_secret(conn, ret.secret);
+ xdr_free((xdrproc_t)xdr_remote_secret_lookup_by_usage_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virSecretPtr
+remoteSecretLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ virSecretPtr rv = NULL;
+ struct private_data *priv = conn->secretPrivateData;
+ remote_secret_lookup_by_uuid_args args;
+ remote_secret_lookup_by_uuid_ret ret;
+
+ remoteDriverLock(priv);
+
+ memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_UUID,
+ (xdrproc_t)xdr_remote_secret_lookup_by_uuid_args, (char *)&args,
+ (xdrproc_t)xdr_remote_secret_lookup_by_uuid_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchSecretLookupByUUID has to be implemented manually */
+ rv = get_nonnull_secret(conn, ret.secret);
+ xdr_free((xdrproc_t)xdr_remote_secret_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchSecretSetValue has to be implemented manually */
@@ -2042,9 +2699,61 @@ done:
return rv;
}
-/* remoteDispatchStoragePoolCreateXML has to be implemented manually */
+static virStoragePoolPtr
+remoteStoragePoolCreateXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+ virStoragePoolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_pool_create_xml_args args;
+ remote_storage_pool_create_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_pool(conn, ret.pool);
+ xdr_free((xdrproc_t)xdr_remote_storage_pool_create_xml_ret, (char *)&ret);
-/* remoteDispatchStoragePoolDefineXML has to be implemented manually */
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolDefineXML(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+ virStoragePoolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_pool_define_xml_args args;
+ remote_storage_pool_define_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_pool(conn, ret.pool);
+ xdr_free((xdrproc_t)xdr_remote_storage_pool_define_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteStoragePoolDelete(virStoragePoolPtr pool, unsigned int flags)
@@ -2178,11 +2887,86 @@ done:
/* remoteDispatchStoragePoolListVolumes has to be implemented manually */
-/* remoteDispatchStoragePoolLookupByName has to be implemented manually */
+static virStoragePoolPtr
+remoteStoragePoolLookupByName(virConnectPtr conn, const char *name)
+{
+ virStoragePoolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_pool_lookup_by_name_args args;
+ remote_storage_pool_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_pool(conn, ret.pool);
+ xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolLookupByUUID(virConnectPtr conn, const unsigned char *uuid)
+{
+ virStoragePoolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_pool_lookup_by_uuid_args args;
+ remote_storage_pool_lookup_by_uuid_ret ret;
+
+ remoteDriverLock(priv);
+
+ memcpy(args.uuid, uuid, VIR_UUID_BUFLEN);
-/* remoteDispatchStoragePoolLookupByUUID has to be implemented manually */
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_pool(conn, ret.pool);
+ xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_uuid_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStoragePoolPtr
+remoteStoragePoolLookupByVolume(virStorageVolPtr vol)
+{
+ virStoragePoolPtr rv = NULL;
+ struct private_data *priv = vol->conn->storagePrivateData;
+ remote_storage_pool_lookup_by_volume_args args;
+ remote_storage_pool_lookup_by_volume_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_vol(&args.vol, vol);
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchStoragePoolLookupByVolume has to be implemented manually */
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_pool(vol->conn, ret.pool);
+ xdr_free((xdrproc_t)xdr_remote_storage_pool_lookup_by_volume_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteStoragePoolNumOfVolumes(virStoragePoolPtr pool)
@@ -2281,9 +3065,64 @@ done:
return rv;
}
-/* remoteDispatchStorageVolCreateXML has to be implemented manually */
+static virStorageVolPtr
+remoteStorageVolCreateXML(virStoragePoolPtr pool, const char *xml, unsigned int flags)
+{
+ virStorageVolPtr rv = NULL;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_vol_create_xml_args args;
+ remote_storage_vol_create_xml_ret ret;
+
+ remoteDriverLock(priv);
-/* remoteDispatchStorageVolCreateXMLFrom has to be implemented manually */
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.xml = (char *)xml;
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+ xdr_free((xdrproc_t)xdr_remote_storage_vol_create_xml_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolCreateXMLFrom(virStoragePoolPtr pool, const char *xml, virStorageVolPtr clonevol, unsigned int flags)
+{
+ virStorageVolPtr rv = NULL;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_vol_create_xml_from_args args;
+ remote_storage_vol_create_xml_from_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.xml = (char *)xml;
+ make_nonnull_storage_vol(&args.clonevol, clonevol);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM,
+ (xdrproc_t)xdr_remote_storage_vol_create_xml_from_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_vol_create_xml_from_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+ xdr_free((xdrproc_t)xdr_remote_storage_vol_create_xml_from_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
@@ -2366,11 +3205,87 @@ done:
return rv;
}
-/* remoteDispatchStorageVolLookupByKey has to be implemented manually */
+static virStorageVolPtr
+remoteStorageVolLookupByKey(virConnectPtr conn, const char *key)
+{
+ virStorageVolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_vol_lookup_by_key_args args;
+ remote_storage_vol_lookup_by_key_ret ret;
+
+ remoteDriverLock(priv);
-/* remoteDispatchStorageVolLookupByName has to be implemented manually */
+ args.key = (char *)key;
-/* remoteDispatchStorageVolLookupByPath has to be implemented manually */
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_vol(conn, ret.vol);
+ xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_key_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolLookupByName(virStoragePoolPtr pool, const char *name)
+{
+ virStorageVolPtr rv = NULL;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_vol_lookup_by_name_args args;
+ remote_storage_vol_lookup_by_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_vol(pool->conn, ret.vol);
+ xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_name_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static virStorageVolPtr
+remoteStorageVolLookupByPath(virConnectPtr conn, const char *path)
+{
+ virStorageVolPtr rv = NULL;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_storage_vol_lookup_by_path_args args;
+ remote_storage_vol_lookup_by_path_ret ret;
+
+ remoteDriverLock(priv);
+
+ 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)
+ goto done;
+
+ rv = get_nonnull_storage_vol(conn, ret.vol);
+ xdr_free((xdrproc_t)xdr_remote_storage_vol_lookup_by_path_ret, (char *)&ret);
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchStorageVolUpload has to be implemented manually */
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index a67f9f6..79ebfb3 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -1810,31 +1810,6 @@ done:
return rv;
}
-
-static int
-remoteGetMaxVcpus (virConnectPtr conn, const char *type)
-{
- int rv = -1;
- remote_get_max_vcpus_args args;
- remote_get_max_vcpus_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- args.type = type == NULL ? NULL : (char **) &type;
- if (call (conn, priv, 0, REMOTE_PROC_GET_MAX_VCPUS,
- (xdrproc_t) xdr_remote_get_max_vcpus_args, (char *) &args,
- (xdrproc_t) xdr_remote_get_max_vcpus_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.max_vcpus;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteNodeGetInfo (virConnectPtr conn, virNodeInfoPtr info)
{
@@ -1908,29 +1883,6 @@ done:
return rv;
}
-static unsigned long long
-remoteNodeGetFreeMemory (virConnectPtr conn)
-{
- unsigned long long rv = 0; /* 0 is error value this special function*/
- remote_node_get_free_memory_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_MEMORY,
- (xdrproc_t) xdr_void, NULL,
- (xdrproc_t) xdr_remote_node_get_free_memory_ret, (char *)&ret) == -1)
- goto done;
-
- rv = ret.freeMem;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static int
remoteListDomains (virConnectPtr conn, int *ids, int maxids)
{
@@ -1976,113 +1928,6 @@ done:
return rv;
}
-static virDomainPtr
-remoteDomainCreateXML (virConnectPtr conn,
- const char *xmlDesc,
- unsigned int flags)
-{
- virDomainPtr dom = NULL;
- remote_domain_create_xml_args args;
- remote_domain_create_xml_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.xml_desc = (char *) xmlDesc;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE_XML,
- (xdrproc_t) xdr_remote_domain_create_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_create_xml_ret, (char *) &ret) == -1)
- goto done;
-
- dom = get_nonnull_domain (conn, ret.dom);
- xdr_free ((xdrproc_t) &xdr_remote_domain_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByID (virConnectPtr conn, int id)
-{
- virDomainPtr dom = NULL;
- remote_domain_lookup_by_id_args args;
- remote_domain_lookup_by_id_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.id = id;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_ID,
- (xdrproc_t) xdr_remote_domain_lookup_by_id_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_lookup_by_id_ret, (char *) &ret) == -1)
- goto done;
-
- dom = get_nonnull_domain (conn, ret.dom);
- xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_id_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByUUID (virConnectPtr conn, const unsigned char *uuid)
-{
- virDomainPtr dom = NULL;
- remote_domain_lookup_by_uuid_args args;
- remote_domain_lookup_by_uuid_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
- (xdrproc_t) xdr_remote_domain_lookup_by_uuid_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret) == -1)
- goto done;
-
- dom = get_nonnull_domain (conn, ret.dom);
- xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dom;
-}
-
-static virDomainPtr
-remoteDomainLookupByName (virConnectPtr conn, const char *name)
-{
- virDomainPtr dom = NULL;
- remote_domain_lookup_by_name_args args;
- remote_domain_lookup_by_name_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.name = (char *) name;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_domain_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- dom = get_nonnull_domain (conn, ret.dom);
- xdr_free ((xdrproc_t) &xdr_remote_domain_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dom;
-}
-
static int
remoteDomainDestroy (virDomainPtr domain)
{
@@ -2666,68 +2511,6 @@ done:
return rv;
}
-static char *
-remoteDomainXMLFromNative (virConnectPtr conn,
- const char *format,
- const char *config,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_domain_xml_from_native_args args;
- remote_domain_xml_from_native_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.nativeFormat = (char *)format;
- args.nativeConfig = (char *)config;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_XML_FROM_NATIVE,
- (xdrproc_t) xdr_remote_domain_xml_from_native_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_xml_from_native_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.domainXml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static char *
-remoteDomainXMLToNative (virConnectPtr conn,
- const char *format,
- const char *xml,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_domain_xml_to_native_args args;
- remote_domain_xml_to_native_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.nativeFormat = (char *)format;
- args.domainXml = (char *)xml;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_XML_TO_NATIVE,
- (xdrproc_t) xdr_remote_domain_xml_to_native_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_xml_to_native_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.nativeConfig;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteDomainMigratePrepare (virConnectPtr dconn,
char **cookie, int *cookielen,
@@ -3062,32 +2845,6 @@ done:
return rv;
}
-static virDomainPtr
-remoteDomainDefineXML (virConnectPtr conn, const char *xml)
-{
- virDomainPtr dom = NULL;
- remote_domain_define_xml_args args;
- remote_domain_define_xml_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.xml = (char *) xml;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_DEFINE_XML,
- (xdrproc_t) xdr_remote_domain_define_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_define_xml_ret, (char *) &ret) == -1)
- goto done;
-
- dom = get_nonnull_domain (conn, ret.dom);
- xdr_free ((xdrproc_t) xdr_remote_domain_define_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dom;
-}
-
static int
remoteDomainGetAutostart (virDomainPtr domain, int *autostart)
{
@@ -3711,112 +3468,6 @@ done:
return rv;
}
-static virNetworkPtr
-remoteNetworkLookupByUUID (virConnectPtr conn,
- const unsigned char *uuid)
-{
- virNetworkPtr net = NULL;
- remote_network_lookup_by_uuid_args args;
- remote_network_lookup_by_uuid_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_UUID,
- (xdrproc_t) xdr_remote_network_lookup_by_uuid_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_lookup_by_uuid_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_network (conn, ret.net);
- xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_uuid_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
-static virNetworkPtr
-remoteNetworkLookupByName (virConnectPtr conn,
- const char *name)
-{
- virNetworkPtr net = NULL;
- remote_network_lookup_by_name_args args;
- remote_network_lookup_by_name_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = (char *) name;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NETWORK_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_network_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_network (conn, ret.net);
- xdr_free ((xdrproc_t) &xdr_remote_network_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
-static virNetworkPtr
-remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
-{
- virNetworkPtr net = NULL;
- remote_network_create_xml_args args;
- remote_network_create_xml_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- args.xml = (char *) xmlDesc;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NETWORK_CREATE_XML,
- (xdrproc_t) xdr_remote_network_create_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_create_xml_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_network (conn, ret.net);
- xdr_free ((xdrproc_t) &xdr_remote_network_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
-static virNetworkPtr
-remoteNetworkDefineXML (virConnectPtr conn, const char *xml)
-{
- virNetworkPtr net = NULL;
- remote_network_define_xml_args args;
- remote_network_define_xml_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- args.xml = (char *) xml;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NETWORK_DEFINE_XML,
- (xdrproc_t) xdr_remote_network_define_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_define_xml_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_network (conn, ret.net);
- xdr_free ((xdrproc_t) &xdr_remote_network_define_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
static int
remoteNetworkGetAutostart (virNetworkPtr network, int *autostart)
{
@@ -4024,89 +3675,6 @@ done:
return rv;
}
-static virInterfacePtr
-remoteInterfaceLookupByName (virConnectPtr conn,
- const char *name)
-{
- virInterfacePtr iface = NULL;
- remote_interface_lookup_by_name_args args;
- remote_interface_lookup_by_name_ret ret;
- struct private_data *priv = conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- args.name = (char *) name;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_interface_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_interface_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- iface = get_nonnull_interface (conn, ret.iface);
- xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return iface;
-}
-
-static virInterfacePtr
-remoteInterfaceLookupByMACString (virConnectPtr conn,
- const char *mac)
-{
- virInterfacePtr iface = NULL;
- remote_interface_lookup_by_mac_string_args args;
- remote_interface_lookup_by_mac_string_ret ret;
- struct private_data *priv = conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- args.mac = (char *) mac;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_LOOKUP_BY_MAC_STRING,
- (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_args, (char *) &args,
- (xdrproc_t) xdr_remote_interface_lookup_by_mac_string_ret, (char *) &ret) == -1)
- goto done;
-
- iface = get_nonnull_interface (conn, ret.iface);
- xdr_free ((xdrproc_t) &xdr_remote_interface_lookup_by_mac_string_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return iface;
-}
-
-static virInterfacePtr
-remoteInterfaceDefineXML (virConnectPtr conn,
- const char *xmlDesc,
- unsigned int flags)
-{
- virInterfacePtr iface = NULL;
- remote_interface_define_xml_args args;
- remote_interface_define_xml_ret ret;
- struct private_data *priv = conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- args.xml = (char *) xmlDesc;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_INTERFACE_DEFINE_XML,
- (xdrproc_t) xdr_remote_interface_define_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_interface_define_xml_ret, (char *) &ret) == -1)
- goto done;
-
- iface = get_nonnull_interface (conn, ret.iface);
- xdr_free ((xdrproc_t) &xdr_remote_interface_define_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return iface;
-}
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -4332,140 +3900,6 @@ done:
return rv;
}
-static virStoragePoolPtr
-remoteStoragePoolLookupByUUID (virConnectPtr conn,
- const unsigned char *uuid)
-{
- virStoragePoolPtr pool = NULL;
- remote_storage_pool_lookup_by_uuid_args args;
- remote_storage_pool_lookup_by_uuid_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- pool = get_nonnull_storage_pool (conn, ret.pool);
- xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_uuid_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolLookupByName (virConnectPtr conn,
- const char *name)
-{
- virStoragePoolPtr pool = NULL;
- remote_storage_pool_lookup_by_name_args args;
- remote_storage_pool_lookup_by_name_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- pool = get_nonnull_storage_pool (conn, ret.pool);
- xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolLookupByVolume (virStorageVolPtr vol)
-{
- virStoragePoolPtr pool = NULL;
- remote_storage_pool_lookup_by_volume_args args;
- remote_storage_pool_lookup_by_volume_ret ret;
- struct private_data *priv = vol->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- pool = get_nonnull_storage_pool (vol->conn, ret.pool);
- xdr_free ((xdrproc_t) &xdr_remote_storage_pool_lookup_by_volume_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
-{
- virStoragePoolPtr pool = NULL;
- remote_storage_pool_create_xml_args args;
- remote_storage_pool_create_xml_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- pool = get_nonnull_storage_pool (conn, ret.pool);
- xdr_free ((xdrproc_t) &xdr_remote_storage_pool_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return pool;
-}
-
-static virStoragePoolPtr
-remoteStoragePoolDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
-{
- virStoragePoolPtr pool = NULL;
- remote_storage_pool_define_xml_args args;
- remote_storage_pool_define_xml_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- pool = get_nonnull_storage_pool (conn, ret.pool);
- xdr_free ((xdrproc_t) &xdr_remote_storage_pool_define_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return pool;
-}
-
static int
remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
{
@@ -4580,151 +4014,6 @@ done:
return rv;
}
-
-
-static virStorageVolPtr
-remoteStorageVolLookupByName (virStoragePoolPtr pool,
- const char *name)
-{
- virStorageVolPtr vol = NULL;
- remote_storage_vol_lookup_by_name_args args;
- remote_storage_vol_lookup_by_name_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- vol = get_nonnull_storage_vol (pool->conn, ret.vol);
- xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolLookupByKey (virConnectPtr conn,
- const char *key)
-{
- virStorageVolPtr vol = NULL;
- remote_storage_vol_lookup_by_key_args args;
- remote_storage_vol_lookup_by_key_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- vol = get_nonnull_storage_vol (conn, ret.vol);
- xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_key_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolLookupByPath (virConnectPtr conn,
- const char *path)
-{
- virStorageVolPtr vol = NULL;
- remote_storage_vol_lookup_by_path_args args;
- remote_storage_vol_lookup_by_path_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- vol = get_nonnull_storage_vol (conn, ret.vol);
- xdr_free ((xdrproc_t) &xdr_remote_storage_vol_lookup_by_path_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolCreateXML (virStoragePoolPtr pool, const char *xmlDesc,
- unsigned int flags)
-{
- virStorageVolPtr vol = NULL;
- remote_storage_vol_create_xml_args args;
- remote_storage_vol_create_xml_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- 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)
- goto done;
-
- vol = get_nonnull_storage_vol (pool->conn, ret.vol);
- xdr_free ((xdrproc_t) &xdr_remote_storage_vol_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return vol;
-}
-
-static virStorageVolPtr
-remoteStorageVolCreateXMLFrom (virStoragePoolPtr pool,
- const char *xmlDesc,
- virStorageVolPtr clonevol,
- unsigned int flags)
-{
- virStorageVolPtr newvol = NULL;
- remote_storage_vol_create_xml_from_args args;
- remote_storage_vol_create_xml_from_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- make_nonnull_storage_vol (&args.clonevol, clonevol);
- args.xml = (char *) xmlDesc;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_CREATE_XML_FROM,
- (xdrproc_t) xdr_remote_storage_vol_create_xml_from_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_vol_create_xml_from_ret, (char *) &ret) == -1)
- goto done;
-
- newvol = get_nonnull_storage_vol (pool->conn, ret.vol);
- xdr_free ((xdrproc_t) &xdr_remote_storage_vol_create_xml_from_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return newvol;
-}
-
static int
remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
{
@@ -4881,34 +4170,6 @@ done:
return rv;
}
-
-static virNodeDevicePtr remoteNodeDeviceLookupByName(virConnectPtr conn,
- const char *name)
-{
- remote_node_device_lookup_by_name_args args;
- remote_node_device_lookup_by_name_ret ret;
- virNodeDevicePtr dev = NULL;
- struct private_data *priv = conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = (char *)name;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_node_device_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_node_device_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- dev = get_nonnull_node_device(conn, ret.dev);
-
- xdr_free ((xdrproc_t) xdr_remote_node_device_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dev;
-}
-
static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev)
{
char *rv = NULL;
@@ -5067,36 +4328,6 @@ done:
return rv;
}
-
-static virNodeDevicePtr
-remoteNodeDeviceCreateXML(virConnectPtr conn,
- const char *xmlDesc,
- unsigned int flags)
-{
- remote_node_device_create_xml_args args;
- remote_node_device_create_xml_ret ret;
- virNodeDevicePtr dev = NULL;
- struct private_data *priv = conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- memset(&ret, 0, sizeof ret);
- args.xml_desc = (char *)xmlDesc;
- args.flags = flags;
-
- if (call(conn, priv, 0, REMOTE_PROC_NODE_DEVICE_CREATE_XML,
- (xdrproc_t) xdr_remote_node_device_create_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_node_device_create_xml_ret, (char *) &ret) == -1)
- goto done;
-
- dev = get_nonnull_node_device(conn, ret.dev);
- xdr_free ((xdrproc_t) xdr_remote_node_device_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return dev;
-}
-
/* ------------------------------------------------------------- */
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5245,62 +4476,6 @@ done:
return rv;
}
-
-
-static virNWFilterPtr
-remoteNWFilterLookupByUUID (virConnectPtr conn,
- const unsigned char *uuid)
-{
- virNWFilterPtr net = NULL;
- remote_nwfilter_lookup_by_uuid_args args;
- remote_nwfilter_lookup_by_uuid_ret ret;
- struct private_data *priv = conn->nwfilterPrivateData;
-
- remoteDriverLock(priv);
-
- memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_UUID,
- (xdrproc_t) xdr_remote_nwfilter_lookup_by_uuid_args, (char *) &args,
- (xdrproc_t) xdr_remote_nwfilter_lookup_by_uuid_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_nwfilter (conn, ret.nwfilter);
- xdr_free ((xdrproc_t) &xdr_remote_nwfilter_lookup_by_uuid_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
-static virNWFilterPtr
-remoteNWFilterLookupByName (virConnectPtr conn,
- const char *name)
-{
- virNWFilterPtr net = NULL;
- remote_nwfilter_lookup_by_name_args args;
- remote_nwfilter_lookup_by_name_ret ret;
- struct private_data *priv = conn->nwfilterPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = (char *) name;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NWFILTER_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_nwfilter_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_nwfilter_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- net = get_nonnull_nwfilter (conn, ret.nwfilter);
- xdr_free ((xdrproc_t) &xdr_remote_nwfilter_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return net;
-}
-
/*----------------------------------------------------------------------*/
static int
@@ -6418,89 +5593,6 @@ done:
return rv;
}
-static virSecretPtr
-remoteSecretLookupByUUID (virConnectPtr conn, const unsigned char *uuid)
-{
- virSecretPtr rv = NULL;
- remote_secret_lookup_by_uuid_args args;
- remote_secret_lookup_by_uuid_ret ret;
- struct private_data *priv = conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- memcpy (args.uuid, uuid, VIR_UUID_BUFLEN);
-
- memset (&ret, 0, sizeof (ret));
- if (call (conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_UUID,
- (xdrproc_t) xdr_remote_secret_lookup_by_uuid_args, (char *) &args,
- (xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret, (char *) &ret) == -1)
- goto done;
-
- rv = get_nonnull_secret (conn, ret.secret);
- xdr_free ((xdrproc_t) xdr_remote_secret_lookup_by_uuid_ret,
- (char *) &ret);
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
-static virSecretPtr
-remoteSecretLookupByUsage (virConnectPtr conn, int usageType, const char *usageID)
-{
- virSecretPtr rv = NULL;
- remote_secret_lookup_by_usage_args args;
- remote_secret_lookup_by_usage_ret ret;
- struct private_data *priv = conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- args.usageType = usageType;
- args.usageID = (char *)usageID;
-
- memset (&ret, 0, sizeof (ret));
- if (call (conn, priv, 0, REMOTE_PROC_SECRET_LOOKUP_BY_USAGE,
- (xdrproc_t) xdr_remote_secret_lookup_by_usage_args, (char *) &args,
- (xdrproc_t) xdr_remote_secret_lookup_by_usage_ret, (char *) &ret) == -1)
- goto done;
-
- rv = get_nonnull_secret (conn, ret.secret);
- xdr_free ((xdrproc_t) xdr_remote_secret_lookup_by_usage_ret,
- (char *) &ret);
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
-static virSecretPtr
-remoteSecretDefineXML (virConnectPtr conn, const char *xml, unsigned int flags)
-{
- virSecretPtr rv = NULL;
- remote_secret_define_xml_args args;
- remote_secret_define_xml_ret ret;
- struct private_data *priv = conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- args.xml = (char *) xml;
- args.flags = flags;
-
- memset (&ret, 0, sizeof (ret));
- if (call (conn, priv, 0, REMOTE_PROC_SECRET_DEFINE_XML,
- (xdrproc_t) xdr_remote_secret_define_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_secret_define_xml_ret, (char *) &ret) == -1)
- goto done;
-
- rv = get_nonnull_secret (conn, ret.secret);
- xdr_free ((xdrproc_t) xdr_remote_secret_define_xml_ret,
- (char *) &ret);
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
static int
remoteSecretSetValue (virSecretPtr secret, const unsigned char *value,
size_t value_size, unsigned int flags)
@@ -7173,36 +6265,6 @@ done:
return rv;
}
-static virDomainSnapshotPtr
-remoteDomainSnapshotCreateXML(virDomainPtr domain,
- const char *xmlDesc,
- unsigned int flags)
-{
- virDomainSnapshotPtr snapshot = NULL;
- remote_domain_snapshot_create_xml_args args;
- remote_domain_snapshot_create_xml_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml_desc = (char *) xmlDesc;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CREATE_XML,
- (xdrproc_t) xdr_remote_domain_snapshot_create_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret) == -1)
- goto done;
-
- snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
- xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_create_xml_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return snapshot;
-}
-
static int
remoteDomainSnapshotListNames (virDomainPtr domain, char **const names,
int maxnames, unsigned int flags)
@@ -7266,64 +6328,6 @@ done:
return rv;
}
-
-static virDomainSnapshotPtr
-remoteDomainSnapshotLookupByName (virDomainPtr domain, const char *name,
- unsigned int flags)
-{
- virDomainSnapshotPtr snapshot = NULL;
- remote_domain_snapshot_lookup_by_name_args args;
- remote_domain_snapshot_lookup_by_name_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain(&args.dom, domain);
- args.name = (char *) name;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LOOKUP_BY_NAME,
- (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret) == -1)
- goto done;
-
- snapshot = get_nonnull_domain_snapshot (domain, ret.snap);
- xdr_free ((xdrproc_t) &xdr_remote_domain_snapshot_lookup_by_name_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return snapshot;
-}
-
-static virDomainSnapshotPtr
-remoteDomainSnapshotCurrent(virDomainPtr domain,
- unsigned int flags)
-{
- virDomainSnapshotPtr snapshot = NULL;
- remote_domain_snapshot_current_args args;
- remote_domain_snapshot_current_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain(&args.dom, domain);
- args.flags = flags;
-
- memset(&ret, 0, sizeof ret);
- if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_CURRENT,
- (xdrproc_t) xdr_remote_domain_snapshot_current_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_snapshot_current_ret, (char *) &ret) == -1)
- goto done;
-
- snapshot = get_nonnull_domain_snapshot(domain, ret.snap);
- xdr_free((xdrproc_t) &xdr_remote_domain_snapshot_current_ret, (char *) &ret);
-
-done:
- remoteDriverUnlock(priv);
- return snapshot;
-}
-
static int remoteDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr dom,
int eventID,
--
1.7.0.4
More information about the libvir-list
mailing list