[libvirt] [PATCH 15/22] remote generator, client: Handle simple remote driver functions

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