[libvirt] [PATCH 15/22] remote generator, client: Handle simple remote driver functions
Matthias Bolte
matthias.bolte at googlemail.com
Sun Apr 24 09:14:02 UTC 2011
Rename remoteSecretListSecrets to remoteListSecrets to match the normal
naming pattern.
---
cfg.mk | 8 +-
daemon/remote_generator.pl | 335 +++++++++-
src/Makefile.am | 13 +-
src/remote/qemu_client_bodies.c | 4 +
src/remote/remote_client_bodies.c | 1391 +++++++++++++++++++++++++++++++++++++
src/remote/remote_driver.c | 1116 +-----------------------------
6 files changed, 1750 insertions(+), 1117 deletions(-)
create mode 100644 src/remote/qemu_client_bodies.c
create mode 100644 src/remote/remote_client_bodies.c
diff --git a/cfg.mk b/cfg.mk
index a38ea48..82759bf 100644
--- a/cfg.mk
+++ b/cfg.mk
@@ -611,7 +611,7 @@ exclude_file_name_regexp--sc_prohibit_close = \
exclude_file_name_regexp--sc_prohibit_doubled_word = ^po/
exclude_file_name_regexp--sc_prohibit_empty_lines_at_EOF = \
- (^docs/api_extension/|^tests/qemuhelpdata/|\.(gif|ico|png)$$|daemon/.*_dispatch_bodies.c$$)
+ (^docs/api_extension/|^tests/qemuhelpdata/|\.(gif|ico|png)$$|^daemon/.*_dispatch_bodies.c$$|^src/remote/.*_client_bodies.c$$)
_src2=src/(util/util|libvirt|lxc/lxc_controller)
exclude_file_name_regexp--sc_prohibit_fork_wrappers = \
@@ -633,9 +633,11 @@ exclude_file_name_regexp--sc_prohibit_strncpy = \
exclude_file_name_regexp--sc_prohibit_xmlGetProp = ^src/util/xml\.c$$
-exclude_file_name_regexp--sc_require_config_h = ^(examples/|daemon/.*_dispatch_bodies.c$$)
+exclude_file_name_regexp--sc_require_config_h = \
+ ^(examples/|daemon/.*_dispatch_bodies.c$$|src/remote/.*_client_bodies.c$$)
-exclude_file_name_regexp--sc_require_config_h_first = ^(examples/|daemon/.*_dispatch_bodies.c$$)
+exclude_file_name_regexp--sc_require_config_h_first = \
+ ^(examples/|daemon/.*_dispatch_bodies.c$$|src/remote/.*_client_bodies.c$$)
exclude_file_name_regexp--sc_trailing_blank = (^docs/|\.(fig|gif|ico|png)$$)
diff --git a/daemon/remote_generator.pl b/daemon/remote_generator.pl
index 9fa3caa..73d1596 100755
--- a/daemon/remote_generator.pl
+++ b/daemon/remote_generator.pl
@@ -20,8 +20,8 @@ use strict;
use Getopt::Std;
# Command line options.
-our ($opt_p, $opt_t, $opt_a, $opt_r, $opt_d, $opt_c, $opt_b);
-getopts ('ptardcb');
+our ($opt_p, $opt_t, $opt_a, $opt_r, $opt_d, $opt_c, $opt_b, $opt_k);
+getopts ('ptardcbk');
my $structprefix = $ARGV[0];
my $procprefix = uc $structprefix;
@@ -724,3 +724,334 @@ elsif ($opt_b) {
print "\n";
}
}
+
+# Bodies for client functions ("remote_client_bodies.c").
+elsif ($opt_k) {
+ # list of functions that currently are not generatable
+ my @ungeneratable;
+
+ if ($structprefix eq "remote") {
+ @ungeneratable = ("Close",
+ "DomainEventsDeregisterAny",
+ "DomainEventsRegisterAny",
+ "DomainMigratePrepareTunnel",
+ "DomainOpenConsole",
+ "DomainPinVcpu",
+ "DomainSetSchedulerParameters",
+ "DomainSetMemoryParameters",
+ "DomainSetBlkioParameters",
+ "Open",
+ "StorageVolUpload",
+ "StorageVolDownload",
+
+ "AuthList",
+ "AuthSaslInit",
+ "AuthSaslStart",
+ "AuthSaslStep",
+ "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",
+ "ListDefinedInterfaces",
+ "ListNWFilters",
+ "NetworkCreateXML",
+ "SupportsFeature",
+ "StorageVolLookupByPath",
+ "StorageVolGetInfo",
+ "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",
+ "ListInterfaces",
+ "NetworkDefineXML",
+ "NetworkLookupByName",
+ "ListDefinedStoragePools",
+ "NetworkIsPersistent",
+ "NodeDeviceDettach",
+ "NodeDeviceLookupByName",
+ "NodeGetFreeMemory",
+ "NumOfDefinedDomains",
+ "ListNetworks",
+ "NodeDeviceListCaps",
+ "NodeDeviceReset",
+ "NumOfNetworks",
+ "NetworkLookupByUUID",
+ "NodeDeviceNumOfCaps",
+ "NumOfSecrets",
+ "NodeDeviceReAttach",
+ "ListSecrets",
+
+ "DomainBlockPeek",
+ "DomainCreateWithFlags",
+ "DomainEventsDeregister",
+ "DomainEventsRegister",
+ "DomainGetBlkioParameters",
+ "DomainGetMemoryParameters",
+ "DomainGetSchedulerParameters",
+ "DomainGetSchedulerType",
+ "DomainGetSecurityLabel",
+ "DomainGetVcpus",
+ "DomainMemoryPeek",
+ "DomainMemoryStats",
+ "DomainMigratePrepare",
+ "DomainMigratePrepare2",
+ "GetType",
+ "NodeDeviceGetParent",
+ "NodeGetSecurityModel",
+ "SecretGetValue");
+ } elsif ($structprefix eq "qemu") {
+ @ungeneratable = ("MonitorCommand");
+ }
+
+ my %ug = map { $_ => 1 } @ungeneratable;
+ my @keys = sort (keys %calls);
+
+ foreach (@keys) {
+ my $call = $calls{$_};
+
+ # skip things which are REMOTE_MESSAGE
+ next if $call->{msg};
+
+ if (exists($ug{$call->{ProcName}})) {
+ print "/* ${structprefix}Dispatch$call->{ProcName} has to " .
+ "be implemented manually */\n\n";
+ next;
+ }
+
+ my @args_list = ();
+ my @vars_list = ();
+ my @setters_list = ();
+ my $priv_src = "conn";
+ my $priv_name = "privateData";
+ my $args = "&args";
+ my $ret = "&ret";
+
+ if ($call->{args} eq "void") {
+ $args = "NULL";
+ } else {
+ push(@vars_list, "$call->{args} args");
+
+ my $is_first_arg = 1;
+ my $has_node_device = 0;
+
+ # node device is special
+ if ($call->{args} =~ m/^remote_node_device_/) {
+ $has_node_device = 1;
+ }
+
+ 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+);/) {
+ my $name = $1;
+ my $type_name = name_to_ProcName($name);
+
+ if ($is_first_arg) {
+ if ($name eq "domain_snapshot") {
+ $priv_src = "$2->domain->conn";
+ } else {
+ $priv_src = "$2->conn";
+ }
+
+ if ($name =~ m/^storage_/) {
+ $priv_name = "storagePrivateData";
+ } elsif (!($name =~ m/^domain/)) {
+ $priv_name = "${name}PrivateData";
+ }
+ }
+
+ push(@args_list, "vir${type_name}Ptr $2");
+ push(@setters_list, "make_nonnull_$1(&args.$2, $2);");
+ } elsif ($args_member =~ m/^remote_nonnull_string (\S+);/) {
+ push(@args_list, "const char *$1");
+ push(@setters_list, "args.$1 = (char *)$1;");
+ } elsif ($args_member =~ m/(\S+)<\S+>;/) {
+ # ignored for now
+ } elsif ($args_member =~ m/^(.*) (\S+);/) {
+ my $type_name = $1;
+ my $arg_name = $2;
+
+ $type_name =~ s/hyper/long/;
+ $type_name =~ s/^unsigned$/unsigned int/;
+ $type_name =~ s/u_int/unsigned int/;
+
+ if ($type_name eq "int") {
+ # fix bad decisions in the xdr protocol
+ if ($arg_name eq "flags" and
+ $call->{ProcName} ne "DomainCoreDump") {
+ $type_name = "unsigned int";
+ } elsif ($arg_name eq "nvcpus" and
+ $call->{ProcName} eq "DomainSetVcpus") {
+ $type_name = "unsigned int";
+ }
+ }
+
+ if ($call->{ProcName} eq "DomainMigrateSetMaxDowntime" and
+ $arg_name eq "downtime") {
+ $type_name = "unsigned long long";
+ }
+
+ push(@args_list, "$type_name $arg_name");
+ push(@setters_list, "args.$arg_name = $arg_name;");
+ } elsif ($args_member =~ m/^\/*/) {
+ # ignore comments
+ } else {
+ die "unhandled type for argument value: $args_member";
+ }
+
+ if ($is_first_arg and $priv_src eq "conn") {
+ unshift(@args_list, "virConnectPtr conn");
+ }
+
+ $is_first_arg = 0;
+ }
+ }
+
+ if ($call->{ret} eq "void") {
+ $ret = "NULL";
+ } else {
+ push(@vars_list, "$call->{ret} ret");
+ }
+
+ # print function
+ print "static int\n";
+ print "remote$call->{ProcName}(";
+
+ print join(", ", @args_list);
+
+ print ")\n";
+ print "{\n";
+ print " int rv = -1;\n";
+ print " struct private_data *priv = $priv_src->$priv_name;\n";
+
+ foreach my $var (@vars_list) {
+ print " $var;\n";
+ }
+
+ print "\n";
+ print " remoteDriverLock(priv);\n";
+ print "\n";
+
+ if (@setters_list) {
+ print " ";
+ }
+
+ print join("\n ", @setters_list);
+
+ if (@setters_list) {
+ print "\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 " goto done;\n";
+ print "\n";
+ print " rv = 0;\n";
+ print "\n";
+ print "done:\n";
+ print " remoteDriverUnlock(priv);\n";
+ print " return rv;\n";
+ print "}\n";
+ print "\n";
+ }
+}
diff --git a/src/Makefile.am b/src/Makefile.am
index 1eaa7d1..8ba176d 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -162,8 +162,19 @@ REMOTE_DRIVER_SOURCES = \
remote/qemu_protocol.c \
remote/qemu_protocol.h
+remote/remote_driver.c: remote/remote_client_bodies.c remote/qemu_client_bodies.c
+
+REMOTE_PROTOCOL = $(top_srcdir)/src/remote/remote_protocol.x
+QEMU_PROTOCOL = $(top_srcdir)/src/remote/qemu_protocol.x
+
+remote/remote_client_bodies.c: $(top_srcdir)/daemon/remote_generator.pl $(REMOTE_PROTOCOL)
+ $(AM_V_GEN)perl -w $(top_srcdir)/daemon/remote_generator.pl -c -k remote $(REMOTE_PROTOCOL) > $@
+
+remote/qemu_client_bodies.c: $(top_srcdir)/daemon/remote_generator.pl $(QEMU_PROTOCOL)
+ $(AM_V_GEN)perl -w $(top_srcdir)/daemon/remote_generator.pl -k remote $(QEMU_PROTOCOL) > $@
+
EXTRA_DIST += remote/remote_protocol.x remote/qemu_protocol.x \
- remote/rpcgen_fix.pl
+ remote/rpcgen_fix.pl remote/remote_client_bodies.c remote/qemu_client_bodies.c
# Ensure that we don't change the struct or member names or member ordering
# in remote_protocol.x The embedded perl below needs a few comments, and
diff --git a/src/remote/qemu_client_bodies.c b/src/remote/qemu_client_bodies.c
new file mode 100644
index 0000000..dd66ba3
--- /dev/null
+++ b/src/remote/qemu_client_bodies.c
@@ -0,0 +1,4 @@
+/* Automatically generated by remote_generator.pl.
+ * Do not edit this file. Any changes you make will be lost.
+ */
+
diff --git a/src/remote/remote_client_bodies.c b/src/remote/remote_client_bodies.c
new file mode 100644
index 0000000..07ddfbf
--- /dev/null
+++ b/src/remote/remote_client_bodies.c
@@ -0,0 +1,1391 @@
+/* Automatically generated by remote_generator.pl.
+ * Do not edit this file. Any changes you make will be lost.
+ */
+
+/* remoteDispatchAuthList has to be implemented manually */
+
+/* remoteDispatchAuthPolkit has to be implemented manually */
+
+/* remoteDispatchAuthSaslInit has to be implemented manually */
+
+/* remoteDispatchAuthSaslStart has to be implemented manually */
+
+/* remoteDispatchAuthSaslStep has to be implemented manually */
+
+/* remoteDispatchClose has to be implemented manually */
+
+/* remoteDispatchCPUBaseline has to be implemented manually */
+
+/* remoteDispatchCPUCompare has to be implemented manually */
+
+static int
+remoteDomainAbortJob(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_abort_job_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ABORT_JOB,
+ (xdrproc_t)xdr_remote_domain_abort_job_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainAttachDevice(virDomainPtr dom, const char *xml)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_attach_device_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml = (char *)xml;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE,
+ (xdrproc_t)xdr_remote_domain_attach_device_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainAttachDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_attach_device_flags_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS,
+ (xdrproc_t)xdr_remote_domain_attach_device_flags_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainBlockPeek has to be implemented manually */
+
+/* remoteDispatchDomainBlockStats has to be implemented manually */
+
+static int
+remoteDomainCoreDump(virDomainPtr dom, const char *to, int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_core_dump_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.to = (char *)to;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_CORE_DUMP,
+ (xdrproc_t)xdr_remote_domain_core_dump_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainCreate has to be implemented manually */
+
+/* remoteDispatchDomainCreateWithFlags has to be implemented manually */
+
+/* remoteDispatchDomainCreateXML has to be implemented manually */
+
+/* remoteDispatchDomainDefineXML has to be implemented manually */
+
+/* remoteDispatchDomainDestroy has to be implemented manually */
+
+static int
+remoteDomainDetachDevice(virDomainPtr dom, const char *xml)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_detach_device_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml = (char *)xml;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE,
+ (xdrproc_t)xdr_remote_domain_detach_device_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainDetachDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_detach_device_flags_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS,
+ (xdrproc_t)xdr_remote_domain_detach_device_flags_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainDumpXML has to be implemented manually */
+
+/* remoteDispatchDomainEventsDeregister has to be implemented manually */
+
+/* remoteDispatchDomainEventsDeregisterAny has to be implemented manually */
+
+/* remoteDispatchDomainEventsRegister has to be implemented manually */
+
+/* remoteDispatchDomainEventsRegisterAny has to be implemented manually */
+
+/* remoteDispatchDomainGetAutostart has to be implemented manually */
+
+/* remoteDispatchDomainGetBlkioParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetBlockInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetJobInfo has to be implemented manually */
+
+/* remoteDispatchDomainGetMaxMemory has to be implemented manually */
+
+/* remoteDispatchDomainGetMaxVcpus has to be implemented manually */
+
+/* remoteDispatchDomainGetMemoryParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetOSType has to be implemented manually */
+
+/* remoteDispatchDomainGetSchedulerParameters has to be implemented manually */
+
+/* remoteDispatchDomainGetSchedulerType has to be implemented manually */
+
+/* remoteDispatchDomainGetSecurityLabel has to be implemented manually */
+
+/* remoteDispatchDomainGetVcpus has to be implemented manually */
+
+/* remoteDispatchDomainGetVcpusFlags has to be implemented manually */
+
+/* remoteDispatchDomainHasCurrentSnapshot has to be implemented manually */
+
+/* remoteDispatchDomainHasManagedSaveImage has to be implemented manually */
+
+/* remoteDispatchDomainInterfaceStats has to be implemented manually */
+
+/* remoteDispatchDomainIsActive has to be implemented manually */
+
+/* remoteDispatchDomainIsPersistent has to be implemented manually */
+
+/* remoteDispatchDomainIsUpdated has to be implemented manually */
+
+/* remoteDispatchDomainLookupByID has to be implemented manually */
+
+/* remoteDispatchDomainLookupByName has to be implemented manually */
+
+/* remoteDispatchDomainLookupByUUID has to be implemented manually */
+
+static int
+remoteDomainManagedSave(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_managed_save_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE,
+ (xdrproc_t)xdr_remote_domain_managed_save_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_managed_save_remove_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MANAGED_SAVE_REMOVE,
+ (xdrproc_t)xdr_remote_domain_managed_save_remove_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainMemoryPeek has to be implemented manually */
+
+/* remoteDispatchDomainMemoryStats has to be implemented manually */
+
+/* remoteDispatchDomainMigrateFinish has to be implemented manually */
+
+/* remoteDispatchDomainMigrateFinish2 has to be implemented manually */
+
+/* remoteDispatchDomainMigratePerform has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepare has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepare2 has to be implemented manually */
+
+/* remoteDispatchDomainMigratePrepareTunnel has to be implemented manually */
+
+static int
+remoteDomainMigrateSetMaxDowntime(virDomainPtr dom, unsigned long long downtime, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_migrate_set_max_downtime_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.downtime = downtime;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME,
+ (xdrproc_t)xdr_remote_domain_migrate_set_max_downtime_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainMigrateSetMaxSpeed(virDomainPtr dom, unsigned long bandwidth, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_migrate_set_max_speed_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.bandwidth = bandwidth;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED,
+ (xdrproc_t)xdr_remote_domain_migrate_set_max_speed_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainOpenConsole has to be implemented manually */
+
+/* remoteDispatchDomainPinVcpu has to be implemented manually */
+
+static int
+remoteDomainReboot(virDomainPtr dom, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_reboot_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_REBOOT,
+ (xdrproc_t)xdr_remote_domain_reboot_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainRestore(virConnectPtr conn, const char *from)
+{
+ int rv = -1;
+ struct private_data *priv = conn->privateData;
+ remote_domain_restore_args args;
+
+ remoteDriverLock(priv);
+
+ args.from = (char *)from;
+
+ if (call(conn, priv, 0, REMOTE_PROC_DOMAIN_RESTORE,
+ (xdrproc_t)xdr_remote_domain_restore_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainResume(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_resume_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_RESUME,
+ (xdrproc_t)xdr_remote_domain_resume_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainRevertToSnapshot(virDomainSnapshotPtr snap, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = snap->domain->conn->privateData;
+ remote_domain_revert_to_snapshot_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snap);
+ args.flags = flags;
+
+ if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT,
+ (xdrproc_t)xdr_remote_domain_revert_to_snapshot_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainSave(virDomainPtr dom, const char *to)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_save_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.to = (char *)to;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE,
+ (xdrproc_t)xdr_remote_domain_save_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainSetAutostart(virDomainPtr dom, int autostart)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_autostart_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.autostart = autostart;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_AUTOSTART,
+ (xdrproc_t)xdr_remote_domain_set_autostart_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainSetBlkioParameters has to be implemented manually */
+
+static int
+remoteDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_max_memory_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.memory = memory;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MAX_MEMORY,
+ (xdrproc_t)xdr_remote_domain_set_max_memory_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainSetMemory(virDomainPtr dom, unsigned long memory)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_memory_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.memory = memory;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY,
+ (xdrproc_t)xdr_remote_domain_set_memory_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainSetMemoryFlags(virDomainPtr dom, unsigned long memory, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_memory_flags_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.memory = memory;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS,
+ (xdrproc_t)xdr_remote_domain_set_memory_flags_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainSetMemoryParameters has to be implemented manually */
+
+/* remoteDispatchDomainSetSchedulerParameters has to be implemented manually */
+
+static int
+remoteDomainSetVcpus(virDomainPtr dom, unsigned int nvcpus)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_vcpus_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.nvcpus = nvcpus;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS,
+ (xdrproc_t)xdr_remote_domain_set_vcpus_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainSetVcpusFlags(virDomainPtr dom, unsigned int nvcpus, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_set_vcpus_flags_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.nvcpus = nvcpus;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS,
+ (xdrproc_t)xdr_remote_domain_set_vcpus_flags_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainShutdown(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_shutdown_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN,
+ (xdrproc_t)xdr_remote_domain_shutdown_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainSnapshotCreateXML has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotCurrent has to be implemented manually */
+
+static int
+remoteDomainSnapshotDelete(virDomainSnapshotPtr snap, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = snap->domain->conn->privateData;
+ remote_domain_snapshot_delete_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain_snapshot(&args.snap, snap);
+ args.flags = flags;
+
+ if (call(snap->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE,
+ (xdrproc_t)xdr_remote_domain_snapshot_delete_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainSnapshotDumpXML has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotListNames has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotLookupByName has to be implemented manually */
+
+/* remoteDispatchDomainSnapshotNum has to be implemented manually */
+
+static int
+remoteDomainSuspend(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_suspend_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SUSPEND,
+ (xdrproc_t)xdr_remote_domain_suspend_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainUndefine(virDomainPtr dom)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_UNDEFINE,
+ (xdrproc_t)xdr_remote_domain_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteDomainUpdateDeviceFlags(virDomainPtr dom, const char *xml, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = dom->conn->privateData;
+ remote_domain_update_device_flags_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_domain(&args.dom, dom);
+ args.xml = (char *)xml;
+ args.flags = flags;
+
+ if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS,
+ (xdrproc_t)xdr_remote_domain_update_device_flags_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchDomainXMLFromNative has to be implemented manually */
+
+/* remoteDispatchDomainXMLToNative has to be implemented manually */
+
+/* remoteDispatchFindStoragePoolSources has to be implemented manually */
+
+/* remoteDispatchGetCapabilities has to be implemented manually */
+
+/* remoteDispatchGetHostname has to be implemented manually */
+
+/* remoteDispatchGetLibVersion has to be implemented manually */
+
+/* remoteDispatchGetMaxVcpus has to be implemented manually */
+
+/* remoteDispatchGetSysinfo has to be implemented manually */
+
+/* remoteDispatchGetType has to be implemented manually */
+
+/* remoteDispatchGetURI has to be implemented manually */
+
+/* remoteDispatchGetVersion has to be implemented manually */
+
+static int
+remoteInterfaceCreate(virInterfacePtr iface, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = iface->conn->interfacePrivateData;
+ remote_interface_create_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface(&args.iface, iface);
+ args.flags = flags;
+
+ if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
+ (xdrproc_t)xdr_remote_interface_create_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchInterfaceDefineXML has to be implemented manually */
+
+static int
+remoteInterfaceDestroy(virInterfacePtr iface, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = iface->conn->interfacePrivateData;
+ remote_interface_destroy_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface(&args.iface, iface);
+ args.flags = flags;
+
+ if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
+ (xdrproc_t)xdr_remote_interface_destroy_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchInterfaceGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchInterfaceIsActive has to be implemented manually */
+
+/* remoteDispatchInterfaceLookupByMACString has to be implemented manually */
+
+/* remoteDispatchInterfaceLookupByName has to be implemented manually */
+
+static int
+remoteInterfaceUndefine(virInterfacePtr iface)
+{
+ int rv = -1;
+ struct private_data *priv = iface->conn->interfacePrivateData;
+ remote_interface_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_interface(&args.iface, iface);
+
+ if (call(iface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
+ (xdrproc_t)xdr_remote_interface_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchIsSecure has to be implemented manually */
+
+/* remoteDispatchListDefinedDomains has to be implemented manually */
+
+/* remoteDispatchListDefinedInterfaces has to be implemented manually */
+
+/* remoteDispatchListDefinedNetworks has to be implemented manually */
+
+/* remoteDispatchListDefinedStoragePools has to be implemented manually */
+
+/* remoteDispatchListDomains has to be implemented manually */
+
+/* remoteDispatchListInterfaces has to be implemented manually */
+
+/* remoteDispatchListNetworks has to be implemented manually */
+
+/* remoteDispatchListNWFilters has to be implemented manually */
+
+/* remoteDispatchListSecrets has to be implemented manually */
+
+/* remoteDispatchListStoragePools has to be implemented manually */
+
+static int
+remoteNetworkCreate(virNetworkPtr net)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_create_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_CREATE,
+ (xdrproc_t)xdr_remote_network_create_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchNetworkCreateXML has to be implemented manually */
+
+/* remoteDispatchNetworkDefineXML has to be implemented manually */
+
+static int
+remoteNetworkDestroy(virNetworkPtr net)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_destroy_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_DESTROY,
+ (xdrproc_t)xdr_remote_network_destroy_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchNetworkDumpXML has to be implemented manually */
+
+/* remoteDispatchNetworkGetAutostart has to be implemented manually */
+
+/* remoteDispatchNetworkGetBridgeName has to be implemented manually */
+
+/* remoteDispatchNetworkIsActive has to be implemented manually */
+
+/* remoteDispatchNetworkIsPersistent has to be implemented manually */
+
+/* remoteDispatchNetworkLookupByName has to be implemented manually */
+
+/* remoteDispatchNetworkLookupByUUID has to be implemented manually */
+
+static int
+remoteNetworkSetAutostart(virNetworkPtr net, int autostart)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_set_autostart_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+ args.autostart = autostart;
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_SET_AUTOSTART,
+ (xdrproc_t)xdr_remote_network_set_autostart_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteNetworkUndefine(virNetworkPtr net)
+{
+ int rv = -1;
+ struct private_data *priv = net->conn->networkPrivateData;
+ remote_network_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_network(&args.net, net);
+
+ if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_UNDEFINE,
+ (xdrproc_t)xdr_remote_network_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchNodeDeviceCreateXML has to be implemented manually */
+
+static int
+remoteNodeDeviceDestroy(virNodeDevicePtr dev)
+{
+ int rv = -1;
+ struct private_data *priv = dev->conn->devMonPrivateData;
+ remote_node_device_destroy_args args;
+
+ remoteDriverLock(priv);
+
+ args.name = dev->name;
+
+ if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DESTROY,
+ (xdrproc_t)xdr_remote_node_device_destroy_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchNodeDeviceDettach has to be implemented manually */
+
+/* remoteDispatchNodeDeviceDumpXML has to be implemented manually */
+
+/* remoteDispatchNodeDeviceGetParent has to be implemented manually */
+
+/* remoteDispatchNodeDeviceListCaps has to be implemented manually */
+
+/* remoteDispatchNodeDeviceLookupByName has to be implemented manually */
+
+/* remoteDispatchNodeDeviceNumOfCaps has to be implemented manually */
+
+/* remoteDispatchNodeDeviceReAttach has to be implemented manually */
+
+/* remoteDispatchNodeDeviceReset has to be implemented manually */
+
+/* remoteDispatchNodeGetCellsFreeMemory has to be implemented manually */
+
+/* remoteDispatchNodeGetFreeMemory has to be implemented manually */
+
+/* remoteDispatchNodeGetInfo has to be implemented manually */
+
+/* remoteDispatchNodeGetSecurityModel has to be implemented manually */
+
+/* remoteDispatchNodeListDevices has to be implemented manually */
+
+/* remoteDispatchNodeNumOfDevices has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedDomains has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedInterfaces has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedNetworks has to be implemented manually */
+
+/* remoteDispatchNumOfDefinedStoragePools has to be implemented manually */
+
+/* remoteDispatchNumOfDomains has to be implemented manually */
+
+/* remoteDispatchNumOfInterfaces has to be implemented manually */
+
+/* remoteDispatchNumOfNetworks has to be implemented manually */
+
+/* remoteDispatchNumOfNWFilters has to be implemented manually */
+
+/* remoteDispatchNumOfSecrets has to be implemented manually */
+
+/* remoteDispatchNumOfStoragePools has to be implemented manually */
+
+/* remoteDispatchNWFilterDefineXML has to be implemented manually */
+
+/* remoteDispatchNWFilterGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchNWFilterLookupByName has to be implemented manually */
+
+/* remoteDispatchNWFilterLookupByUUID has to be implemented manually */
+
+static int
+remoteNWFilterUndefine(virNWFilterPtr nwfilter)
+{
+ int rv = -1;
+ struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
+ remote_nwfilter_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_nwfilter(&args.nwfilter, nwfilter);
+
+ if (call(nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_UNDEFINE,
+ (xdrproc_t)xdr_remote_nwfilter_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchOpen has to be implemented manually */
+
+/* remoteDispatchSecretDefineXML has to be implemented manually */
+
+/* remoteDispatchSecretGetValue has to be implemented manually */
+
+/* remoteDispatchSecretGetXMLDesc has to be implemented manually */
+
+/* remoteDispatchSecretLookupByUsage has to be implemented manually */
+
+/* remoteDispatchSecretLookupByUUID has to be implemented manually */
+
+/* remoteDispatchSecretSetValue has to be implemented manually */
+
+static int
+remoteSecretUndefine(virSecretPtr secret)
+{
+ int rv = -1;
+ struct private_data *priv = secret->conn->secretPrivateData;
+ remote_secret_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_secret(&args.secret, secret);
+
+ if (call(secret->conn, priv, 0, REMOTE_PROC_SECRET_UNDEFINE,
+ (xdrproc_t)xdr_remote_secret_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolBuild(virStoragePoolPtr pool, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_build_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.flags = flags;
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
+ (xdrproc_t)xdr_remote_storage_pool_build_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolCreate(virStoragePoolPtr pool, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_create_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.flags = flags;
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
+ (xdrproc_t)xdr_remote_storage_pool_create_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchStoragePoolCreateXML has to be implemented manually */
+
+/* remoteDispatchStoragePoolDefineXML has to be implemented manually */
+
+static int
+remoteStoragePoolDelete(virStoragePoolPtr pool, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_delete_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.flags = flags;
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
+ (xdrproc_t)xdr_remote_storage_pool_delete_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolDestroy(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_destroy_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DESTROY,
+ (xdrproc_t)xdr_remote_storage_pool_destroy_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchStoragePoolDumpXML has to be implemented manually */
+
+/* remoteDispatchStoragePoolGetAutostart has to be implemented manually */
+
+/* remoteDispatchStoragePoolGetInfo has to be implemented manually */
+
+/* remoteDispatchStoragePoolIsActive has to be implemented manually */
+
+/* remoteDispatchStoragePoolIsPersistent has to be implemented manually */
+
+/* remoteDispatchStoragePoolListVolumes has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByName has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByUUID has to be implemented manually */
+
+/* remoteDispatchStoragePoolLookupByVolume has to be implemented manually */
+
+/* remoteDispatchStoragePoolNumOfVolumes has to be implemented manually */
+
+static int
+remoteStoragePoolRefresh(virStoragePoolPtr pool, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_refresh_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.flags = flags;
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
+ (xdrproc_t)xdr_remote_storage_pool_refresh_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolSetAutostart(virStoragePoolPtr pool, int autostart)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_set_autostart_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+ args.autostart = autostart;
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
+ (xdrproc_t)xdr_remote_storage_pool_set_autostart_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+static int
+remoteStoragePoolUndefine(virStoragePoolPtr pool)
+{
+ int rv = -1;
+ struct private_data *priv = pool->conn->storagePrivateData;
+ remote_storage_pool_undefine_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_pool(&args.pool, pool);
+
+ if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_UNDEFINE,
+ (xdrproc_t)xdr_remote_storage_pool_undefine_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchStorageVolCreateXML has to be implemented manually */
+
+/* remoteDispatchStorageVolCreateXMLFrom has to be implemented manually */
+
+static int
+remoteStorageVolDelete(virStorageVolPtr vol, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = vol->conn->storagePrivateData;
+ remote_storage_vol_delete_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_vol(&args.vol, vol);
+ args.flags = flags;
+
+ if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
+ (xdrproc_t)xdr_remote_storage_vol_delete_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchStorageVolDownload has to be implemented manually */
+
+/* remoteDispatchStorageVolDumpXML has to be implemented manually */
+
+/* remoteDispatchStorageVolGetInfo has to be implemented manually */
+
+/* remoteDispatchStorageVolGetPath has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByKey has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByName has to be implemented manually */
+
+/* remoteDispatchStorageVolLookupByPath has to be implemented manually */
+
+/* remoteDispatchStorageVolUpload has to be implemented manually */
+
+static int
+remoteStorageVolWipe(virStorageVolPtr vol, unsigned int flags)
+{
+ int rv = -1;
+ struct private_data *priv = vol->conn->storagePrivateData;
+ remote_storage_vol_wipe_args args;
+
+ remoteDriverLock(priv);
+
+ make_nonnull_storage_vol(&args.vol, vol);
+ args.flags = flags;
+
+ if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_WIPE,
+ (xdrproc_t)xdr_remote_storage_vol_wipe_args, (char *)&args,
+ (xdrproc_t)xdr_void, (char *)NULL) == -1)
+ goto done;
+
+ rv = 0;
+
+done:
+ remoteDriverUnlock(priv);
+ return rv;
+}
+
+/* remoteDispatchSupportsFeature has to be implemented manually */
+
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 934fdda..bf4d866 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -2249,99 +2249,6 @@ done:
}
static int
-remoteDomainSuspend (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_suspend_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SUSPEND,
- (xdrproc_t) xdr_remote_domain_suspend_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainResume (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_resume_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_RESUME,
- (xdrproc_t) xdr_remote_domain_resume_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainShutdown (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_shutdown_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SHUTDOWN,
- (xdrproc_t) xdr_remote_domain_shutdown_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainReboot (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_reboot_args args;
- 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_REBOOT,
- (xdrproc_t) xdr_remote_domain_reboot_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainDestroy (virDomainPtr domain)
{
int rv = -1;
@@ -2417,81 +2324,6 @@ done:
}
static int
-remoteDomainSetMaxMemory (virDomainPtr domain, unsigned long memory)
-{
- int rv = -1;
- remote_domain_set_max_memory_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.memory = memory;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MAX_MEMORY,
- (xdrproc_t) xdr_remote_domain_set_max_memory_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainSetMemory (virDomainPtr domain, unsigned long memory)
-{
- int rv = -1;
- remote_domain_set_memory_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.memory = memory;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY,
- (xdrproc_t) xdr_remote_domain_set_memory_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainSetMemoryFlags (virDomainPtr domain, unsigned long memory, unsigned int flags)
-{
- int rv = -1;
- remote_domain_set_memory_flags_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.memory = memory;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_MEMORY_FLAGS,
- (xdrproc_t) xdr_remote_domain_set_memory_flags_args,
- (char *) &args,
- (xdrproc_t) xdr_void,
- (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainSetMemoryParameters (virDomainPtr domain,
virMemoryParameterPtr params,
int nparams,
@@ -2861,129 +2693,6 @@ done:
}
static int
-remoteDomainSave (virDomainPtr domain, const char *to)
-{
- int rv = -1;
- remote_domain_save_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.to = (char *) to;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SAVE,
- (xdrproc_t) xdr_remote_domain_save_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainRestore (virConnectPtr conn, const char *from)
-{
- int rv = -1;
- remote_domain_restore_args args;
- struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
-
- args.from = (char *) from;
-
- if (call (conn, priv, 0, REMOTE_PROC_DOMAIN_RESTORE,
- (xdrproc_t) xdr_remote_domain_restore_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainCoreDump (virDomainPtr domain, const char *to, int flags)
-{
- int rv = -1;
- remote_domain_core_dump_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.to = (char *) to;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_CORE_DUMP,
- (xdrproc_t) xdr_remote_domain_core_dump_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainSetVcpus (virDomainPtr domain, unsigned int nvcpus)
-{
- int rv = -1;
- remote_domain_set_vcpus_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.nvcpus = nvcpus;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS,
- (xdrproc_t) xdr_remote_domain_set_vcpus_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainSetVcpusFlags (virDomainPtr domain, unsigned int nvcpus,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_set_vcpus_flags_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.nvcpus = nvcpus;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_VCPUS_FLAGS,
- (xdrproc_t) xdr_remote_domain_set_vcpus_flags_args,
- (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainGetVcpusFlags (virDomainPtr domain, unsigned int flags)
{
int rv = -1;
@@ -3696,155 +3405,6 @@ done:
}
static int
-remoteDomainUndefine (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_undefine_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_UNDEFINE,
- (xdrproc_t) xdr_remote_domain_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainAttachDevice (virDomainPtr domain, const char *xml)
-{
- int rv = -1;
- remote_domain_attach_device_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml = (char *) xml;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE,
- (xdrproc_t) xdr_remote_domain_attach_device_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainAttachDeviceFlags (virDomainPtr domain, const char *xml,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_attach_device_flags_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml = (char *) xml;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ATTACH_DEVICE_FLAGS,
- (xdrproc_t) xdr_remote_domain_attach_device_flags_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainDetachDevice (virDomainPtr domain, const char *xml)
-{
- int rv = -1;
- remote_domain_detach_device_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml = (char *) xml;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE,
- (xdrproc_t) xdr_remote_domain_detach_device_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainDetachDeviceFlags (virDomainPtr domain, const char *xml,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_detach_device_flags_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml = (char *) xml;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_DETACH_DEVICE_FLAGS,
- (xdrproc_t) xdr_remote_domain_detach_device_flags_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainUpdateDeviceFlags (virDomainPtr domain, const char *xml,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_update_device_flags_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.xml = (char *) xml;
- args.flags = flags;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_UPDATE_DEVICE_FLAGS,
- (xdrproc_t) xdr_remote_domain_update_device_flags_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainGetAutostart (virDomainPtr domain, int *autostart)
{
int rv = -1;
@@ -3870,30 +3430,6 @@ done:
return rv;
}
-static int
-remoteDomainSetAutostart (virDomainPtr domain, int autostart)
-{
- int rv = -1;
- remote_domain_set_autostart_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
- args.autostart = autostart;
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SET_AUTOSTART,
- (xdrproc_t) xdr_remote_domain_set_autostart_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static char *
remoteDomainGetSchedulerType (virDomainPtr domain, int *nparams)
{
@@ -4311,30 +3847,6 @@ done:
}
static int
-remoteDomainManagedSave (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_managed_save_args args;
- 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_MANAGED_SAVE,
- (xdrproc_t) xdr_remote_domain_managed_save_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteDomainHasManagedSaveImage (virDomainPtr domain, unsigned int flags)
{
int rv = -1;
@@ -4359,30 +3871,6 @@ done:
return rv;
}
-static int
-remoteDomainManagedSaveRemove (virDomainPtr domain, unsigned int flags)
-{
- int rv = -1;
- remote_domain_managed_save_remove_args args;
- 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_MANAGED_SAVE_REMOVE,
- (xdrproc_t) xdr_remote_domain_managed_save_remove_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -4762,75 +4250,6 @@ done:
return net;
}
-static int
-remoteNetworkUndefine (virNetworkPtr network)
-{
- int rv = -1;
- remote_network_undefine_args args;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_UNDEFINE,
- (xdrproc_t) xdr_remote_network_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteNetworkCreate (virNetworkPtr network)
-{
- int rv = -1;
- remote_network_create_args args;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_CREATE,
- (xdrproc_t) xdr_remote_network_create_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteNetworkDestroy (virNetworkPtr network)
-{
- int rv = -1;
- remote_network_destroy_args args;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_DESTROY,
- (xdrproc_t) xdr_remote_network_destroy_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static char *
remoteNetworkDumpXML (virNetworkPtr network, int flags)
{
@@ -4911,33 +4330,6 @@ done:
return rv;
}
-static int
-remoteNetworkSetAutostart (virNetworkPtr network, int autostart)
-{
- int rv = -1;
- remote_network_set_autostart_args args;
- struct private_data *priv = network->conn->networkPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_network (&args.net, network);
- args.autostart = autostart;
-
- if (call (network->conn, priv, 0, REMOTE_PROC_NETWORK_SET_AUTOSTART,
- (xdrproc_t) xdr_remote_network_set_autostart_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5299,79 +4691,6 @@ done:
return iface;
}
-static int
-remoteInterfaceUndefine (virInterfacePtr iface)
-{
- int rv = -1;
- remote_interface_undefine_args args;
- struct private_data *priv = iface->conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_interface (&args.iface, iface);
-
- if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_UNDEFINE,
- (xdrproc_t) xdr_remote_interface_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteInterfaceCreate (virInterfacePtr iface,
- unsigned int flags)
-{
- int rv = -1;
- remote_interface_create_args args;
- struct private_data *priv = iface->conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_interface (&args.iface, iface);
- args.flags = flags;
-
- if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_CREATE,
- (xdrproc_t) xdr_remote_interface_create_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteInterfaceDestroy (virInterfacePtr iface,
- unsigned int flags)
-{
- int rv = -1;
- remote_interface_destroy_args args;
- struct private_data *priv = iface->conn->interfacePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_interface (&args.iface, iface);
- args.flags = flags;
-
- if (call (iface->conn, priv, 0, REMOTE_PROC_INTERFACE_DESTROY,
- (xdrproc_t) xdr_remote_interface_destroy_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
/*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -5826,151 +5145,6 @@ done:
}
static int
-remoteStoragePoolUndefine (virStoragePoolPtr pool)
-{
- int rv = -1;
- remote_storage_pool_undefine_args args;
- 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_UNDEFINE,
- (xdrproc_t) xdr_remote_storage_pool_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolCreate (virStoragePoolPtr pool, unsigned int flags)
-{
- int rv = -1;
- remote_storage_pool_create_args args;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.flags = flags;
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_CREATE,
- (xdrproc_t) xdr_remote_storage_pool_create_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolBuild (virStoragePoolPtr pool,
- unsigned int flags)
-{
- int rv = -1;
- remote_storage_pool_build_args args;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.flags = flags;
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_BUILD,
- (xdrproc_t) xdr_remote_storage_pool_build_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolDestroy (virStoragePoolPtr pool)
-{
- int rv = -1;
- remote_storage_pool_destroy_args args;
- 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_DESTROY,
- (xdrproc_t) xdr_remote_storage_pool_destroy_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolDelete (virStoragePoolPtr pool,
- unsigned int flags)
-{
- int rv = -1;
- remote_storage_pool_delete_args args;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.flags = flags;
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_DELETE,
- (xdrproc_t) xdr_remote_storage_pool_delete_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStoragePoolRefresh (virStoragePoolPtr pool,
- unsigned int flags)
-{
- int rv = -1;
- remote_storage_pool_refresh_args args;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.flags = flags;
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_REFRESH,
- (xdrproc_t) xdr_remote_storage_pool_refresh_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
remoteStoragePoolGetInfo (virStoragePoolPtr pool, virStoragePoolInfoPtr info)
{
int rv = -1;
@@ -6056,31 +5230,6 @@ done:
}
static int
-remoteStoragePoolSetAutostart (virStoragePoolPtr pool, int autostart)
-{
- int rv = -1;
- remote_storage_pool_set_autostart_args args;
- struct private_data *priv = pool->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_pool (&args.pool, pool);
- args.autostart = autostart;
-
- if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_SET_AUTOSTART,
- (xdrproc_t) xdr_remote_storage_pool_set_autostart_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static int
remoteStoragePoolNumOfVolumes (virStoragePoolPtr pool)
{
int rv = -1;
@@ -6307,57 +5456,6 @@ done:
}
static int
-remoteStorageVolDelete (virStorageVolPtr vol,
- unsigned int flags)
-{
- int rv = -1;
- remote_storage_vol_delete_args args;
- struct private_data *priv = vol->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_vol (&args.vol, vol);
- args.flags = flags;
-
- if (call (vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_DELETE,
- (xdrproc_t) xdr_remote_storage_vol_delete_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteStorageVolWipe(virStorageVolPtr vol,
- unsigned int flags)
-{
- int rv = -1;
- remote_storage_vol_wipe_args args;
- struct private_data *priv = vol->conn->storagePrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_storage_vol(&args.vol, vol);
- args.flags = flags;
-
- if (call(vol->conn, priv, 0, REMOTE_PROC_STORAGE_VOL_WIPE,
- (xdrproc_t) xdr_remote_storage_vol_wipe_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static int
remoteStorageVolGetInfo (virStorageVolPtr vol, virStorageVolInfoPtr info)
{
int rv = -1;
@@ -6863,29 +5961,6 @@ done:
return dev;
}
-static int
-remoteNodeDeviceDestroy(virNodeDevicePtr dev)
-{
- int rv = -1;
- remote_node_device_destroy_args args;
- struct private_data *priv = dev->conn->devMonPrivateData;
-
- remoteDriverLock(priv);
-
- args.name = dev->name;
-
- if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DESTROY,
- (xdrproc_t) xdr_remote_node_device_destroy_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
/* ------------------------------------------------------------- */
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
@@ -6999,31 +6074,6 @@ done:
return net;
}
-
-static int
-remoteNWFilterUndefine (virNWFilterPtr nwfilter)
-{
- int rv = -1;
- remote_nwfilter_undefine_args args;
- struct private_data *priv = nwfilter->conn->nwfilterPrivateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_nwfilter (&args.nwfilter, nwfilter);
-
- if (call (nwfilter->conn, priv, 0, REMOTE_PROC_NWFILTER_UNDEFINE,
- (xdrproc_t) xdr_remote_nwfilter_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
static int
remoteListNWFilters (virConnectPtr conn, char **const names, int maxnames)
{
@@ -8252,7 +7302,7 @@ done:
}
static int
-remoteSecretListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
+remoteListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
{
int rv = -1;
int i;
@@ -8472,30 +7522,6 @@ done:
return rv;
}
-static int
-remoteSecretUndefine (virSecretPtr secret)
-{
- int rv = -1;
- remote_secret_undefine_args args;
- struct private_data *priv = secret->conn->secretPrivateData;
-
- remoteDriverLock (priv);
-
- make_nonnull_secret (&args.secret, secret);
-
- if (call (secret->conn, priv, 0, REMOTE_PROC_SECRET_UNDEFINE,
- (xdrproc_t) xdr_remote_secret_undefine_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock (priv);
- return rv;
-}
-
-
static struct private_stream_data *
remoteStreamOpen(virStreamPtr st,
unsigned int proc_nr,
@@ -9141,89 +8167,6 @@ done:
return rv;
}
-
-static int
-remoteDomainAbortJob (virDomainPtr domain)
-{
- int rv = -1;
- remote_domain_abort_job_args args;
- struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain (&args.dom, domain);
-
- if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_ABORT_JOB,
- (xdrproc_t) xdr_remote_domain_abort_job_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static int
-remoteDomainMigrateSetMaxDowntime(virDomainPtr domain,
- unsigned long long downtime,
- unsigned int flags)
-{
- struct private_data *priv = domain->conn->privateData;
- remote_domain_migrate_set_max_downtime_args args;
- int rv = -1;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain(&args.dom, domain);
- args.downtime = downtime;
- args.flags = flags;
-
- if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_DOWNTIME,
- (xdrproc_t) xdr_remote_domain_migrate_set_max_downtime_args,
- (char *) &args,
- (xdrproc_t) xdr_void,
- (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-static int
-remoteDomainMigrateSetMaxSpeed(virDomainPtr domain,
- unsigned long bandwidth,
- unsigned int flags)
-{
- struct private_data *priv = domain->conn->privateData;
- remote_domain_migrate_set_max_speed_args args;
- int rv = -1;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain(&args.dom, domain);
- args.bandwidth = bandwidth;
- args.flags = flags;
-
- if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_SET_MAX_SPEED,
- (xdrproc_t) xdr_remote_domain_migrate_set_max_speed_args,
- (char *) &args,
- (xdrproc_t) xdr_void,
- (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static virDomainSnapshotPtr
remoteDomainSnapshotCreateXML(virDomainPtr domain,
const char *xmlDesc,
@@ -9458,58 +8401,6 @@ done:
return snapshot;
}
-
-static int
-remoteDomainRevertToSnapshot (virDomainSnapshotPtr snapshot,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_revert_to_snapshot_args args;
- struct private_data *priv = snapshot->domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain_snapshot(&args.snap, snapshot);
- args.flags = flags;
-
- if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_REVERT_TO_SNAPSHOT,
- (xdrproc_t) xdr_remote_domain_revert_to_snapshot_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
-
-static int
-remoteDomainSnapshotDelete (virDomainSnapshotPtr snapshot,
- unsigned int flags)
-{
- int rv = -1;
- remote_domain_snapshot_delete_args args;
- struct private_data *priv = snapshot->domain->conn->privateData;
-
- remoteDriverLock(priv);
-
- make_nonnull_domain_snapshot(&args.snap, snapshot);
- args.flags = flags;
-
- if (call (snapshot->domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_DELETE,
- (xdrproc_t) xdr_remote_domain_snapshot_delete_args, (char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
-
-done:
- remoteDriverUnlock(priv);
- return rv;
-}
-
static int remoteDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr dom,
int eventID,
@@ -9770,6 +8661,9 @@ done:
return rv;
}
+#include "remote_client_bodies.c"
+#include "qemu_client_bodies.c"
+
/*----------------------------------------------------------------------*/
static struct remote_thread_call *
@@ -11389,7 +10283,7 @@ static virSecretDriver secret_driver = {
.open = remoteSecretOpen,
.close = remoteSecretClose,
.numOfSecrets = remoteSecretNumOfSecrets,
- .listSecrets = remoteSecretListSecrets,
+ .listSecrets = remoteListSecrets,
.lookupByUUID = remoteSecretLookupByUUID,
.lookupByUsage = remoteSecretLookupByUsage,
.defineXML = remoteSecretDefineXML,
--
1.7.0.4
More information about the libvir-list
mailing list