---
daemon/remote_generator.pl | 122 +++--
src/remote/remote_client_bodies.c | 1097 +++++++++++++++++++++++++++++++++++--
src/remote/remote_driver.c | 1081 +------------------------------------
3 files changed, 1120 insertions(+), 1180 deletions(-)
diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl
index 73d1596..a973b21 100755
--- a/daemon/remote_generator.pl
+++ b/daemon/remote_generator.pl
@@ -751,63 +751,42 @@ elsif ($opt_k) {
"AuthPolkit",
"CPUBaseline",
- "CPUCompare",
"DomainBlockStats",
"DomainCreate",
"DomainCreateXML",
"DomainDefineXML",
"DomainDestroy",
- "DomainDumpXML",
"DomainGetAutostart",
"DomainGetBlockInfo",
"DomainGetInfo",
"StoragePoolLookupByUUID",
- "StoragePoolNumOfVolumes",
"NodeDeviceCreateXML",
"DomainGetJobInfo",
- "DomainGetMaxMemory",
- "DomainGetOSType",
- "DomainGetVcpusFlags",
- "HasCurrentSnapshot",
"DomainInterfaceStats",
- "DomainIsActive",
- "DomainIsPersistent",
- "DomainIsUpdated",
"DomainLookupByID",
"DomainLookupByName",
"DomainLookupByUIID",
"DomainMigrateFinish",
- "DomainGetMaxVcpus",
- "DomainHasCurrentSnapshot",
"NWFilterDefineXML",
- "NumOfStoragePools",
"NWFilterLookupByName",
"NWFilterLookupByUUID",
"SecretLookupByUUID",
"SecretLookupByUsage",
"StoragePoolCreateXML",
- "StoragePoolIsActive",
- "DomainHasManagedSaveImage",
"DomainLookupByUUID",
"DomainMigratePerform",
"DomainMigrateFinish2",
"DomainSnapshotCreateXML",
- "DomainSnapshotDumpXML",
- "DomainSnapshotNum",
"DomainSnapshotCurrent",
"DomainSnapshotListNames",
- "GetCapabilities",
- "GetHostname",
"GetLibVersion",
"GetMaxVcpus",
"DomainSnapshotLookupByName",
"DomainXMLFromNative",
"FindStoragePoolSources",
- "GetSysinfo",
"GetVersion",
"GetLibVersion",
"InterfaceDefineXML",
- "InterfaceGetXMLDesc",
"InterfaceLookupByName",
"IsSecure",
"ListDefinedDomains",
@@ -820,40 +799,22 @@ elsif ($opt_k) {
"StorageVolCreateXML",
"StorageVolLookupByName",
"StorageVolLookupByKey",
- "StoragePoolIsPersistent",
"StoragePoolGetInfo",
- "StorageVolGetPath",
"StorageVolCreateXMLFrom",
"StoragePoolLookupByName",
- "SecretGetXMLDesc",
- "NWFilterGetXMLDesc",
- "NumOfNWFilters",
- "NumOfInterfaces",
- "NumOfDomains",
- "NumOfDefinedStoragePools",
"NodeListDevices",
"NodeGetCellsFreeMemory",
- "NodeDeviceDumpXML",
- "NetworkIsActive",
"ListDefinedNetworks",
"DomainXMLToNative",
- "StorageVolDumpXML",
"StoragePoolListVolumes",
- "StoragePoolDumpXML",
"SecretDefineXML",
- "NumOfDefinedNetworks",
- "InterfaceIsActive",
"ListDomains",
"ListStoragePools",
- "NetworkDumpXML",
"NetworkGetAutostart",
- "NetworkGetBridgeName",
"StoragePoolLookupByVolume",
"StoragePoolGetAutostart",
"SecretSetValue",
- "NumOfDefinedInterfaces",
"StoragePoolDefineXML",
- "NodeNumOfDevices",
"NodeGetInfo",
"GetURI",
"InterfaceLookupByMACString",
@@ -861,18 +822,13 @@ elsif ($opt_k) {
"NetworkDefineXML",
"NetworkLookupByName",
"ListDefinedStoragePools",
- "NetworkIsPersistent",
"NodeDeviceDettach",
"NodeDeviceLookupByName",
"NodeGetFreeMemory",
- "NumOfDefinedDomains",
"ListNetworks",
"NodeDeviceListCaps",
"NodeDeviceReset",
- "NumOfNetworks",
"NetworkLookupByUUID",
- "NodeDeviceNumOfCaps",
- "NumOfSecrets",
"NodeDeviceReAttach",
"ListSecrets",
@@ -916,13 +872,16 @@ elsif ($opt_k) {
my @args_list = ();
my @vars_list = ();
my @setters_list = ();
+ my @ret_list = ();
my $priv_src = "conn";
my $priv_name = "privateData";
- my $args = "&args";
- my $ret = "&ret";
+ my $call_args = "&args";
+ my $call_ret = "&ret";
+ my $single_ret_var = "int rv = -1";
+ my $single_ret_type = "int";
if ($call->{args} eq "void") {
- $args = "NULL";
+ $call_args = "NULL";
} else {
push(@vars_list, "$call->{args} args");
@@ -930,14 +889,14 @@ elsif ($opt_k) {
my $has_node_device = 0;
# node device is special
- if ($call->{args} =~ m/^remote_node_device_/) {
+ if ($call->{args} =~ m/^remote_node_/) {
$has_node_device = 1;
+ $priv_name = "devMonPrivateData";
}
foreach my $args_member (@{$call->{args_members}}) {
if ($args_member =~ m/^remote_nonnull_string name;/ and $has_node_device) {
$priv_src = "dev->conn";
- $priv_name = "devMonPrivateData";
push(@args_list, "virNodeDevicePtr dev");
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+);/) {
@@ -960,6 +919,9 @@ elsif ($opt_k) {
push(@args_list, "vir${type_name}Ptr $2");
push(@setters_list, "make_nonnull_$1(&args.$2, $2);");
+ } elsif ($args_member =~ m/^remote_string (\S+);/) {
+ push(@args_list, "const char *$1");
+ push(@setters_list, "args.$1 = $1 ? (char **)&$1 : NULL;");
} elsif ($args_member =~ m/^remote_nonnull_string (\S+);/) {
push(@args_list, "const char *$1");
push(@setters_list, "args.$1 = (char *)$1;");
@@ -976,7 +938,9 @@ elsif ($opt_k) {
if ($type_name eq "int") {
# fix bad decisions in the xdr protocol
if ($arg_name eq "flags" and
- $call->{ProcName} ne "DomainCoreDump") {
+ $call->{ProcName} ne "DomainCoreDump" and
+ $call->{ProcName} ne "DomainDumpXML" and
+ $call->{ProcName} ne "NetworkDumpXML") {
$type_name = "unsigned int";
} elsif ($arg_name eq "nvcpus" and
$call->{ProcName} eq "DomainSetVcpus") {
@@ -1005,21 +969,52 @@ elsif ($opt_k) {
}
}
+ # fix priv_name for the NumOf* functions
+ if ($priv_name eq "privateData" and
+ !($call->{ProcName} =~ m/Domains/) and
+ $call->{ProcName} =~ m/NumOf(Defined|Domain)*(\S+)s/) {
+ my $prefix = lc $2;
+ $prefix =~ s/(pool|vol)$//;
+ $priv_name = "${prefix}PrivateData";
+ }
+
if ($call->{ret} eq "void") {
- $ret = "NULL";
+ $call_ret = "NULL";
} else {
push(@vars_list, "$call->{ret} ret");
+
+ foreach my $ret_member (@{$call->{ret_members}}) {
+ if ($ret_member =~ m/remote_nonnull_string (\S+);/) {
+ push(@ret_list, "rv = ret.$1;");
+ $single_ret_var = "char *rv = NULL";
+ $single_ret_type = "char *";
+ } 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";
+ } else {
+ die "unhandled type for return value: $ret_member";
+ }
+ }
+ }
+
+ if (! @args_list) {
+ push(@args_list, "virConnectPtr conn");
}
# print function
- print "static int\n";
+ print "static $single_ret_type\n";
print "remote$call->{ProcName}(";
print join(", ", @args_list);
print ")\n";
print "{\n";
- print " int rv = -1;\n";
+ print " $single_ret_var;\n";
print " struct private_data *priv = $priv_src->$priv_name;\n";
foreach my $var (@vars_list) {
@@ -1028,9 +1023,9 @@ elsif ($opt_k) {
print "\n";
print " remoteDriverLock(priv);\n";
- print "\n";
if (@setters_list) {
+ print "\n";
print " ";
}
@@ -1040,13 +1035,26 @@ elsif ($opt_k) {
print "\n";
}
+ if ($call->{ret} ne "void") {
+ print "\n";
+ print " memset(&ret, 0, sizeof ret);\n";
+ }
+
print "\n";
print " if (call($priv_src, priv, 0, ${procprefix}_PROC_$call->{UC_NAME},\n";
- print " (xdrproc_t)xdr_$call->{args}, (char *)$args,\n";
- print " (xdrproc_t)xdr_$call->{ret}, (char *)$ret) == -1)\n";
+ print " (xdrproc_t)xdr_$call->{args}, (char *)$call_args,\n";
+ print " (xdrproc_t)xdr_$call->{ret}, (char *)$call_ret) == -1)\n";
print " goto done;\n";
print "\n";
- print " rv = 0;\n";
+
+ if (@ret_list) {
+ print " ";
+ print join("\n ", @ret_list);
+ print "\n";
+ } else {
+ print " rv = 0;\n";
+ }
+
print "\n";
print "done:\n";
print " remoteDriverUnlock(priv);\n";
diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c
index 07ddfbf..b878832 100644
--- a/src/remote/remote_client_bodies.c
+++ b/src/remote/remote_client_bodies.c
@@ -16,7 +16,32 @@
/* remoteDispatchCPUBaseline has to be implemented manually */
-/* remoteDispatchCPUCompare has to be implemented manually */
+static int
+remoteCPUCompare(virConnectPtr conn, const char *xml, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_cpu_compare_args args;
+ remote_cpu_compare_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_CPU_COMPARE,
+ (xdrproc_t)xdr_remote_cpu_compare_args, (char *)&args,
+ (xdrproc_t)xdr_remote_cpu_compare_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.result;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteDomainAbortJob(virDomainPtr dom)
@@ -178,7 +203,32 @@ done:
return rv;
}
-/* remoteDispatchDomainDumpXML has to be implemented manually */
+static char *
+remoteDomainDumpXML(virDomainPtr dom, int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_dump_xml_args args;
+ remote_domain_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_DUMP_XML,
+ (xdrproc_t)xdr_remote_domain_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainEventsDeregister has to be implemented manually */
@@ -198,13 +248,85 @@ done:
/* remoteDispatchDomainGetJobInfo has to be implemented manually */
-/* remoteDispatchDomainGetMaxMemory has to be implemented manually */
+static unsigned long
+remoteDomainGetMaxMemory(virDomainPtr dom)
+{
+ unsigned long rv = 0;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_get_max_memory_args args;
+ remote_domain_get_max_memory_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_MEMORY,
+ (xdrproc_t)xdr_remote_domain_get_max_memory_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_get_max_memory_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchDomainGetMaxVcpus has to be implemented manually */
+ rv = ret.memory;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainGetMaxVcpus(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_get_max_vcpus_args args;
+ remote_domain_get_max_vcpus_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_VCPUS,
+ (xdrproc_t)xdr_remote_domain_get_max_vcpus_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_get_max_vcpus_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainGetMemoryParameters has to be implemented manually */
-/* remoteDispatchDomainGetOSType has to be implemented manually */
+static char *
+remoteDomainGetOSType(virDomainPtr dom)
+{
+ char *rv = NULL;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_get_os_type_args args;
+ remote_domain_get_os_type_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_OS_TYPE,
+ (xdrproc_t)xdr_remote_domain_get_os_type_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_get_os_type_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.type;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainGetSchedulerParameters has to be implemented manually */
@@ -214,19 +336,166 @@ done:
/* remoteDispatchDomainGetVcpus has to be implemented manually */
-/* remoteDispatchDomainGetVcpusFlags has to be implemented manually */
+static int
+remoteDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_get_vcpus_flags_args args;
+ remote_domain_get_vcpus_flags_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_VCPUS_FLAGS,
+ (xdrproc_t)xdr_remote_domain_get_vcpus_flags_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_get_vcpus_flags_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainHasCurrentSnapshot(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_has_current_snapshot_args args;
+ remote_domain_has_current_snapshot_ret ret;
-/* remoteDispatchDomainHasCurrentSnapshot has to be implemented manually */
+ remoteDriverLock(priv);
-/* remoteDispatchDomainHasManagedSaveImage has to be implemented manually */
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT,
+ (xdrproc_t)xdr_remote_domain_has_current_snapshot_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_has_current_snapshot_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.result;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainHasManagedSaveImage(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_has_managed_save_image_args args;
+ remote_domain_has_managed_save_image_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE,
+ (xdrproc_t)xdr_remote_domain_has_managed_save_image_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_has_managed_save_image_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.result;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainInterfaceStats has to be implemented manually */
-/* remoteDispatchDomainIsActive has to be implemented manually */
+static int
+remoteDomainIsActive(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_is_active_args args;
+ remote_domain_is_active_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_ACTIVE,
+ (xdrproc_t)xdr_remote_domain_is_active_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_is_active_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainIsPersistent(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_is_persistent_args args;
+ remote_domain_is_persistent_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_PERSISTENT,
+ (xdrproc_t)xdr_remote_domain_is_persistent_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_is_persistent_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainIsUpdated(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_is_updated_args args;
+ remote_domain_is_updated_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_UPDATED,
+ (xdrproc_t)xdr_remote_domain_is_updated_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_is_updated_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchDomainIsPersistent has to be implemented manually */
+ rv = ret.updated;
-/* remoteDispatchDomainIsUpdated has to be implemented manually */
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainLookupByID has to be implemented manually */
@@ -673,13 +942,63 @@ done:
return rv;
}
-/* remoteDispatchDomainSnapshotDumpXML has to be implemented manually */
+static char *
+remoteDomainSnapshotDumpXML(virDomainSnapshotPtr snap, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = snap->domain->conn->privateData;
+ remote_domain_snapshot_dump_xml_args args;
+ remote_domain_snapshot_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snap);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DUMP_XML,
+ (xdrproc_t)xdr_remote_domain_snapshot_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_snapshot_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchDomainSnapshotListNames has to be implemented manually */
/* remoteDispatchDomainSnapshotLookupByName has to be implemented manually */
-/* remoteDispatchDomainSnapshotNum has to be implemented manually */
+static int
+remoteDomainSnapshotNum(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_snapshot_num_args args;
+ remote_domain_snapshot_num_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_NUM,
+ (xdrproc_t)xdr_remote_domain_snapshot_num_args, (char *)&args,
+ (xdrproc_t)xdr_remote_domain_snapshot_num_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteDomainSuspend(virDomainPtr dom)
@@ -758,15 +1077,81 @@ done:
/* remoteDispatchFindStoragePoolSources has to be implemented manually */
-/* remoteDispatchGetCapabilities has to be implemented manually */
+static char *
+remoteGetCapabilities(virConnectPtr conn)
+{
+ char *rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_get_capabilities_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_GET_CAPABILITIES,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_get_capabilities_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.capabilities;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static char *
+remoteGetHostname(virConnectPtr conn)
+{
+ char *rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_get_hostname_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchGetHostname has to be implemented manually */
+ if (call(conn, priv, 0, REMOTE_PROC_GET_HOSTNAME,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_get_hostname_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.hostname;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchGetLibVersion has to be implemented manually */
/* remoteDispatchGetMaxVcpus has to be implemented manually */
-/* remoteDispatchGetSysinfo has to be implemented manually */
+static char *
+remoteGetSysinfo(virConnectPtr conn, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = conn->privateData;
+ remote_get_sysinfo_args args;
+ remote_get_sysinfo_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_GET_SYSINFO,
+ (xdrproc_t)xdr_remote_get_sysinfo_args, (char *)&args,
+ (xdrproc_t)xdr_remote_get_sysinfo_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.sysinfo;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchGetType has to be implemented manually */
@@ -824,9 +1209,58 @@ done:
return rv;
}
-/* remoteDispatchInterfaceGetXMLDesc has to be implemented manually */
+static char *
+remoteInterfaceGetXMLDesc(virInterfacePtr iface, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = iface->conn->interfacePrivateData;
+ remote_interface_get_xml_desc_args args;
+ remote_interface_get_xml_desc_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface(&args.iface, iface);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchInterfaceIsActive has to be implemented manually */
+ if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_GET_XML_DESC,
+ (xdrproc_t)xdr_remote_interface_get_xml_desc_args, (char *)&args,
+ (xdrproc_t)xdr_remote_interface_get_xml_desc_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteInterfaceIsActive(virInterfacePtr iface)
+{
+ int rv = -1;
+ struct private_data *priv = iface->conn->interfacePrivateData;
+ remote_interface_is_active_args args;
+ remote_interface_is_active_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface(&args.iface, iface);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_IS_ACTIVE,
+ (xdrproc_t)xdr_remote_interface_is_active_args, (char *)&args,
+ (xdrproc_t)xdr_remote_interface_is_active_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchInterfaceLookupByMACString has to be implemented manually */
@@ -927,15 +1361,112 @@ done:
return rv;
}
-/* remoteDispatchNetworkDumpXML has to be implemented manually */
+static char *
+remoteNetworkDumpXML(virNetworkPtr net, int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_dump_xml_args args;
+ remote_network_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_DUMP_XML,
+ (xdrproc_t)xdr_remote_network_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNetworkGetAutostart has to be implemented manually */
-/* remoteDispatchNetworkGetBridgeName has to be implemented manually */
+static char *
+remoteNetworkGetBridgeName(virNetworkPtr net)
+{
+ char *rv = NULL;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_get_bridge_name_args args;
+ remote_network_get_bridge_name_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_GET_BRIDGE_NAME,
+ (xdrproc_t)xdr_remote_network_get_bridge_name_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_get_bridge_name_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.name;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNetworkIsActive(virNetworkPtr net)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_is_active_args args;
+ remote_network_is_active_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_IS_ACTIVE,
+ (xdrproc_t)xdr_remote_network_is_active_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_is_active_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNetworkIsPersistent(virNetworkPtr net)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_is_persistent_args args;
+ remote_network_is_persistent_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchNetworkIsActive has to be implemented manually */
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_IS_PERSISTENT,
+ (xdrproc_t)xdr_remote_network_is_persistent_args, (char *)&args,
+ (xdrproc_t)xdr_remote_network_is_persistent_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchNetworkIsPersistent has to be implemented manually */
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNetworkLookupByName has to be implemented manually */
@@ -1015,7 +1546,32 @@ done:
/* remoteDispatchNodeDeviceDettach has to be implemented manually */
-/* remoteDispatchNodeDeviceDumpXML has to be implemented manually */
+static char *
+remoteNodeDeviceDumpXML(virNodeDevicePtr dev, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = dev->conn->devMonPrivateData;
+ remote_node_device_dump_xml_args args;
+ remote_node_device_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = dev->name;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DUMP_XML,
+ (xdrproc_t)xdr_remote_node_device_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_node_device_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNodeDeviceGetParent has to be implemented manually */
@@ -1023,7 +1579,31 @@ done:
/* remoteDispatchNodeDeviceLookupByName has to be implemented manually */
-/* remoteDispatchNodeDeviceNumOfCaps has to be implemented manually */
+static int
+remoteNodeDeviceNumOfCaps(virNodeDevicePtr dev)
+{
+ int rv = -1;
+ struct private_data *priv = dev->conn->devMonPrivateData;
+ remote_node_device_num_of_caps_args args;
+ remote_node_device_num_of_caps_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.name = dev->name;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS,
+ (xdrproc_t)xdr_remote_node_device_num_of_caps_args, (char *)&args,
+ (xdrproc_t)xdr_remote_node_device_num_of_caps_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNodeDeviceReAttach has to be implemented manually */
@@ -1039,31 +1619,291 @@ done:
/* remoteDispatchNodeListDevices has to be implemented manually */
-/* remoteDispatchNodeNumOfDevices has to be implemented manually */
+static int
+remoteNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = conn->devMonPrivateData;
+ remote_node_num_of_devices_args args;
+ remote_node_num_of_devices_ret ret;
+
+ remoteDriverLock(priv);
+
+ args.cap = cap ? (char **)&cap : NULL;
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NODE_NUM_OF_DEVICES,
+ (xdrproc_t)xdr_remote_node_num_of_devices_args, (char *)&args,
+ (xdrproc_t)xdr_remote_node_num_of_devices_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfDefinedDomains(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_num_of_defined_domains_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_DOMAINS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_defined_domains_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfDefinedInterfaces(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->interfacePrivateData;
+ remote_num_of_defined_interfaces_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_INTERFACES,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_defined_interfaces_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfDefinedNetworks(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_num_of_defined_networks_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_NETWORKS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_defined_networks_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfDefinedStoragePools(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_num_of_defined_storage_pools_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_defined_storage_pools_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfDomains(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_num_of_domains_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_DOMAINS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_domains_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfInterfaces(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->interfacePrivateData;
+ remote_num_of_interfaces_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_INTERFACES,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_interfaces_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfNetworks(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->networkPrivateData;
+ remote_num_of_networks_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_NETWORKS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_networks_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
-/* remoteDispatchNumOfDefinedDomains has to be implemented manually */
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
-/* remoteDispatchNumOfDefinedInterfaces has to be implemented manually */
+static int
+remoteNumOfNWFilters(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->nwfilterPrivateData;
+ remote_num_of_nwfilters_ret ret;
+
+ remoteDriverLock(priv);
-/* remoteDispatchNumOfDefinedNetworks has to be implemented manually */
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_NWFILTERS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_nwfilters_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchNumOfDefinedStoragePools has to be implemented manually */
+ rv = ret.num;
-/* remoteDispatchNumOfDomains has to be implemented manually */
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
-/* remoteDispatchNumOfInterfaces has to be implemented manually */
+static int
+remoteNumOfSecrets(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->secretPrivateData;
+ remote_num_of_secrets_ret ret;
-/* remoteDispatchNumOfNetworks has to be implemented manually */
+ remoteDriverLock(priv);
-/* remoteDispatchNumOfNWFilters has to be implemented manually */
+ memset(&ret, 0, sizeof ret);
-/* remoteDispatchNumOfSecrets has to be implemented manually */
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_SECRETS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_secrets_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchNumOfStoragePools has to be implemented manually */
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNumOfStoragePools(virConnectPtr conn)
+{
+ int rv = -1;
+ struct private_data *priv = conn->storagePrivateData;
+ remote_num_of_storage_pools_ret ret;
+
+ remoteDriverLock(priv);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
+ (xdrproc_t)xdr_void, (char *)NULL,
+ (xdrproc_t)xdr_remote_num_of_storage_pools_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNWFilterDefineXML has to be implemented manually */
-/* remoteDispatchNWFilterGetXMLDesc has to be implemented manually */
+static char *
+remoteNWFilterGetXMLDesc(virNWFilterPtr nwfilter, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
+ remote_nwfilter_get_xml_desc_args args;
+ remote_nwfilter_get_xml_desc_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_nwfilter(&args.nwfilter, nwfilter);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_GET_XML_DESC,
+ (xdrproc_t)xdr_remote_nwfilter_get_xml_desc_args, (char *)&args,
+ (xdrproc_t)xdr_remote_nwfilter_get_xml_desc_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchNWFilterLookupByName has to be implemented manually */
@@ -1098,7 +1938,32 @@ done:
/* remoteDispatchSecretGetValue has to be implemented manually */
-/* remoteDispatchSecretGetXMLDesc has to be implemented manually */
+static char *
+remoteSecretGetXMLDesc(virSecretPtr secret, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = secret->conn->secretPrivateData;
+ remote_secret_get_xml_desc_args args;
+ remote_secret_get_xml_desc_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_secret(&args.secret, secret);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(secret->conn, priv, 0, REMOTE_PROC_SECRET_GET_XML_DESC,
+ (xdrproc_t)xdr_remote_secret_get_xml_desc_args, (char *)&args,
+ (xdrproc_t)xdr_remote_secret_get_xml_desc_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchSecretLookupByUsage has to be implemented manually */
@@ -1228,15 +2093,88 @@ done:
return rv;
}
-/* remoteDispatchStoragePoolDumpXML has to be implemented manually */
+static char *
+remoteStoragePoolDumpXML(virStoragePoolPtr pool, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_dump_xml_args args;
+ remote_storage_pool_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DUMP_XML,
+ (xdrproc_t)xdr_remote_storage_pool_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_pool_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchStoragePoolGetAutostart has to be implemented manually */
/* remoteDispatchStoragePoolGetInfo has to be implemented manually */
-/* remoteDispatchStoragePoolIsActive has to be implemented manually */
+static int
+remoteStoragePoolIsActive(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_is_active_args args;
+ remote_storage_pool_is_active_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_ACTIVE,
+ (xdrproc_t)xdr_remote_storage_pool_is_active_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_pool_is_active_ret, (char *)&ret) == -1)
+ goto done;
-/* remoteDispatchStoragePoolIsPersistent has to be implemented manually */
+ rv = ret.active;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolIsPersistent(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_is_persistent_args args;
+ remote_storage_pool_is_persistent_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT,
+ (xdrproc_t)xdr_remote_storage_pool_is_persistent_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_pool_is_persistent_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.persistent;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchStoragePoolListVolumes has to be implemented manually */
@@ -1246,7 +2184,31 @@ done:
/* remoteDispatchStoragePoolLookupByVolume has to be implemented manually */
-/* remoteDispatchStoragePoolNumOfVolumes has to be implemented manually */
+static int
+remoteStoragePoolNumOfVolumes(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_num_of_volumes_args args;
+ remote_storage_pool_num_of_volumes_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES,
+ (xdrproc_t)xdr_remote_storage_pool_num_of_volumes_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_pool_num_of_volumes_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.num;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
static int
remoteStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
@@ -1349,11 +2311,60 @@ done:
/* remoteDispatchStorageVolDownload has to be implemented manually */
-/* remoteDispatchStorageVolDumpXML has to be implemented manually */
+static char *
+remoteStorageVolDumpXML(virStorageVolPtr vol, unsigned int flags)
+{
+ char *rv = NULL;
+ struct private_data *priv = vol->conn->storagePrivateData;
+ remote_storage_vol_dump_xml_args args;
+ remote_storage_vol_dump_xml_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_vol(&args.vol, vol);
+ args.flags = flags;
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DUMP_XML,
+ (xdrproc_t)xdr_remote_storage_vol_dump_xml_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_vol_dump_xml_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.xml;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchStorageVolGetInfo has to be implemented manually */
-/* remoteDispatchStorageVolGetPath has to be implemented manually */
+static char *
+remoteStorageVolGetPath(virStorageVolPtr vol)
+{
+ char *rv = NULL;
+ struct private_data *priv = vol->conn->storagePrivateData;
+ remote_storage_vol_get_path_args args;
+ remote_storage_vol_get_path_ret ret;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_vol(&args.vol, vol);
+
+ memset(&ret, 0, sizeof ret);
+
+ if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_GET_PATH,
+ (xdrproc_t)xdr_remote_storage_vol_get_path_args, (char *)&args,
+ (xdrproc_t)xdr_remote_storage_vol_get_path_ret, (char *)&ret) == -1)
+ goto done;
+
+ rv = ret.name;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
/* remoteDispatchStorageVolLookupByKey has to be implemented manually */
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index bf4d866..a67f9f6 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -1745,54 +1745,6 @@ done:
return rv;
}
-static char *
-remoteGetHostname (virConnectPtr conn)
-{
- char *rv = NULL;
- remote_get_hostname_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_GET_HOSTNAME,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_get_hostname_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees this. */
- rv = ret.hostname;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static char *
-remoteGetSysinfo (virConnectPtr conn, unsigned int flags)
-{
- char *rv = NULL;
- remote_get_sysinfo_args args;
- remote_get_sysinfo_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- args.flags = flags;
- if (call (conn, priv, 0, REMOTE_PROC_GET_SYSINFO,
- (xdrproc_t) xdr_remote_get_sysinfo_args, (char *) &args,
- (xdrproc_t) xdr_remote_get_sysinfo_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees this. */
- rv = ret.sysinfo;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int remoteIsSecure(virConnectPtr conn)
{
int rv = -1;
@@ -1914,29 +1866,6 @@ done:
return rv;
}
-static char *
-remoteGetCapabilities (virConnectPtr conn)
-{
- char *rv = NULL;
- remote_get_capabilities_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_GET_CAPABILITIES,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_get_capabilities_ret, (char *)&ret) == -1)
- goto done;
-
- /* Caller frees this. */
- rv = ret.capabilities;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteNodeGetCellsFreeMemory(virConnectPtr conn,
unsigned long long *freeMems,
@@ -2047,100 +1976,6 @@ done:
return rv;
}
-static int
-remoteNumOfDomains (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_domains_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DOMAINS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_domains_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainIsActive(virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_is_active_args args;
- remote_domain_is_active_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_ACTIVE,
- (xdrproc_t) xdr_remote_domain_is_active_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_is_active_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.active;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainIsPersistent(virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_is_persistent_args args;
- remote_domain_is_persistent_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_PERSISTENT,
- (xdrproc_t) xdr_remote_domain_is_persistent_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_is_persistent_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.persistent;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainIsUpdated(virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_is_updated_args args;
- remote_domain_is_updated_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_IS_UPDATED,
- (xdrproc_t) xdr_remote_domain_is_updated_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_is_updated_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.updated;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static virDomainPtr
remoteDomainCreateXML (virConnectPtr conn,
const char *xmlDesc,
@@ -2272,57 +2107,6 @@ done:
return rv;
}
-static char *
-remoteDomainGetOSType (virDomainPtr domain)
-{
- char *rv = NULL;
- remote_domain_get_os_type_args args;
- remote_domain_get_os_type_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- memset (&ret, 0, sizeof ret);
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_OS_TYPE,
- (xdrproc_t) xdr_remote_domain_get_os_type_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_get_os_type_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.type;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static unsigned long
-remoteDomainGetMaxMemory (virDomainPtr domain)
-{
- unsigned long rv = 0;
- remote_domain_get_max_memory_args args;
- remote_domain_get_max_memory_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- memset (&ret, 0, sizeof ret);
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_MEMORY,
- (xdrproc_t) xdr_remote_domain_get_max_memory_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_get_max_memory_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.memory;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteDomainSetMemoryParameters (virDomainPtr domain,
virMemoryParameterPtr params,
@@ -2693,32 +2477,6 @@ done:
}
static int
-remoteDomainGetVcpusFlags (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_get_vcpus_flags_args args;
- remote_domain_get_vcpus_flags_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_GET_VCPUS_FLAGS,
- (xdrproc_t) xdr_remote_domain_get_vcpus_flags_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_get_vcpus_flags_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainPinVcpu (virDomainPtr domain,
unsigned int vcpu,
unsigned char *cpumap,
@@ -2829,31 +2587,6 @@ done:
}
static int
-remoteDomainGetMaxVcpus (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_get_max_vcpus_args args;
- remote_domain_get_max_vcpus_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- memset (&ret, 0, sizeof ret);
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MAX_VCPUS,
- (xdrproc_t) xdr_remote_domain_get_max_vcpus_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_get_max_vcpus_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainGetSecurityLabel (virDomainPtr domain, virSecurityLabelPtr seclabel)
{
remote_domain_get_security_label_args args;
@@ -2934,33 +2667,6 @@ done:
}
static char *
-remoteDomainDumpXML (virDomainPtr domain, int flags)
-{
- char *rv = NULL;
- remote_domain_dump_xml_args args;
- remote_domain_dump_xml_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_DUMP_XML,
- (xdrproc_t) xdr_remote_domain_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static char *
remoteDomainXMLFromNative (virConnectPtr conn,
const char *format,
const char *config,
@@ -3286,28 +2992,6 @@ done:
}
static int
-remoteNumOfDefinedDomains (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_defined_domains_ret ret;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_DOMAINS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_defined_domains_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainCreate (virDomainPtr domain)
{
int rv = -1;
@@ -3846,31 +3530,6 @@ done:
return rv;
}
-static int
-remoteDomainHasManagedSaveImage (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_has_managed_save_image_args args;
- remote_domain_has_managed_save_image_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_MANAGED_SAVE_IMAGE,
- (xdrproc_t) xdr_remote_domain_has_managed_save_image_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_has_managed_save_image_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.result;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -3934,28 +3593,6 @@ remoteNetworkClose (virConnectPtr conn)
}
static int
-remoteNumOfNetworks (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_networks_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_NETWORKS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_networks_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListNetworks (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
@@ -4015,28 +3652,6 @@ done:
}
static int
-remoteNumOfDefinedNetworks (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_defined_networks_ret ret;
- struct private_data *priv = conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_NETWORKS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_defined_networks_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListDefinedNetworks (virConnectPtr conn,
char **const names, int maxnames)
{
@@ -4150,54 +3765,6 @@ done:
return net;
}
-static int
-remoteNetworkIsActive(virNetworkPtr network)
-{
- int rv = -1;
- remote_network_is_active_args args;
- remote_network_is_active_ret ret;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_ACTIVE,
- (xdrproc_t) xdr_remote_network_is_active_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_is_active_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.active;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteNetworkIsPersistent(virNetworkPtr network)
-{
- int rv = -1;
- remote_network_is_persistent_args args;
- remote_network_is_persistent_ret ret;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_IS_PERSISTENT,
- (xdrproc_t) xdr_remote_network_is_persistent_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_is_persistent_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.persistent;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static virNetworkPtr
remoteNetworkCreateXML (virConnectPtr conn, const char *xmlDesc)
{
@@ -4250,59 +3817,6 @@ done:
return net;
}
-static char *
-remoteNetworkDumpXML (virNetworkPtr network, int flags)
-{
- char *rv = NULL;
- remote_network_dump_xml_args args;
- remote_network_dump_xml_ret ret;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_DUMP_XML,
- (xdrproc_t) xdr_remote_network_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static char *
-remoteNetworkGetBridgeName (virNetworkPtr network)
-{
- char *rv = NULL;
- remote_network_get_bridge_name_args args;
- remote_network_get_bridge_name_ret ret;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- memset (&ret, 0, sizeof ret);
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_GET_BRIDGE_NAME,
- (xdrproc_t) xdr_remote_network_get_bridge_name_args, (char *) &args,
- (xdrproc_t) xdr_remote_network_get_bridge_name_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.name;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteNetworkGetAutostart (virNetworkPtr network, int *autostart)
{
@@ -4393,28 +3907,6 @@ remoteInterfaceClose (virConnectPtr conn)
}
static int
-remoteNumOfInterfaces (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_interfaces_ret ret;
- struct private_data *priv = conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_INTERFACES,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_interfaces_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListInterfaces (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
@@ -4474,28 +3966,6 @@ done:
}
static int
-remoteNumOfDefinedInterfaces (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_defined_interfaces_ret ret;
- struct private_data *priv = conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_INTERFACES,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_defined_interfaces_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListDefinedInterfaces (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
@@ -4608,60 +4078,6 @@ done:
return iface;
}
-
-static int
-remoteInterfaceIsActive(virInterfacePtr iface)
-{
- int rv = -1;
- remote_interface_is_active_args args;
- remote_interface_is_active_ret ret;
- struct private_data *priv = iface->conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_interface (&args.iface, iface);
-
- if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_IS_ACTIVE,
- (xdrproc_t) xdr_remote_interface_is_active_args, (char *) &args,
- (xdrproc_t) xdr_remote_interface_is_active_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.active;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static char *
-remoteInterfaceGetXMLDesc (virInterfacePtr iface,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_interface_get_xml_desc_args args;
- remote_interface_get_xml_desc_ret ret;
- struct private_data *priv = iface->conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_interface (&args.iface, iface);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_GET_XML_DESC,
- (xdrproc_t) xdr_remote_interface_get_xml_desc_args, (char *) &args,
- (xdrproc_t) xdr_remote_interface_get_xml_desc_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static virInterfacePtr
remoteInterfaceDefineXML (virConnectPtr conn,
const char *xmlDesc,
@@ -4761,28 +4177,6 @@ remoteStorageClose (virConnectPtr conn)
}
static int
-remoteNumOfStoragePools (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_storage_pools_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_STORAGE_POOLS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_storage_pools_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListStoragePools (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
@@ -4838,28 +4232,6 @@ done:
}
static int
-remoteNumOfDefinedStoragePools (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_defined_storage_pools_ret ret;
- struct private_data *priv = conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_DEFINED_STORAGE_POOLS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_defined_storage_pools_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteListDefinedStoragePools (virConnectPtr conn,
char **const names, int maxnames)
{
@@ -5040,56 +4412,6 @@ done:
return pool;
}
-
-static int
-remoteStoragePoolIsActive(virStoragePoolPtr pool)
-{
- int rv = -1;
- remote_storage_pool_is_active_args args;
- remote_storage_pool_is_active_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_ACTIVE,
- (xdrproc_t) xdr_remote_storage_pool_is_active_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_pool_is_active_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.active;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolIsPersistent(virStoragePoolPtr pool)
-{
- int rv = -1;
- remote_storage_pool_is_persistent_args args;
- remote_storage_pool_is_persistent_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_IS_PERSISTENT,
- (xdrproc_t) xdr_remote_storage_pool_is_persistent_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_pool_is_persistent_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.persistent;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static virStoragePoolPtr
remoteStoragePoolCreateXML (virConnectPtr conn, const char *xmlDesc, unsigned int flags)
{
@@ -5174,34 +4496,6 @@ done:
return rv;
}
-static char *
-remoteStoragePoolDumpXML (virStoragePoolPtr pool,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_storage_pool_dump_xml_args args;
- remote_storage_pool_dump_xml_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DUMP_XML,
- (xdrproc_t) xdr_remote_storage_pool_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_pool_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int
remoteStoragePoolGetAutostart (virStoragePoolPtr pool, int *autostart)
{
@@ -5229,30 +4523,6 @@ done:
return rv;
}
-static int
-remoteStoragePoolNumOfVolumes (virStoragePoolPtr pool)
-{
- int rv = -1;
- remote_storage_pool_num_of_volumes_args args;
- remote_storage_pool_num_of_volumes_ret ret;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool(&args.pool, pool);
-
- memset (&ret, 0, sizeof ret);
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_NUM_OF_VOLUMES,
- (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_pool_num_of_volumes_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
static int
remoteStoragePoolListVolumes (virStoragePoolPtr pool, char **const names, int maxnames)
@@ -5484,61 +4754,6 @@ done:
return rv;
}
-static char *
-remoteStorageVolDumpXML (virStorageVolPtr vol,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_storage_vol_dump_xml_args args;
- remote_storage_vol_dump_xml_ret ret;
- struct private_data *priv = vol->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_vol (&args.vol, vol);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DUMP_XML,
- (xdrproc_t) xdr_remote_storage_vol_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_vol_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static char *
-remoteStorageVolGetPath (virStorageVolPtr vol)
-{
- char *rv = NULL;
- remote_storage_vol_get_path_args args;
- remote_storage_vol_get_path_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_VOL_GET_PATH,
- (xdrproc_t) xdr_remote_storage_vol_get_path_args, (char *) &args,
- (xdrproc_t) xdr_remote_storage_vol_get_path_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.name;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5606,34 +4821,6 @@ static int remoteDevMonClose(virConnectPtr conn)
return ret;
}
-static int remoteNodeNumOfDevices(virConnectPtr conn,
- const char *cap,
- unsigned int flags)
-{
- int rv = -1;
- remote_node_num_of_devices_args args;
- remote_node_num_of_devices_ret ret;
- struct private_data *priv = conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- args.cap = cap ? (char **)&cap : NULL;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NODE_NUM_OF_DEVICES,
- (xdrproc_t) xdr_remote_node_num_of_devices_args, (char *) &args,
- (xdrproc_t) xdr_remote_node_num_of_devices_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static int remoteNodeListDevices(virConnectPtr conn,
const char *cap,
char **const names,
@@ -5722,33 +4909,6 @@ done:
return dev;
}
-static char *remoteNodeDeviceDumpXML(virNodeDevicePtr dev,
- unsigned int flags)
-{
- char *rv = NULL;
- remote_node_device_dump_xml_args args;
- remote_node_device_dump_xml_ret ret;
- struct private_data *priv = dev->conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = dev->name;
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DUMP_XML,
- (xdrproc_t) xdr_remote_node_device_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_node_device_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev)
{
char *rv = NULL;
@@ -5775,30 +4935,6 @@ done:
return rv;
}
-static int remoteNodeDeviceNumOfCaps(virNodeDevicePtr dev)
-{
- int rv = -1;
- remote_node_device_num_of_caps_args args;
- remote_node_device_num_of_caps_ret ret;
- struct private_data *priv = dev->conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = dev->name;
-
- memset (&ret, 0, sizeof ret);
- if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_NUM_OF_CAPS,
- (xdrproc_t) xdr_remote_node_device_num_of_caps_args, (char *) &args,
- (xdrproc_t) xdr_remote_node_device_num_of_caps_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int remoteNodeDeviceListCaps(virNodeDevicePtr dev,
char **const names,
int maxnames)
@@ -6023,30 +5159,6 @@ remoteNWFilterClose (virConnectPtr conn)
return rv;
}
-
-static int
-remoteNumOfNWFilters (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_nwfilters_ret ret;
- struct private_data *priv = conn->nwfilterPrivateData;
-
- remoteDriverLock(priv);
-
- memset (&ret, 0, sizeof ret);
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_NWFILTERS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_nwfilters_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static virNWFilterPtr
remoteNWFilterDefineXML (virConnectPtr conn, const char *xmlDesc,
unsigned int flags ATTRIBUTE_UNUSED)
@@ -6189,35 +5301,6 @@ done:
return net;
}
-
-static char *
-remoteNWFilterGetXMLDesc (virNWFilterPtr nwfilter, unsigned int flags)
-{
- char *rv = NULL;
- remote_nwfilter_get_xml_desc_args args;
- remote_nwfilter_get_xml_desc_ret ret;
- struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_nwfilter (&args.nwfilter, nwfilter);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_GET_XML_DESC,
- (xdrproc_t) xdr_remote_nwfilter_get_xml_desc_args, (char *) &args,
- (xdrproc_t) xdr_remote_nwfilter_get_xml_desc_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
/*----------------------------------------------------------------------*/
static int
@@ -7280,28 +6363,6 @@ remoteSecretClose (virConnectPtr conn)
}
static int
-remoteSecretNumOfSecrets (virConnectPtr conn)
-{
- int rv = -1;
- remote_num_of_secrets_ret ret;
- struct private_data *priv = conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- memset (&ret, 0, sizeof (ret));
- if (call (conn, priv, 0, REMOTE_PROC_NUM_OF_SECRETS,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_remote_num_of_secrets_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
-static int
remoteListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
{
int rv = -1;
@@ -7440,33 +6501,6 @@ done:
return rv;
}
-static char *
-remoteSecretGetXMLDesc (virSecretPtr secret, unsigned int flags)
-{
- char *rv = NULL;
- remote_secret_get_xml_desc_args args;
- remote_secret_get_xml_desc_ret ret;
- struct private_data *priv = secret->conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- make_nonnull_secret (&args.secret, secret);
- args.flags = flags;
-
- memset (&ret, 0, sizeof (ret));
- if (call (secret->conn, priv, 0, REMOTE_PROC_SECRET_GET_XML_DESC,
- (xdrproc_t) xdr_remote_secret_get_xml_desc_args, (char *) &args,
- (xdrproc_t) xdr_remote_secret_get_xml_desc_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
static int
remoteSecretSetValue (virSecretPtr secret, const unsigned char *value,
size_t value_size, unsigned int flags)
@@ -8070,34 +7104,6 @@ done:
return rv;
}
-
-static int
-remoteCPUCompare(virConnectPtr conn, const char *xmlDesc,
- unsigned int flags ATTRIBUTE_UNUSED)
-{
- struct private_data *priv = conn->privateData;
- remote_cpu_compare_args args;
- remote_cpu_compare_ret ret;
- int rv = VIR_CPU_COMPARE_ERROR;
-
- remoteDriverLock(priv);
-
- args.xml = (char *) xmlDesc;
-
- memset(&ret, 0, sizeof (ret));
- if (call(conn, priv, 0, REMOTE_PROC_CPU_COMPARE,
- (xdrproc_t) xdr_remote_cpu_compare_args, (char *) &args,
- (xdrproc_t) xdr_remote_cpu_compare_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.result;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static char *
remoteCPUBaseline(virConnectPtr conn,
const char **xmlCPUs,
@@ -8197,62 +7203,6 @@ done:
return snapshot;
}
-
-static char *
-remoteDomainSnapshotDumpXML(virDomainSnapshotPtr snapshot, unsigned int flags)
-{
- char *rv = NULL;
- remote_domain_snapshot_dump_xml_args args;
- remote_domain_snapshot_dump_xml_ret ret;
- struct private_data *priv = snapshot->domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain_snapshot(&args.snap, snapshot);
- args.flags = flags;
-
- memset (&ret, 0, sizeof ret);
- if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DUMP_XML,
- (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_snapshot_dump_xml_ret, (char *) &ret) == -1)
- goto done;
-
- /* Caller frees. */
- rv = ret.xml;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static int
-remoteDomainSnapshotNum (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_snapshot_num_args args;
- remote_domain_snapshot_num_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_NUM,
- (xdrproc_t) xdr_remote_domain_snapshot_num_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_snapshot_num_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.num;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static int
remoteDomainSnapshotListNames (virDomainPtr domain, char **const names,
int maxnames, unsigned int flags)
@@ -8346,33 +7296,6 @@ done:
return snapshot;
}
-
-static int
-remoteDomainHasCurrentSnapshot(virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_has_current_snapshot_args args;
- remote_domain_has_current_snapshot_ret ret;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain(&args.dom, domain);
- args.flags = flags;
-
- if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_HAS_CURRENT_SNAPSHOT,
- (xdrproc_t) xdr_remote_domain_has_current_snapshot_args, (char *) &args,
- (xdrproc_t) xdr_remote_domain_has_current_snapshot_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.result;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static virDomainSnapshotPtr
remoteDomainSnapshotCurrent(virDomainPtr domain,
unsigned int flags)
@@ -8617,7 +7540,6 @@ done:
remoteDriverUnlock(priv);
return rv;
-
}
@@ -8646,7 +7568,6 @@ remoteQemuDomainMonitorCommand (virDomainPtr domain, const char *cmd,
*result = strdup(ret.result);
if (*result == NULL) {
-
virReportOOMError();
goto cleanup;
}
@@ -10282,7 +9203,7 @@ static virSecretDriver secret_driver = {
.name = "remote",
.open = remoteSecretOpen,
.close = remoteSecretClose,
- .numOfSecrets = remoteSecretNumOfSecrets,
+ .numOfSecrets = remoteNumOfSecrets,
.listSecrets = remoteListSecrets,
.lookupByUUID = remoteSecretLookupByUUID,
.lookupByUsage = remoteSecretLookupByUsage,
--
1.7.0.4
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list