Skip to content

L
libvirt

openeuler / libvirt

通知 3
Star 0
Fork 0
L
libvirt

体验新版 GitCode，发现更多精彩内容 >>

提交 42b85f17 编写于 作者: M Martin Kletzander
浏览文件
操作

remote: Generate what's possible 

Since gendisplatch can now generate "modern" *ListAll* functions, let
them all be generated.
Signed-off-by: NMartin Kletzander <mkletzan@redhat.com>
上级 5b7d0980
展开全部 隐藏空白更改
内联 并排
Showing with 20 addition and 1273 deletion
daemon/remote.c
浏览文件 @ 42b85f17
此差异已折叠。
src/remote/remote_driver.c
浏览文件 @ 42b85f17
......@@ -1626,71 +1626,6 @@ remoteConnectListDomains(virConnectPtr conn, int *ids, int maxids)
return rv;
}
static int
remoteConnectListAllDomains(virConnectPtr conn,
virDomainPtr **domains,
unsigned int flags)
{
int rv = -1;
size_t i;
virDomainPtr *doms = NULL;
remote_connect_list_all_domains_args args;
remote_connect_list_all_domains_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!domains;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS,
(xdrproc_t) xdr_remote_connect_list_all_domains_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_domains_ret,
(char *) &ret) == -1)
goto done;
if (ret.domains.domains_len > REMOTE_DOMAIN_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many domains '%d' for limit '%d'"),
ret.domains.domains_len, REMOTE_DOMAIN_LIST_MAX);
goto cleanup;
}
if (domains) {
if (VIR_ALLOC_N(doms, ret.domains.domains_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.domains.domains_len; i++) {
doms[i] = get_nonnull_domain(conn, ret.domains.domains_val[i]);
if (!doms[i])
goto cleanup;
}
*domains = doms;
doms = NULL;
}
rv = ret.ret;
cleanup:
if (doms) {
for (i = 0; i < ret.domains.domains_len; i++)
virObjectUnref(doms[i]);
VIR_FREE(doms);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_domains_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteDeserializeDomainDiskErrors(remote_domain_disk_error *ret_errors_val,
u_int ret_errors_len,
......@@ -2945,71 +2880,6 @@ static int remoteDomainGetCPUStats(virDomainPtr domain,
return rv;
}
static int
remoteConnectListAllNetworks(virConnectPtr conn,
virNetworkPtr **nets,
unsigned int flags)
{
int rv = -1;
size_t i;
virNetworkPtr *tmp_nets = NULL;
remote_connect_list_all_networks_args args;
remote_connect_list_all_networks_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!nets;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS,
(xdrproc_t) xdr_remote_connect_list_all_networks_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_networks_ret,
(char *) &ret) == -1)
goto done;
if (ret.nets.nets_len > REMOTE_NETWORK_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many networks '%d' for limit '%d'"),
ret.nets.nets_len, REMOTE_NETWORK_LIST_MAX);
goto cleanup;
}
if (nets) {
if (VIR_ALLOC_N(tmp_nets, ret.nets.nets_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.nets.nets_len; i++) {
tmp_nets[i] = get_nonnull_network(conn, ret.nets.nets_val[i]);
if (!tmp_nets[i])
goto cleanup;
}
*nets = tmp_nets;
tmp_nets = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_nets) {
for (i = 0; i < ret.nets.nets_len; i++)
virObjectUnref(tmp_nets[i]);
VIR_FREE(tmp_nets);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_networks_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteConnectNetworkEventRegisterAny(virConnectPtr conn,
......@@ -3202,267 +3072,6 @@ remoteConnectDomainQemuMonitorEventDeregister(virConnectPtr conn,
return rv;
}
static int
remoteConnectListAllInterfaces(virConnectPtr conn,
virInterfacePtr **ifaces,
unsigned int flags)
{
int rv = -1;
size_t i;
virInterfacePtr *tmp_ifaces = NULL;
remote_connect_list_all_interfaces_args args;
remote_connect_list_all_interfaces_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!ifaces;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES,
(xdrproc_t) xdr_remote_connect_list_all_interfaces_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_interfaces_ret,
(char *) &ret) == -1)
goto done;
if (ret.ifaces.ifaces_len > REMOTE_INTERFACE_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many interfaces '%d' for limit '%d'"),
ret.ifaces.ifaces_len, REMOTE_INTERFACE_LIST_MAX);
goto cleanup;
}
if (ifaces) {
if (VIR_ALLOC_N(tmp_ifaces, ret.ifaces.ifaces_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.ifaces.ifaces_len; i++) {
tmp_ifaces[i] = get_nonnull_interface(conn, ret.ifaces.ifaces_val[i]);
if (!tmp_ifaces[i])
goto cleanup;
}
*ifaces = tmp_ifaces;
tmp_ifaces = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_ifaces) {
for (i = 0; i < ret.ifaces.ifaces_len; i++)
virObjectUnref(tmp_ifaces[i]);
}
VIR_FREE(tmp_ifaces);
xdr_free((xdrproc_t) xdr_remote_connect_list_all_interfaces_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteConnectListAllNodeDevices(virConnectPtr conn,
virNodeDevicePtr **devices,
unsigned int flags)
{
int rv = -1;
size_t i;
virNodeDevicePtr *tmp_devices = NULL;
remote_connect_list_all_node_devices_args args;
remote_connect_list_all_node_devices_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!devices;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES,
(xdrproc_t) xdr_remote_connect_list_all_node_devices_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_node_devices_ret,
(char *) &ret) == -1)
goto done;
if (ret.devices.devices_len > REMOTE_NODE_DEVICE_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many node devices '%d' for limit '%d'"),
ret.devices.devices_len, REMOTE_NODE_DEVICE_LIST_MAX);
goto cleanup;
}
if (devices) {
if (VIR_ALLOC_N(tmp_devices, ret.devices.devices_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.devices.devices_len; i++) {
tmp_devices[i] = get_nonnull_node_device(conn, ret.devices.devices_val[i]);
if (!tmp_devices[i])
goto cleanup;
}
*devices = tmp_devices;
tmp_devices = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_devices) {
for (i = 0; i < ret.devices.devices_len; i++)
virObjectUnref(tmp_devices[i]);
VIR_FREE(tmp_devices);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_node_devices_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteConnectListAllNWFilters(virConnectPtr conn,
virNWFilterPtr **filters,
unsigned int flags)
{
int rv = -1;
size_t i;
virNWFilterPtr *tmp_filters = NULL;
remote_connect_list_all_nwfilters_args args;
remote_connect_list_all_nwfilters_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!filters;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS,
(xdrproc_t) xdr_remote_connect_list_all_nwfilters_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_nwfilters_ret,
(char *) &ret) == -1)
goto done;
if (ret.filters.filters_len > REMOTE_NWFILTER_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many network filters '%d' for limit '%d'"),
ret.filters.filters_len, REMOTE_NWFILTER_LIST_MAX);
goto cleanup;
}
if (filters) {
if (VIR_ALLOC_N(tmp_filters, ret.filters.filters_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.filters.filters_len; i++) {
tmp_filters[i] = get_nonnull_nwfilter(conn, ret.filters.filters_val[i]);
if (!tmp_filters[i])
goto cleanup;
}
*filters = tmp_filters;
tmp_filters = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_filters) {
for (i = 0; i < ret.filters.filters_len; i++)
virObjectUnref(tmp_filters[i]);
VIR_FREE(tmp_filters);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_nwfilters_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteConnectListAllSecrets(virConnectPtr conn,
virSecretPtr **secrets,
unsigned int flags)
{
int rv = -1;
size_t i;
virSecretPtr *tmp_secrets = NULL;
remote_connect_list_all_secrets_args args;
remote_connect_list_all_secrets_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!secrets;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_SECRETS,
(xdrproc_t) xdr_remote_connect_list_all_secrets_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_secrets_ret,
(char *) &ret) == -1)
goto done;
if (ret.secrets.secrets_len > REMOTE_SECRET_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many secrets '%d' for limit '%d'"),
ret.secrets.secrets_len, REMOTE_SECRET_LIST_MAX);
goto cleanup;
}
if (secrets) {
if (VIR_ALLOC_N(tmp_secrets, ret.secrets.secrets_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.secrets.secrets_len; i++) {
tmp_secrets[i] = get_nonnull_secret(conn, ret.secrets.secrets_val[i]);
if (!tmp_secrets[i])
goto cleanup;
}
*secrets = tmp_secrets;
tmp_secrets = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_secrets) {
for (i = 0; i < ret.secrets.secrets_len; i++)
virObjectUnref(tmp_secrets[i]);
VIR_FREE(tmp_secrets);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_secrets_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/
static char *
......@@ -3498,138 +3107,6 @@ remoteConnectFindStoragePoolSources(virConnectPtr conn,
return rv;
}
static int
remoteConnectListAllStoragePools(virConnectPtr conn,
virStoragePoolPtr **pools,
unsigned int flags)
{
int rv = -1;
size_t i;
virStoragePoolPtr *tmp_pools = NULL;
remote_connect_list_all_storage_pools_args args;
remote_connect_list_all_storage_pools_ret ret;
struct private_data *priv = conn->privateData;
remoteDriverLock(priv);
args.need_results = !!pools;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(conn,
priv,
0,
REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS,
(xdrproc_t) xdr_remote_connect_list_all_storage_pools_args,
(char *) &args,
(xdrproc_t) xdr_remote_connect_list_all_storage_pools_ret,
(char *) &ret) == -1)
goto done;
if (ret.pools.pools_len > REMOTE_STORAGE_POOL_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many storage pools '%d' for limit '%d'"),
ret.pools.pools_len, REMOTE_STORAGE_POOL_LIST_MAX);
goto cleanup;
}
if (pools) {
if (VIR_ALLOC_N(tmp_pools, ret.pools.pools_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.pools.pools_len; i++) {
tmp_pools[i] = get_nonnull_storage_pool(conn, ret.pools.pools_val[i]);
if (!tmp_pools[i])
goto cleanup;
}
*pools = tmp_pools;
tmp_pools = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_pools) {
for (i = 0; i < ret.pools.pools_len; i++)
virObjectUnref(tmp_pools[i]);
VIR_FREE(tmp_pools);
}
xdr_free((xdrproc_t) xdr_remote_connect_list_all_storage_pools_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteStoragePoolListAllVolumes(virStoragePoolPtr pool,
virStorageVolPtr **vols,
unsigned int flags)
{
int rv = -1;
size_t i;
virStorageVolPtr *tmp_vols = NULL;
remote_storage_pool_list_all_volumes_args args;
remote_storage_pool_list_all_volumes_ret ret;
struct private_data *priv = pool->conn->privateData;
remoteDriverLock(priv);
make_nonnull_storage_pool(&args.pool, pool);
args.need_results = !!vols;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(pool->conn,
priv,
0,
REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES,
(xdrproc_t) xdr_remote_storage_pool_list_all_volumes_args,
(char *) &args,
(xdrproc_t) xdr_remote_storage_pool_list_all_volumes_ret,
(char *) &ret) == -1)
goto done;
if (ret.vols.vols_len > REMOTE_STORAGE_VOL_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many storage volumes '%d' for limit '%d'"),
ret.vols.vols_len, REMOTE_STORAGE_VOL_LIST_MAX);
goto cleanup;
}
if (vols) {
if (VIR_ALLOC_N(tmp_vols, ret.vols.vols_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.vols.vols_len; i++) {
tmp_vols[i] = get_nonnull_storage_vol(pool->conn, ret.vols.vols_val[i]);
if (!tmp_vols[i])
goto cleanup;
}
*vols = tmp_vols;
tmp_vols = NULL;
}
rv = ret.ret;
cleanup:
if (tmp_vols) {
for (i = 0; i < ret.vols.vols_len; i++)
virObjectUnref(tmp_vols[i]);
VIR_FREE(tmp_vols);
}
xdr_free((xdrproc_t) xdr_remote_storage_pool_list_all_volumes_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
/*----------------------------------------------------------------------*/
static int
......@@ -6616,137 +6093,6 @@ remoteDomainGetInterfaceParameters(virDomainPtr domain,
return rv;
}
static int
remoteDomainListAllSnapshots(virDomainPtr dom,
virDomainSnapshotPtr **snapshots,
unsigned int flags)
{
int rv = -1;
size_t i;
virDomainSnapshotPtr *snaps = NULL;
remote_domain_list_all_snapshots_args args;
remote_domain_list_all_snapshots_ret ret;
struct private_data *priv = dom->conn->privateData;
remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.need_results = !!snapshots;
args.flags = flags;
memset(&ret, 0, sizeof(ret));
if (call(dom->conn,
priv,
0,
REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS,
(xdrproc_t) xdr_remote_domain_list_all_snapshots_args,
(char *) &args,
(xdrproc_t) xdr_remote_domain_list_all_snapshots_ret,
(char *) &ret) == -1)
goto done;
if (ret.snapshots.snapshots_len > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many domain snapshots '%d' for limit '%d'"),
ret.snapshots.snapshots_len,
REMOTE_DOMAIN_SNAPSHOT_LIST_MAX);
goto cleanup;
}
if (snapshots) {
if (VIR_ALLOC_N(snaps, ret.snapshots.snapshots_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.snapshots.snapshots_len; i++) {
snaps[i] = get_nonnull_domain_snapshot(dom, ret.snapshots.snapshots_val[i]);
if (!snaps[i])
goto cleanup;
}
*snapshots = snaps;
snaps = NULL;
}
rv = ret.ret;
cleanup:
if (snaps) {
for (i = 0; i < ret.snapshots.snapshots_len; i++)
virObjectUnref(snaps[i]);
VIR_FREE(snaps);
}
xdr_free((xdrproc_t) xdr_remote_domain_list_all_snapshots_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteDomainSnapshotListAllChildren(virDomainSnapshotPtr parent,
virDomainSnapshotPtr **snapshots,
unsigned int flags)
{
int rv = -1;
size_t i;
virDomainSnapshotPtr *snaps = NULL;
remote_domain_snapshot_list_all_children_args args;
remote_domain_snapshot_list_all_children_ret ret;
struct private_data *priv = parent->domain->conn->privateData;
remoteDriverLock(priv);
args.need_results = !!snapshots;
args.flags = flags;
make_nonnull_domain_snapshot(&args.snapshot, parent);
memset(&ret, 0, sizeof(ret));
if (call(parent->domain->conn,
priv,
0,
REMOTE_PROC_DOMAIN_SNAPSHOT_LIST_ALL_CHILDREN,
(xdrproc_t) xdr_remote_domain_snapshot_list_all_children_args,
(char *) &args,
(xdrproc_t) xdr_remote_domain_snapshot_list_all_children_ret,
(char *) &ret) == -1)
goto done;
if (ret.snapshots.snapshots_len > REMOTE_DOMAIN_SNAPSHOT_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many domain snapshots '%d' for limit '%d'"),
ret.snapshots.snapshots_len,
REMOTE_DOMAIN_SNAPSHOT_LIST_MAX);
goto cleanup;
}
if (snapshots) {
if (VIR_ALLOC_N(snaps, ret.snapshots.snapshots_len + 1) < 0)
goto cleanup;
for (i = 0; i < ret.snapshots.snapshots_len; i++) {
snaps[i] = get_nonnull_domain_snapshot(parent->domain, ret.snapshots.snapshots_val[i]);
if (!snaps[i])
goto cleanup;
}
*snapshots = snaps;
snaps = NULL;
}
rv = ret.ret;
cleanup:
if (snaps) {
for (i = 0; i < ret.snapshots.snapshots_len; i++)
virObjectUnref(snaps[i]);
VIR_FREE(snaps);
}
xdr_free((xdrproc_t) xdr_remote_domain_snapshot_list_all_children_ret, (char *) &ret);
done:
remoteDriverUnlock(priv);
return rv;
}
static int
remoteNodeGetMemoryParameters(virConnectPtr conn,
......
src/remote/remote_protocol.x
浏览文件 @ 42b85f17
......@@ -2553,7 +2553,7 @@ struct remote_domain_list_all_snapshots_args {
unsigned int flags;
};
struct remote_domain_list_all_snapshots_ret {
struct remote_domain_list_all_snapshots_ret { /* insert@1 */
remote_nonnull_domain_snapshot snapshots<REMOTE_DOMAIN_SNAPSHOT_LIST_MAX>;
int ret;
};
......@@ -2583,7 +2583,7 @@ struct remote_domain_snapshot_list_all_children_args {
unsigned int flags;
};
struct remote_domain_snapshot_list_all_children_ret {
struct remote_domain_snapshot_list_all_children_ret { /* insert@1 */
remote_nonnull_domain_snapshot snapshots<REMOTE_DOMAIN_SNAPSHOT_LIST_MAX>;
int ret;
};
......@@ -2822,7 +2822,7 @@ struct remote_connect_list_all_domains_args {
unsigned int flags;
};
struct remote_connect_list_all_domains_ret {
struct remote_connect_list_all_domains_ret { /* insert@1 */
remote_nonnull_domain domains<REMOTE_DOMAIN_LIST_MAX>;
unsigned int ret;
};
......@@ -2832,7 +2832,7 @@ struct remote_connect_list_all_storage_pools_args {
unsigned int flags;
};
struct remote_connect_list_all_storage_pools_ret {
struct remote_connect_list_all_storage_pools_ret { /* insert@1 */
remote_nonnull_storage_pool pools<REMOTE_STORAGE_POOL_LIST_MAX>;
unsigned int ret;
};
......@@ -2843,7 +2843,7 @@ struct remote_storage_pool_list_all_volumes_args {
unsigned int flags;
};
struct remote_storage_pool_list_all_volumes_ret {
struct remote_storage_pool_list_all_volumes_ret { /* insert@1 */
remote_nonnull_storage_vol vols<REMOTE_STORAGE_VOL_LIST_MAX>;
unsigned int ret;
};
......@@ -2853,7 +2853,7 @@ struct remote_connect_list_all_networks_args {
unsigned int flags;
};
struct remote_connect_list_all_networks_ret {
struct remote_connect_list_all_networks_ret { /* insert@1 */
remote_nonnull_network nets<REMOTE_NETWORK_LIST_MAX>;
unsigned int ret;
};
......@@ -2863,7 +2863,7 @@ struct remote_connect_list_all_interfaces_args {
unsigned int flags;
};
struct remote_connect_list_all_interfaces_ret {
struct remote_connect_list_all_interfaces_ret { /* insert@1 */
remote_nonnull_interface ifaces<REMOTE_INTERFACE_LIST_MAX>;
unsigned int ret;
};
......@@ -2873,7 +2873,7 @@ struct remote_connect_list_all_node_devices_args {
unsigned int flags;
};
struct remote_connect_list_all_node_devices_ret {
struct remote_connect_list_all_node_devices_ret { /* insert@1 */
remote_nonnull_node_device devices<REMOTE_NODE_DEVICE_LIST_MAX>;
unsigned int ret;
};
......@@ -2883,7 +2883,7 @@ struct remote_connect_list_all_nwfilters_args {
unsigned int flags;
};
struct remote_connect_list_all_nwfilters_ret {
struct remote_connect_list_all_nwfilters_ret { /* insert@1 */
remote_nonnull_nwfilter filters<REMOTE_NWFILTER_LIST_MAX>;
unsigned int ret;
};
......@@ -2893,7 +2893,7 @@ struct remote_connect_list_all_secrets_args {
unsigned int flags;
};
struct remote_connect_list_all_secrets_ret {
struct remote_connect_list_all_secrets_ret { /* insert@1 */
remote_nonnull_secret secrets<REMOTE_SECRET_LIST_MAX>;
unsigned int ret;
};
......@@ -5147,7 +5147,7 @@ enum remote_procedure {
REMOTE_PROC_DOMAIN_SNAPSHOT_HAS_METADATA = 272,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_domains
* @aclfilter: domain:getattr
......@@ -5155,14 +5155,14 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_DOMAINS = 273,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: domain:read
*/
REMOTE_PROC_DOMAIN_LIST_ALL_SNAPSHOTS = 274,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: domain:read
*/
......@@ -5202,7 +5202,7 @@ enum remote_procedure {
REMOTE_PROC_DOMAIN_GET_EMULATOR_PIN_INFO = 280,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_storage_pools
* @aclfilter: storage_pool:getattr
......@@ -5210,7 +5210,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_STORAGE_POOLS = 281,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: storage_pool:search_storage_vols
* @aclfilter: storage_vol:getattr
......@@ -5218,7 +5218,7 @@ enum remote_procedure {
REMOTE_PROC_STORAGE_POOL_LIST_ALL_VOLUMES = 282,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_networks
* @aclfilter: network:getattr
......@@ -5226,7 +5226,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_NETWORKS = 283,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_interfaces
* @aclfilter: interface:getattr
......@@ -5234,7 +5234,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_INTERFACES = 284,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_node_devices
* @aclfilter: node_device:getattr
......@@ -5242,7 +5242,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_NODE_DEVICES = 285,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_nwfilters
* @aclfilter: nwfilter:getattr
......@@ -5250,7 +5250,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_LIST_ALL_NWFILTERS = 286,
/**
* @generate: none
* @generate: both
* @priority: high
* @acl: connect:search_secrets
* @aclfilter: secret:getattr
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或