Skip to content

L
libvirt

openeuler / libvirt

通知 3
Star 0
Fork 0
L
libvirt
提交 b5041a49 编写于 作者: M Matthias Bolte
浏览文件
操作

remote generator, client: Handle functions that return lists

上级 8921799a
隐藏空白更改
内联 并排
Showing with 858 addition and 786 deletion
cfg.mk
浏览文件 @ b5041a49
...@@ -590,6 +590,9 @@ exclude_file_name_regexp--sc_avoid_write = \ ...@@ -590,6 +590,9 @@ exclude_file_name_regexp--sc_avoid_write = \
exclude_file_name_regexp--sc_bindtextdomain = ^(tests|examples)/ exclude_file_name_regexp--sc_bindtextdomain = ^(tests|examples)/
exclude_file_name_regexp--sc_libvirt_unmarked_diagnostics = \
^daemon/remote_generator\.pl$$
exclude_file_name_regexp--sc_po_check = ^(docs/|daemon/remote_generator\.pl$$) exclude_file_name_regexp--sc_po_check = ^(docs/|daemon/remote_generator\.pl$$)
exclude_file_name_regexp--sc_prohibit_VIR_ERR_NO_MEMORY = \ exclude_file_name_regexp--sc_prohibit_VIR_ERR_NO_MEMORY = \
...@@ -621,6 +624,9 @@ exclude_file_name_regexp--sc_prohibit_gethostname = ^src/util/util\.c$$ ...@@ -621,6 +624,9 @@ exclude_file_name_regexp--sc_prohibit_gethostname = ^src/util/util\.c$$
exclude_file_name_regexp--sc_prohibit_gettext_noop = ^docs/ exclude_file_name_regexp--sc_prohibit_gettext_noop = ^docs/
exclude_file_name_regexp--sc_prohibit_newline_at_end_of_diagnostic = \
^daemon/remote_generator\.pl$$
exclude_file_name_regexp--sc_prohibit_nonreentrant = \ exclude_file_name_regexp--sc_prohibit_nonreentrant = \
^((po|docs|tests)/|tools/(virsh|console)\.c$$) ^((po|docs|tests)/|tools/(virsh|console)\.c$$)
......
daemon/remote_generator.pl
浏览文件 @ b5041a49
...@@ -758,29 +758,16 @@ elsif ($opt_k) { ...@@ -758,29 +758,16 @@ elsif ($opt_k) {
"NWFilterDefineXML", # public API and XDR protocol mismatch "NWFilterDefineXML", # public API and XDR protocol mismatch
"DomainMigratePerform", "DomainMigratePerform",
"DomainMigrateFinish2", "DomainMigrateFinish2",
"DomainSnapshotListNames",
"FindStoragePoolSources", "FindStoragePoolSources",
"IsSecure", "IsSecure",
"ListDefinedDomains",
"ListDefinedInterfaces",
"ListNWFilters",
"SupportsFeature", "SupportsFeature",
"NodeListDevices",
"NodeGetCellsFreeMemory", "NodeGetCellsFreeMemory",
"ListDefinedNetworks",
"StoragePoolListVolumes",
"ListDomains", "ListDomains",
"ListStoragePools",
"SecretSetValue", "SecretSetValue",
"GetURI", "GetURI",
"ListInterfaces",
"ListDefinedStoragePools",
"NodeDeviceDettach", "NodeDeviceDettach",
"ListNetworks",
"NodeDeviceListCaps",
"NodeDeviceReset", "NodeDeviceReset",
"NodeDeviceReAttach", "NodeDeviceReAttach",
"ListSecrets",
"DomainBlockPeek", "DomainBlockPeek",
"DomainCreateWithFlags", "DomainCreateWithFlags",
...@@ -928,8 +915,9 @@ elsif ($opt_k) { ...@@ -928,8 +915,9 @@ elsif ($opt_k) {
# fix priv_name for the NumOf* functions # fix priv_name for the NumOf* functions
if ($priv_name eq "privateData" and if ($priv_name eq "privateData" and
!($call->{ProcName} =~ m/Domains/) and !($call->{ProcName} =~ m/(Domains|DomainSnapshot)/) and
$call->{ProcName} =~ m/NumOf(Defined|Domain)*(\S+)s/) { ($call->{ProcName} =~ m/NumOf(Defined|Domain)*(\S+)s/ or
$call->{ProcName} =~ m/List(Defined|Domain)*(\S+)s/)) {
my $prefix = lc $2; my $prefix = lc $2;
$prefix =~ s/(pool|vol)$//; $prefix =~ s/(pool|vol)$//;
$priv_name = "${prefix}PrivateData"; $priv_name = "${prefix}PrivateData";
...@@ -940,6 +928,11 @@ elsif ($opt_k) { ...@@ -940,6 +928,11 @@ elsif ($opt_k) {
my $call_ret = "&ret"; my $call_ret = "&ret";
my $single_ret_var = "int rv = -1"; my $single_ret_var = "int rv = -1";
my $single_ret_type = "int"; my $single_ret_type = "int";
my $single_ret_as_list = 0;
my $single_ret_list_error_msg_type = "undefined";
my $single_ret_list_name = "undefined";
my $single_ret_list_max_var = "undefined";
my $single_ret_list_max_define = "undefined";
my $multi_ret = 0; my $multi_ret = 0;
if ($call->{ret} ne "void" and if ($call->{ret} ne "void" and
...@@ -964,6 +957,30 @@ elsif ($opt_k) { ...@@ -964,6 +957,30 @@ elsif ($opt_k) {
} else { } else {
die "unhandled type for multi-return-value: $ret_member"; die "unhandled type for multi-return-value: $ret_member";
} }
} elsif ($ret_member =~ m/remote_nonnull_string (\S+)<(\S+)>;/) {
$single_ret_as_list = 1;
$single_ret_list_name = $1;
$single_ret_list_max_var = "max$1";
$single_ret_list_max_define = $2;
my $first_arg = shift(@args_list);
my $second_arg;
if ($call->{ProcName} eq "NodeListDevices") {
$second_arg = shift(@args_list);
}
unshift(@args_list, "char **const $1");
if (defined $second_arg) {
unshift(@args_list, $second_arg);
}
unshift(@args_list, $first_arg);
push(@ret_list, "rv = ret.$1.$1_len;");
$single_ret_var = "int rv = -1";
$single_ret_type = "int";
} elsif ($ret_member =~ m/remote_nonnull_string (\S+);/) { } elsif ($ret_member =~ m/remote_nonnull_string (\S+);/) {
push(@ret_list, "rv = ret.$1;"); push(@ret_list, "rv = ret.$1;");
$single_ret_var = "char *rv = NULL"; $single_ret_var = "char *rv = NULL";
...@@ -1062,9 +1079,23 @@ elsif ($opt_k) { ...@@ -1062,9 +1079,23 @@ elsif ($opt_k) {
print " $var;\n"; print " $var;\n";
} }
if ($single_ret_as_list) {
print " int i;\n";
}
print "\n"; print "\n";
print " remoteDriverLock(priv);\n"; print " remoteDriverLock(priv);\n";
if ($single_ret_as_list) {
print "\n";
print " if ($single_ret_list_max_var > $single_ret_list_max_define) {\n";
print " remoteError(VIR_ERR_RPC,\n";
print " _(\"too many remote ${single_ret_list_error_msg_type}s: %d > %d\"),\n";
print " $single_ret_list_max_var, $single_ret_list_max_define);\n";
print " goto done;\n";
print " }\n";
}
if (@setters_list) { if (@setters_list) {
print "\n"; print "\n";
print " "; print " ";
...@@ -1088,6 +1119,32 @@ elsif ($opt_k) { ...@@ -1088,6 +1119,32 @@ elsif ($opt_k) {
print " goto done;\n"; print " goto done;\n";
print "\n"; print "\n";
if ($single_ret_as_list) {
print " if (ret.$single_ret_list_name.${single_ret_list_name}_len > $single_ret_list_max_var) {\n";
print " remoteError(VIR_ERR_RPC,\n";
print " _(\"too many remote ${single_ret_list_error_msg_type}s: %d > %d\"),\n";
print " ret.$single_ret_list_name.${single_ret_list_name}_len, $single_ret_list_max_var);\n";
print " goto cleanup;\n";
print " }\n";
print "\n";
print " /* This call is caller-frees (although that isn't clear from\n";
print " * the documentation). However xdr_free will free up both the\n";
print " * names and the list of pointers, so we have to strdup the\n";
print " * names here. */\n";
print " for (i = 0; i < ret.$single_ret_list_name.${single_ret_list_name}_len; ++i) {\n";
print " ${single_ret_list_name}[i] = strdup(ret.$single_ret_list_name.${single_ret_list_name}_val[i]);\n";
print "\n";
print " if (${single_ret_list_name}[i] == NULL) {\n";
print " for (--i; i >= 0; --i)\n";
print " VIR_FREE(${single_ret_list_name}[i]);\n";
print "\n";
print " virReportOOMError();\n";
print " goto cleanup;\n";
print " }\n";
print " }\n";
print "\n";
}
if (@ret_list) { if (@ret_list) {
print " "; print " ";
print join("\n ", @ret_list); print join("\n ", @ret_list);
...@@ -1098,6 +1155,12 @@ elsif ($opt_k) { ...@@ -1098,6 +1155,12 @@ elsif ($opt_k) {
print " rv = 0;\n"; print " rv = 0;\n";
} }
if ($single_ret_as_list) {
print "\n";
print "cleanup:\n";
print " xdr_free((xdrproc_t)xdr_remote_$call->{name}_ret, (char *)&ret);\n";
}
print "\n"; print "\n";
print "done:\n"; print "done:\n";
print " remoteDriverUnlock(priv);\n"; print " remoteDriverUnlock(priv);\n";
......
po/POTFILES.in
浏览文件 @ b5041a49
...@@ -64,6 +64,7 @@ src/qemu/qemu_monitor.c ...@@ -64,6 +64,7 @@ src/qemu/qemu_monitor.c
src/qemu/qemu_monitor_json.c src/qemu/qemu_monitor_json.c
src/qemu/qemu_monitor_text.c src/qemu/qemu_monitor_text.c
src/qemu/qemu_process.c src/qemu/qemu_process.c
src/remote/remote_client_bodies.c
src/remote/remote_driver.c src/remote/remote_driver.c
src/secret/secret_driver.c src/secret/secret_driver.c
src/security/security_apparmor.c src/security/security_apparmor.c
......
src/remote/remote_client_bodies.c
浏览文件 @ b5041a49
...@@ -1330,7 +1330,67 @@ done: ...@@ -1330,7 +1330,67 @@ done:
return rv; return rv;
} }
/* remoteDispatchDomainSnapshotListNames has to be implemented manually */ static int
remoteDomainSnapshotListNames(virDomainPtr dom, char **const names, int maxnames, unsigned int flags)
{
int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_snapshot_list_names_args args;
remote_domain_snapshot_list_names_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX);
goto done;
}
make_nonnull_domain(&args.dom, dom);
args.maxnames = maxnames;
args.flags = flags;
memset(&ret, 0, sizeof ret);
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES,
(xdrproc_t)xdr_remote_domain_snapshot_list_names_args, (char *)&args,
(xdrproc_t)xdr_remote_domain_snapshot_list_names_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_domain_snapshot_list_names_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static virDomainSnapshotPtr static virDomainSnapshotPtr
remoteDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags) remoteDomainSnapshotLookupByName(virDomainPtr dom, const char *name, unsigned int flags)
...@@ -1875,25 +1935,547 @@ done: ...@@ -1875,25 +1935,547 @@ done:
/* remoteDispatchIsSecure has to be implemented manually */ /* remoteDispatchIsSecure has to be implemented manually */
/* remoteDispatchListDefinedDomains has to be implemented manually */ static int
remoteListDefinedDomains(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->privateData;
remote_list_defined_domains_args args;
remote_list_defined_domains_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_DOMAIN_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_DOMAINS,
(xdrproc_t)xdr_remote_list_defined_domains_args, (char *)&args,
(xdrproc_t)xdr_remote_list_defined_domains_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* remoteDispatchListDefinedInterfaces has to be implemented manually */ /* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
/* remoteDispatchListDefinedNetworks has to be implemented manually */ if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
/* remoteDispatchListDefinedStoragePools has to be implemented manually */ virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_defined_domains_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedInterfaces(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->interfacePrivateData;
remote_list_defined_interfaces_args args;
remote_list_defined_interfaces_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_INTERFACES,
(xdrproc_t)xdr_remote_list_defined_interfaces_args, (char *)&args,
(xdrproc_t)xdr_remote_list_defined_interfaces_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_defined_interfaces_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedNetworks(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->networkPrivateData;
remote_list_defined_networks_args args;
remote_list_defined_networks_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_NETWORKS,
(xdrproc_t)xdr_remote_list_defined_networks_args, (char *)&args,
(xdrproc_t)xdr_remote_list_defined_networks_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_defined_networks_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedStoragePools(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->storagePrivateData;
remote_list_defined_storage_pools_args args;
remote_list_defined_storage_pools_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_STORAGE_POOL_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS,
(xdrproc_t)xdr_remote_list_defined_storage_pools_args, (char *)&args,
(xdrproc_t)xdr_remote_list_defined_storage_pools_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_defined_storage_pools_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/* remoteDispatchListDomains has to be implemented manually */ /* remoteDispatchListDomains has to be implemented manually */
/* remoteDispatchListInterfaces has to be implemented manually */ static int
remoteListInterfaces(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->interfacePrivateData;
remote_list_interfaces_args args;
remote_list_interfaces_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_INTERFACE_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_INTERFACES,
(xdrproc_t)xdr_remote_list_interfaces_args, (char *)&args,
(xdrproc_t)xdr_remote_list_interfaces_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_interfaces_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListNetworks(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->networkPrivateData;
remote_list_networks_args args;
remote_list_networks_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_NETWORKS,
(xdrproc_t)xdr_remote_list_networks_args, (char *)&args,
(xdrproc_t)xdr_remote_list_networks_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_networks_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListNWFilters(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->nwfilterPrivateData;
remote_list_nwfilters_args args;
remote_list_nwfilters_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_NWFILTER_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_NWFILTER_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_NWFILTERS,
(xdrproc_t)xdr_remote_list_nwfilters_args, (char *)&args,
(xdrproc_t)xdr_remote_list_nwfilters_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_nwfilters_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListSecrets(virConnectPtr conn, char **const uuids, int maxuuids)
{
int rv = -1;
struct private_data *priv = conn->secretPrivateData;
remote_list_secrets_args args;
remote_list_secrets_ret ret;
int i;
remoteDriverLock(priv);
if (maxuuids > REMOTE_SECRET_UUID_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined uuids: %d > %d"),
maxuuids, REMOTE_SECRET_UUID_LIST_MAX);
goto done;
}
args.maxuuids = maxuuids;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_SECRETS,
(xdrproc_t)xdr_remote_list_secrets_args, (char *)&args,
(xdrproc_t)xdr_remote_list_secrets_ret, (char *)&ret) == -1)
goto done;
if (ret.uuids.uuids_len > maxuuids) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.uuids.uuids_len, maxuuids);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.uuids.uuids_len; ++i) {
uuids[i] = strdup(ret.uuids.uuids_val[i]);
/* remoteDispatchListNetworks has to be implemented manually */ if (uuids[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(uuids[i]);
/* remoteDispatchListNWFilters has to be implemented manually */ virReportOOMError();
goto cleanup;
}
}
/* remoteDispatchListSecrets has to be implemented manually */ rv = ret.uuids.uuids_len;
/* remoteDispatchListStoragePools has to be implemented manually */ cleanup:
xdr_free((xdrproc_t)xdr_remote_list_secrets_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListStoragePools(virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = conn->storagePrivateData;
remote_list_storage_pools_args args;
remote_list_storage_pools_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_STORAGE_POOL_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS,
(xdrproc_t)xdr_remote_list_storage_pools_args, (char *)&args,
(xdrproc_t)xdr_remote_list_storage_pools_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_list_storage_pools_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int static int
remoteNetworkCreate(virNetworkPtr net) remoteNetworkCreate(virNetworkPtr net)
...@@ -2310,7 +2892,66 @@ done: ...@@ -2310,7 +2892,66 @@ done:
/* remoteDispatchNodeDeviceGetParent has to be implemented manually */ /* remoteDispatchNodeDeviceGetParent has to be implemented manually */
/* remoteDispatchNodeDeviceListCaps has to be implemented manually */ static int
remoteNodeDeviceListCaps(virNodeDevicePtr dev, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = dev->conn->devMonPrivateData;
remote_node_device_list_caps_args args;
remote_node_device_list_caps_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_NODE_DEVICE_CAPS_LIST_MAX);
goto done;
}
args.name = dev->name;
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LIST_CAPS,
(xdrproc_t)xdr_remote_node_device_list_caps_args, (char *)&args,
(xdrproc_t)xdr_remote_node_device_list_caps_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_node_device_list_caps_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static virNodeDevicePtr static virNodeDevicePtr
remoteNodeDeviceLookupByName(virConnectPtr conn, const char *name) remoteNodeDeviceLookupByName(virConnectPtr conn, const char *name)
...@@ -2427,7 +3068,67 @@ done: ...@@ -2427,7 +3068,67 @@ done:
/* remoteDispatchNodeGetSecurityModel has to be implemented manually */ /* remoteDispatchNodeGetSecurityModel has to be implemented manually */
/* remoteDispatchNodeListDevices has to be implemented manually */ static int
remoteNodeListDevices(virConnectPtr conn, const char *cap, char **const names, int maxnames, unsigned int flags)
{
int rv = -1;
struct private_data *priv = conn->devMonPrivateData;
remote_node_list_devices_args args;
remote_node_list_devices_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_NODE_DEVICE_NAME_LIST_MAX);
goto done;
}
args.cap = cap ? (char **)&cap : NULL;
args.maxnames = maxnames;
args.flags = flags;
memset(&ret, 0, sizeof ret);
if (call(conn, priv, 0, REMOTE_PROC_NODE_LIST_DEVICES,
(xdrproc_t)xdr_remote_node_list_devices_args, (char *)&args,
(xdrproc_t)xdr_remote_node_list_devices_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_node_list_devices_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int static int
remoteNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags) remoteNodeNumOfDevices(virConnectPtr conn, const char *cap, unsigned int flags)
...@@ -3218,7 +3919,66 @@ done: ...@@ -3218,7 +3919,66 @@ done:
return rv; return rv;
} }
/* remoteDispatchStoragePoolListVolumes has to be implemented manually */ static int
remoteStoragePoolListVolumes(virStoragePoolPtr pool, char **const names, int maxnames)
{
int rv = -1;
struct private_data *priv = pool->conn->storagePrivateData;
remote_storage_pool_list_volumes_args args;
remote_storage_pool_list_volumes_ret ret;
int i;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote undefined names: %d > %d"),
maxnames, REMOTE_STORAGE_VOL_NAME_LIST_MAX);
goto done;
}
make_nonnull_storage_pool(&args.pool, pool);
args.maxnames = maxnames;
memset(&ret, 0, sizeof ret);
if (call(pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES,
(xdrproc_t)xdr_remote_storage_pool_list_volumes_args, (char *)&args,
(xdrproc_t)xdr_remote_storage_pool_list_volumes_ret, (char *)&ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote undefineds: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here. */
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup(ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free((xdrproc_t)xdr_remote_storage_pool_list_volumes_ret, (char *)&ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static virStoragePoolPtr static virStoragePoolPtr
remoteStoragePoolLookupByName(virConnectPtr conn, const char *name) remoteStoragePoolLookupByName(virConnectPtr conn, const char *name)
......
src/remote/remote_driver.c
浏览文件 @ b5041a49
...@@ -2606,65 +2606,6 @@ done: ...@@ -2606,65 +2606,6 @@ done:
return ddom; return ddom;
} }
static int
remoteListDefinedDomains (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_defined_domains_args args;
remote_list_defined_domains_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_DOMAIN_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote domain names: %d > %d"),
maxnames, REMOTE_DOMAIN_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_DOMAINS,
(xdrproc_t) xdr_remote_list_defined_domains_args, (char *) &args,
(xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote domain names: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_defined_domains_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int static int
remoteDomainCreate (virDomainPtr domain) remoteDomainCreate (virDomainPtr domain)
{ {
...@@ -3122,125 +3063,6 @@ remoteNetworkClose(virConnectPtr conn) ...@@ -3122,125 +3063,6 @@ remoteNetworkClose(virConnectPtr conn)
return remoteGenericClose(conn, &conn->networkPrivateData); return remoteGenericClose(conn, &conn->networkPrivateData);
} }
static int
remoteListNetworks (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_networks_args args;
remote_list_networks_ret ret;
struct private_data *priv = conn->networkPrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote networks: %d > %d"),
maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_NETWORKS,
(xdrproc_t) xdr_remote_list_networks_args, (char *) &args,
(xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote networks: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_networks_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedNetworks (virConnectPtr conn,
char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_defined_networks_args args;
remote_list_defined_networks_ret ret;
struct private_data *priv = conn->networkPrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_NETWORK_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote networks: %d > %d"),
maxnames, REMOTE_NETWORK_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_NETWORKS,
(xdrproc_t) xdr_remote_list_defined_networks_args, (char *) &args,
(xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote networks: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_defined_networks_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1) static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
...@@ -3255,124 +3077,6 @@ remoteInterfaceClose(virConnectPtr conn) ...@@ -3255,124 +3077,6 @@ remoteInterfaceClose(virConnectPtr conn)
return remoteGenericClose(conn, &conn->interfacePrivateData); return remoteGenericClose(conn, &conn->interfacePrivateData);
} }
static int
remoteListInterfaces (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_interfaces_args args;
remote_list_interfaces_ret ret;
struct private_data *priv = conn->interfacePrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_INTERFACE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote interfaces: %d > %d"),
maxnames, REMOTE_INTERFACE_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_INTERFACES,
(xdrproc_t) xdr_remote_list_interfaces_args, (char *) &args,
(xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote interfaces: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_interfaces_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedInterfaces (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_defined_interfaces_args args;
remote_list_defined_interfaces_ret ret;
struct private_data *priv = conn->interfacePrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote interfaces: %d > %d"),
maxnames, REMOTE_DEFINED_INTERFACE_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_INTERFACES,
(xdrproc_t) xdr_remote_list_defined_interfaces_args, (char *) &args,
(xdrproc_t) xdr_remote_list_defined_interfaces_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote interfaces: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_defined_interfaces_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1) static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
...@@ -3387,117 +3091,6 @@ remoteStorageClose(virConnectPtr conn) ...@@ -3387,117 +3091,6 @@ remoteStorageClose(virConnectPtr conn)
return remoteGenericClose(conn, &conn->storagePrivateData); return remoteGenericClose(conn, &conn->storagePrivateData);
} }
static int
remoteListStoragePools (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_storage_pools_args args;
remote_list_storage_pools_ret ret;
struct private_data *priv = conn->storagePrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage pools requested"));
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_STORAGE_POOLS,
(xdrproc_t) xdr_remote_list_storage_pools_args, (char *) &args,
(xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage pools received"));
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_storage_pools_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteListDefinedStoragePools (virConnectPtr conn,
char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_defined_storage_pools_args args;
remote_list_defined_storage_pools_ret ret;
struct private_data *priv = conn->storagePrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_POOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage pools requested"));
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_DEFINED_STORAGE_POOLS,
(xdrproc_t) xdr_remote_list_defined_storage_pools_args, (char *) &args,
(xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage pools received"));
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_defined_storage_pools_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static char * static char *
remoteFindStoragePoolSources (virConnectPtr conn, remoteFindStoragePoolSources (virConnectPtr conn,
const char *type, const char *type,
...@@ -3543,62 +3136,6 @@ done: ...@@ -3543,62 +3136,6 @@ done:
return rv; return rv;
} }
static int
remoteStoragePoolListVolumes (virStoragePoolPtr pool, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_storage_pool_list_volumes_args args;
remote_storage_pool_list_volumes_ret ret;
struct private_data *priv = pool->conn->storagePrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_STORAGE_VOL_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage volumes requested"));
goto done;
}
args.maxnames = maxnames;
make_nonnull_storage_pool(&args.pool, pool);
memset (&ret, 0, sizeof ret);
if (call (pool->conn, priv, 0, REMOTE_PROC_STORAGE_POOL_LIST_VOLUMES,
(xdrproc_t) xdr_remote_storage_pool_list_volumes_args, (char *) &args,
(xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC, "%s", _("too many storage volumes received"));
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_storage_pool_list_volumes_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static virDrvOpenStatus ATTRIBUTE_NONNULL (1) static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
...@@ -3613,66 +3150,6 @@ remoteDevMonClose(virConnectPtr conn) ...@@ -3613,66 +3150,6 @@ remoteDevMonClose(virConnectPtr conn)
return remoteGenericClose(conn, &conn->devMonPrivateData); return remoteGenericClose(conn, &conn->devMonPrivateData);
} }
static int remoteNodeListDevices(virConnectPtr conn,
const char *cap,
char **const names,
int maxnames,
unsigned int flags)
{
int rv = -1;
int i;
remote_node_list_devices_args args;
remote_node_list_devices_ret ret;
struct private_data *priv = conn->devMonPrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_NODE_DEVICE_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC, "%s", _("too many device names requested"));
goto done;
}
args.cap = cap ? (char **)&cap : NULL;
args.maxnames = maxnames;
args.flags = flags;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_NODE_LIST_DEVICES,
(xdrproc_t) xdr_remote_node_list_devices_args, (char *) &args,
(xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC, "%s", _("too many device names received"));
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_node_list_devices_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev) static char *remoteNodeDeviceGetParent(virNodeDevicePtr dev)
{ {
char *rv = NULL; char *rv = NULL;
...@@ -3699,63 +3176,6 @@ done: ...@@ -3699,63 +3176,6 @@ done:
return rv; return rv;
} }
static int remoteNodeDeviceListCaps(virNodeDevicePtr dev,
char **const names,
int maxnames)
{
int rv = -1;
int i;
remote_node_device_list_caps_args args;
remote_node_device_list_caps_ret ret;
struct private_data *priv = dev->conn->devMonPrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_NODE_DEVICE_CAPS_LIST_MAX) {
remoteError(VIR_ERR_RPC, "%s", _("too many capability names requested"));
goto done;
}
args.maxnames = maxnames;
args.name = dev->name;
memset (&ret, 0, sizeof ret);
if (call (dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_LIST_CAPS,
(xdrproc_t) xdr_remote_node_device_list_caps_args, (char *) &args,
(xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC, "%s", _("too many capability names received"));
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_node_device_list_caps_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int static int
remoteNodeDeviceDettach (virNodeDevicePtr dev) remoteNodeDeviceDettach (virNodeDevicePtr dev)
{ {
...@@ -3872,65 +3292,6 @@ done: ...@@ -3872,65 +3292,6 @@ done:
return net; return net;
} }
static int
remoteListNWFilters (virConnectPtr conn, char **const names, int maxnames)
{
int rv = -1;
int i;
remote_list_nwfilters_args args;
remote_list_nwfilters_ret ret;
struct private_data *priv = conn->nwfilterPrivateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_NWFILTER_NAME_LIST_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote nwfilters: %d > %d"),
maxnames, REMOTE_NWFILTER_NAME_LIST_MAX);
goto done;
}
args.maxnames = maxnames;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_NWFILTERS,
(xdrproc_t) xdr_remote_list_nwfilters_args, (char *) &args,
(xdrproc_t) xdr_remote_list_nwfilters_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote nwfilters: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_nwfilters_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
static int static int
...@@ -4937,62 +4298,6 @@ remoteSecretClose (virConnectPtr conn) ...@@ -4937,62 +4298,6 @@ remoteSecretClose (virConnectPtr conn)
return remoteGenericClose(conn, &conn->secretPrivateData); return remoteGenericClose(conn, &conn->secretPrivateData);
} }
static int
remoteListSecrets (virConnectPtr conn, char **uuids, int maxuuids)
{
int rv = -1;
int i;
remote_list_secrets_args args;
remote_list_secrets_ret ret;
struct private_data *priv = conn->secretPrivateData;
remoteDriverLock(priv);
if (maxuuids > REMOTE_SECRET_UUID_LIST_MAX) {
remoteError(VIR_ERR_RPC, _("too many remote secret UUIDs: %d > %d"),
maxuuids, REMOTE_SECRET_UUID_LIST_MAX);
goto done;
}
args.maxuuids = maxuuids;
memset (&ret, 0, sizeof ret);
if (call (conn, priv, 0, REMOTE_PROC_LIST_SECRETS,
(xdrproc_t) xdr_remote_list_secrets_args, (char *) &args,
(xdrproc_t) xdr_remote_list_secrets_ret, (char *) &ret) == -1)
goto done;
if (ret.uuids.uuids_len > maxuuids) {
remoteError(VIR_ERR_RPC, _("too many remote secret UUIDs: %d > %d"),
ret.uuids.uuids_len, maxuuids);
goto cleanup;
}
/* This call is caller-frees. However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.uuids.uuids_len; ++i) {
uuids[i] = strdup (ret.uuids.uuids_val[i]);
if (uuids[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(uuids[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.uuids.uuids_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_list_secrets_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int static int
remoteSecretSetValue (virSecretPtr secret, const unsigned char *value, remoteSecretSetValue (virSecretPtr secret, const unsigned char *value,
size_t value_size, unsigned int flags) size_t value_size, unsigned int flags)
...@@ -5626,69 +4931,6 @@ done: ...@@ -5626,69 +4931,6 @@ done:
return cpu; return cpu;
} }
static int
remoteDomainSnapshotListNames (virDomainPtr domain, char **const names,
int maxnames, unsigned int flags)
{
int rv = -1;
int i;
remote_domain_snapshot_list_names_args args;
remote_domain_snapshot_list_names_ret ret;
struct private_data *priv = domain->conn->privateData;
remoteDriverLock(priv);
if (maxnames > REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX) {
remoteError(VIR_ERR_RPC,
_("too many remote domain snapshot names: %d > %d"),
maxnames, REMOTE_DOMAIN_SNAPSHOT_LIST_NAMES_MAX);
goto done;
}
make_nonnull_domain(&args.dom, domain);
args.maxnames = maxnames;
args.flags = flags;
memset (&ret, 0, sizeof ret);
if (call (domain->conn, priv, 0, REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_NAMES,
(xdrproc_t) xdr_remote_domain_snapshot_list_names_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret) == -1)
goto done;
if (ret.names.names_len > maxnames) {
remoteError(VIR_ERR_RPC,
_("too many remote domain snapshots: %d > %d"),
ret.names.names_len, maxnames);
goto cleanup;
}
/* This call is caller-frees (although that isn't clear from
* the documentation). However xdr_free will free up both the
* names and the list of pointers, so we have to strdup the
* names here.
*/
for (i = 0; i < ret.names.names_len; ++i) {
names[i] = strdup (ret.names.names_val[i]);
if (names[i] == NULL) {
for (--i; i >= 0; --i)
VIR_FREE(names[i]);
virReportOOMError();
goto cleanup;
}
}
rv = ret.names.names_len;
cleanup:
xdr_free ((xdrproc_t) xdr_remote_domain_snapshot_list_names_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int remoteDomainEventRegisterAny(virConnectPtr conn, static int remoteDomainEventRegisterAny(virConnectPtr conn,
virDomainPtr dom, virDomainPtr dom,
int eventID, int eventID,
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或