static const char *
remoteConnectGetType(virConnectPtr conn)
{
- char *rv = NULL;
remote_connect_get_type_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
/* Cached? */
if (priv->type) {
- rv = priv->type;
- goto done;
+ return priv->type;
}
memset(&ret, 0, sizeof(ret));
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_GET_TYPE,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_remote_connect_get_type_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
/* Stash. */
- rv = priv->type = ret.type;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return priv->type = ret.type;
}
static int remoteConnectIsSecure(virConnectPtr conn)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
remote_connect_is_secure_ret ret;
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_IS_SECURE,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_remote_connect_is_secure_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* We claim to be secure, if the remote driver
* transport itself is secure, and the remote
* remote driver is used to connect to a XenD
* driver using unencrypted HTTP:/// access
*/
- rv = priv->is_secure && ret.secure ? 1 : 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return priv->is_secure && ret.secure ? 1 : 0;
}
static int remoteConnectIsEncrypted(virConnectPtr conn)
{
- int rv = -1;
bool encrypted;
struct private_data *priv = conn->privateData;
remote_connect_is_secure_ret ret;
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_IS_SECURE,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_remote_connect_is_secure_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
encrypted = virNetClientIsEncrypted(priv->client);
* option, since it will almost always be false,
* even if secure (eg UNIX sockets).
*/
- rv = encrypted && ret.secure ? 1 : 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return encrypted && ret.secure ? 1 : 0;
}
static int
remote_node_get_cpu_stats_ret ret;
size_t i;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.nparams = *nparams;
args.cpuNum = cpuNum;
(char *) &args,
(xdrproc_t) xdr_remote_node_get_cpu_stats_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
/* Check the length of the returned list carefully. */
if (ret.params.params_len > REMOTE_NODE_CPU_STATS_MAX ||
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_cpu_stats_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_node_get_memory_stats_ret ret;
size_t i;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.nparams = *nparams;
args.cellNum = cellNum;
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_MEMORY_STATS,
(xdrproc_t) xdr_remote_node_get_memory_stats_args, (char *) &args,
(xdrproc_t) xdr_remote_node_get_memory_stats_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Check the length of the returned list carefully. */
if (ret.params.params_len > REMOTE_NODE_MEMORY_STATS_MAX ||
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_memory_stats_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
int startCell,
int maxCells)
{
- int rv = -1;
remote_node_get_cells_free_memory_args args;
remote_node_get_cells_free_memory_ret ret;
size_t i;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (maxCells > REMOTE_NODE_MAX_CELLS) {
virReportError(VIR_ERR_RPC,
_("too many NUMA cells: %d > %d"),
maxCells, REMOTE_NODE_MAX_CELLS);
- goto done;
+ return -1;
}
args.startCell = startCell;
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_CELLS_FREE_MEMORY,
(xdrproc_t) xdr_remote_node_get_cells_free_memory_args, (char *)&args,
(xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, (char *)&ret) == -1)
- goto done;
+ return -1;
for (i = 0; i < ret.cells.cells_len; i++)
freeMems[i] = ret.cells.cells_val[i];
xdr_free((xdrproc_t) xdr_remote_node_get_cells_free_memory_ret, (char *) &ret);
- rv = ret.cells.cells_len;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return ret.cells.cells_len;
}
static int
remote_connect_list_domains_args args;
remote_connect_list_domains_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (maxids > REMOTE_DOMAIN_LIST_MAX) {
virReportError(VIR_ERR_RPC,
_("Too many domains '%d' for limit '%d'"),
maxids, REMOTE_DOMAIN_LIST_MAX);
- goto done;
+ return -1;
}
args.maxids = maxids;
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_LIST_DOMAINS,
(xdrproc_t) xdr_remote_connect_list_domains_args, (char *) &args,
(xdrproc_t) xdr_remote_connect_list_domains_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.ids.ids_len > maxids) {
virReportError(VIR_ERR_RPC,
cleanup:
xdr_free((xdrproc_t) xdr_remote_connect_list_domains_ret, (char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_block_stats_flags_args args;
remote_domain_block_stats_flags_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.nparams = *nparams;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_BLOCK_STATS_FLAGS,
(xdrproc_t) xdr_remote_domain_block_stats_flags_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_block_stats_flags_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Check the length of the returned list carefully. */
if (ret.params.params_len > REMOTE_DOMAIN_BLOCK_STATS_PARAMETERS_MAX ||
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_block_stats_flags_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_memory_parameters_args args;
remote_domain_get_memory_parameters_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.nparams = *nparams;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_MEMORY_PARAMETERS,
(xdrproc_t) xdr_remote_domain_get_memory_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_memory_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Handle the case when the caller does not know the number of parameters
* and is asking for the number of parameters supported
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_memory_parameters_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_numa_parameters_args args;
remote_domain_get_numa_parameters_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.nparams = *nparams;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_NUMA_PARAMETERS,
(xdrproc_t) xdr_remote_domain_get_numa_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_numa_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Handle the case when the caller does not know the number of parameters
* and is asking for the number of parameters supported
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_numa_parameters_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_launch_security_info_args args;
remote_domain_get_launch_security_info_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_LAUNCH_SECURITY_INFO,
(xdrproc_t) xdr_remote_domain_get_launch_security_info_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_launch_security_info_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_launch_security_info_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_perf_events_args args;
remote_domain_get_perf_events_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_PERF_EVENTS,
(xdrproc_t) xdr_remote_domain_get_perf_events_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_perf_events_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_perf_events_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_blkio_parameters_args args;
remote_domain_get_blkio_parameters_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.nparams = *nparams;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_BLKIO_PARAMETERS,
(xdrproc_t) xdr_remote_domain_get_blkio_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_blkio_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Handle the case when the caller does not know the number of parameters
* and is asking for the number of parameters supported
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_blkio_parameters_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_vcpu_pin_info_args args;
remote_domain_get_vcpu_pin_info_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (ncpumaps > REMOTE_VCPUINFO_MAX) {
virReportError(VIR_ERR_RPC,
_("vCPU count exceeds maximum: %d > %d"),
ncpumaps, REMOTE_VCPUINFO_MAX);
- goto done;
+ return -1;
}
if (VIR_INT_MULTIPLY_OVERFLOW(ncpumaps, maplen) ||
virReportError(VIR_ERR_RPC,
_("vCPU map buffer length exceeds maximum: %d > %d"),
ncpumaps * maplen, REMOTE_CPUMAPS_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
(char *) &args,
(xdrproc_t) xdr_remote_domain_get_vcpu_pin_info_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.num > ncpumaps) {
virReportError(VIR_ERR_RPC,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_vcpu_pin_info_ret, (char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
int cpumaplen,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_pin_emulator_args args;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (cpumaplen > REMOTE_CPUMAP_MAX) {
virReportError(VIR_ERR_RPC,
_("%s length greater than maximum: %d > %d"),
"cpumap", cpumaplen, REMOTE_CPUMAP_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, dom);
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_PIN_EMULATOR,
(xdrproc_t) xdr_remote_domain_pin_emulator_args,
(char *) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1) {
- goto done;
- }
-
- rv = 0;
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
remote_domain_get_emulator_pin_info_args args;
remote_domain_get_emulator_pin_info_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
/* There is only one cpumap for all emulator threads */
if (maplen > REMOTE_CPUMAPS_MAX) {
virReportError(VIR_ERR_RPC,
_("vCPU map buffer length exceeds maximum: %d > %d"),
maplen, REMOTE_CPUMAPS_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
(char *) &args,
(xdrproc_t) xdr_remote_domain_get_emulator_pin_info_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.cpumaps.cpumaps_len > maplen) {
virReportError(VIR_ERR_RPC,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_emulator_pin_info_ret,
(char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_vcpus_args args;
remote_domain_get_vcpus_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (maxinfo > REMOTE_VCPUINFO_MAX) {
virReportError(VIR_ERR_RPC,
_("vCPU count exceeds maximum: %d > %d"),
maxinfo, REMOTE_VCPUINFO_MAX);
- goto done;
+ return -1;
}
if (VIR_INT_MULTIPLY_OVERFLOW(maxinfo, maplen) ||
maxinfo * maplen > REMOTE_CPUMAPS_MAX) {
virReportError(VIR_ERR_RPC,
_("vCPU map buffer length exceeds maximum: %d > %d"),
maxinfo * maplen, REMOTE_CPUMAPS_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_VCPUS,
(xdrproc_t) xdr_remote_domain_get_vcpus_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.info.info_len > maxinfo) {
virReportError(VIR_ERR_RPC,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_vcpus_ret, (char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_iothread_info_args args;
remote_domain_get_iothread_info_ret ret;
remote_domain_iothread_info *src;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
(char *)&args,
(xdrproc_t)xdr_remote_domain_get_iothread_info_ret,
(char *)&ret) == -1)
- goto done;
+ return -1;
if (ret.info.info_len > REMOTE_IOTHREAD_INFO_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
cleanup:
xdr_free((xdrproc_t)xdr_remote_domain_get_iothread_info_ret,
(char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_security_label_ret ret;
struct private_data *priv = domain->conn->privateData;
int rv = -1;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
memset(&ret, 0, sizeof(ret));
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL,
(xdrproc_t) xdr_remote_domain_get_security_label_args, (char *)&args,
- (xdrproc_t) xdr_remote_domain_get_security_label_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t) xdr_remote_domain_get_security_label_ret, (char *)&ret) == -1)
+ return -1;
if (ret.label.label_val != NULL) {
if (virStrcpyStatic(seclabel->label, ret.label.label_val) < 0) {
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_security_label_ret, (char *)&ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
struct private_data *priv = domain->conn->privateData;
size_t i;
int rv = -1;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
memset(&ret, 0, sizeof(ret));
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SECURITY_LABEL_LIST,
(xdrproc_t) xdr_remote_domain_get_security_label_list_args, (char *)&args,
- (xdrproc_t) xdr_remote_domain_get_security_label_list_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t) xdr_remote_domain_get_security_label_list_ret, (char *)&ret) == -1)
+ return -1;
*seclabels = g_new0(virSecurityLabel, ret.labels.labels_len);
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_security_label_list_ret, (char *)&ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
int *reason,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_state_args args;
remote_domain_get_state_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_STATE,
(xdrproc_t) xdr_remote_domain_get_state_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_state_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
*state = ret.state;
if (reason)
*reason = ret.reason;
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
remote_node_get_security_model_ret ret;
struct private_data *priv = conn->privateData;
int rv = -1;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
memset(secmodel, 0, sizeof(*secmodel));
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_SECURITY_MODEL,
(xdrproc_t) xdr_void, NULL,
- (xdrproc_t) xdr_remote_node_get_security_model_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t) xdr_remote_node_get_security_model_ret, (char *)&ret) == -1)
+ return -1;
if (ret.model.model_val != NULL) {
if (virStrcpyStatic(secmodel->model, ret.model.model_val) < 0) {
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_security_model_ret, (char *)&ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
unsigned long flags, const char *dname,
unsigned long resource)
{
- int rv = -1;
remote_domain_migrate_prepare_args args;
remote_domain_migrate_prepare_ret ret;
struct private_data *priv = dconn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.uri_in = uri_in == NULL ? NULL : (char **) &uri_in;
args.flags = flags;
if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE,
(xdrproc_t) xdr_remote_domain_migrate_prepare_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_prepare_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.cookie.cookie_len > 0) {
*cookie = ret.cookie.cookie_val; /* Caller frees. */
*uri_out = *ret.uri_out; /* Caller frees. */
VIR_FREE(ret.uri_out);
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
remote_domain_migrate_prepare2_args args;
remote_domain_migrate_prepare2_ret ret;
struct private_data *priv = dconn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.uri_in = uri_in == NULL ? NULL : (char **) &uri_in;
args.flags = flags;
if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE2,
(xdrproc_t) xdr_remote_domain_migrate_prepare2_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_prepare2_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.cookie.cookie_len > 0) {
if (!cookie || !cookielen) {
done:
VIR_FREE(ret.uri_out);
- remoteDriverUnlock(priv);
return rv;
error:
if (ret.cookie.cookie_len)
static int
remoteDomainCreate(virDomainPtr domain)
{
- int rv = -1;
remote_domain_create_args args;
remote_domain_lookup_by_uuid_args args2;
remote_domain_lookup_by_uuid_ret ret2;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_CREATE,
(xdrproc_t) xdr_remote_domain_create_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
/* Need to do a lookup figure out ID of newly started guest, because
* bug in design of REMOTE_PROC_DOMAIN_CREATE means we aren't getting
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_LOOKUP_BY_UUID,
(xdrproc_t) xdr_remote_domain_lookup_by_uuid_args, (char *) &args2,
(xdrproc_t) xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret2) == -1)
- goto done;
+ return -1;
domain->id = ret2.dom.id;
xdr_free((xdrproc_t) &xdr_remote_domain_lookup_by_uuid_ret, (char *) &ret2);
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static char *
remoteDomainGetSchedulerType(virDomainPtr domain, int *nparams)
{
- char *rv = NULL;
remote_domain_get_scheduler_type_args args;
remote_domain_get_scheduler_type_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_SCHEDULER_TYPE,
(xdrproc_t) xdr_remote_domain_get_scheduler_type_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_scheduler_type_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
if (nparams) *nparams = ret.nparams;
/* Caller frees this. */
- rv = ret.type;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return ret.type;
}
static int
remote_domain_memory_stats_ret ret;
struct private_data *priv = domain->conn->privateData;
size_t i;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
if (nr_stats > REMOTE_DOMAIN_MEMORY_STATS_MAX) {
virReportError(VIR_ERR_RPC,
_("too many memory stats requested: %d > %d"), nr_stats,
REMOTE_DOMAIN_MEMORY_STATS_MAX);
- goto done;
+ return -1;
}
args.maxStats = nr_stats;
args.flags = flags;
(char *) &args,
(xdrproc_t) xdr_remote_domain_memory_stats_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
for (i = 0; i < ret.stats.stats_len; i++) {
stats[i].tag = ret.stats.stats_val[i].tag;
rv = ret.stats.stats_len;
xdr_free((xdrproc_t) xdr_remote_domain_memory_stats_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_block_peek_args args;
remote_domain_block_peek_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (size > REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX) {
virReportError(VIR_ERR_RPC,
_("block peek request too large for remote protocol, %zi > %d"),
size, REMOTE_DOMAIN_BLOCK_PEEK_BUFFER_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
(char *) &args,
(xdrproc_t) xdr_remote_domain_block_peek_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.buffer.buffer_len != size) {
virReportError(VIR_ERR_RPC, "%s",
cleanup:
VIR_FREE(ret.buffer.buffer_val);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_memory_peek_args args;
remote_domain_memory_peek_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (size > REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX) {
virReportError(VIR_ERR_RPC,
_("memory peek request too large for remote protocol, %zi > %d"),
size, REMOTE_DOMAIN_MEMORY_PEEK_BUFFER_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
(char *) &args,
(xdrproc_t) xdr_remote_domain_memory_peek_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.buffer.buffer_len != size) {
virReportError(VIR_ERR_RPC, "%s",
cleanup:
VIR_FREE(ret.buffer.buffer_val);
- done:
- remoteDriverUnlock(priv);
return rv;
}
virDomainBlockJobInfoPtr info,
unsigned int flags)
{
- int rv = -1;
remote_domain_get_block_job_info_args args;
remote_domain_get_block_job_info_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.path = (char *)path;
(char *)&args,
(xdrproc_t)xdr_remote_domain_get_block_job_info_ret,
(char *)&ret) == -1)
- goto done;
+ return -1;
if (ret.found) {
info->type = ret.type;
info->bandwidth = ret.bandwidth;
info->cur = ret.cur;
info->end = ret.end;
- rv = 1;
+ return 1;
} else {
- rv = 0;
+ return 0;
}
-
- done:
- remoteDriverUnlock(priv);
- return rv;
}
static int remoteDomainGetBlockIoTune(virDomainPtr domain,
remote_domain_get_block_io_tune_args args;
remote_domain_get_block_io_tune_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.disk = disk ? (char **)&disk : NULL;
(char *) &args,
(xdrproc_t) xdr_remote_domain_get_block_io_tune_ret,
(char *) &ret) == -1) {
- goto done;
+ return -1;
}
/* Handle the case when the caller does not know the number of parameters
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_block_io_tune_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_cpu_stats_ret ret;
int rv = -1;
int cpu;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (nparams > REMOTE_NODE_CPU_STATS_MAX) {
virReportError(VIR_ERR_RPC,
_("nparams count exceeds maximum: %u > %u"),
nparams, REMOTE_NODE_CPU_STATS_MAX);
- goto done;
+ return -1;
}
if (ncpus > REMOTE_DOMAIN_GET_CPU_STATS_NCPUS_MAX) {
virReportError(VIR_ERR_RPC,
_("ncpus count exceeds maximum: %u > %u"),
ncpus, REMOTE_DOMAIN_GET_CPU_STATS_NCPUS_MAX);
- goto done;
+ return -1;
}
make_nonnull_domain(&args.dom, domain);
(char *) &args,
(xdrproc_t) xdr_remote_domain_get_cpu_stats_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
/* Check the length of the returned list carefully. */
if (ret.params.params_len > nparams * ncpus ||
xdr_free((xdrproc_t) xdr_remote_domain_get_cpu_stats_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
void *opaque,
virFreeCallback freecb)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
remote_connect_network_event_register_any_args args;
remote_connect_network_event_register_any_ret ret;
int callbackID;
int count;
remote_nonnull_network network;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virNetworkEventStateRegisterClient(conn, priv->eventState,
net, eventID, callback,
opaque, freecb,
&callbackID)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
(xdrproc_t) xdr_remote_connect_network_event_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
remote_connect_network_event_deregister_any_args args;
int eventID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this eventID, we need to disable
* events on the server */
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_network_event_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
void *opaque,
virFreeCallback freecb)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
remote_connect_storage_pool_event_register_any_args args;
remote_connect_storage_pool_event_register_any_ret ret;
int callbackID;
int count;
remote_nonnull_storage_pool storage_pool;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virStoragePoolEventStateRegisterClient(conn, priv->eventState,
pool, eventID, callback,
opaque, freecb,
&callbackID)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
(xdrproc_t) xdr_remote_connect_storage_pool_event_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
static int
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
remote_connect_storage_pool_event_deregister_any_args args;
int eventID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this eventID, we need to disable
* events on the server */
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_STORAGE_POOL_EVENT_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_storage_pool_event_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
void *opaque,
virFreeCallback freecb)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
remote_connect_node_device_event_register_any_args args;
remote_connect_node_device_event_register_any_ret ret;
int callbackID;
int count;
remote_nonnull_node_device node_device;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virNodeDeviceEventStateRegisterClient(conn, priv->eventState,
dev, eventID, callback,
opaque, freecb,
&callbackID)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
(xdrproc_t) xdr_remote_connect_node_device_event_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
remote_connect_node_device_event_deregister_any_args args;
int eventID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this eventID, we need to disable
* events on the server */
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_NODE_DEVICE_EVENT_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_node_device_event_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
void *opaque,
virFreeCallback freecb)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
remote_connect_secret_event_register_any_args args;
remote_connect_secret_event_register_any_ret ret;
int callbackID;
int count;
remote_nonnull_secret sec;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virSecretEventStateRegisterClient(conn, priv->eventState,
secret, eventID, callback,
opaque, freecb,
&callbackID)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
(xdrproc_t) xdr_remote_connect_secret_event_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
remote_connect_secret_event_deregister_any_args args;
int eventID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this eventID, we need to disable
* events on the server */
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_SECRET_EVENT_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_secret_event_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
virFreeCallback freecb,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
qemu_connect_domain_monitor_event_register_args args;
qemu_connect_domain_monitor_event_register_ret ret;
int callbackID;
int count;
remote_nonnull_domain domain;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virDomainQemuMonitorEventStateRegisterID(conn,
priv->eventState,
dom, event, callback,
opaque, freecb, -1,
&callbackID)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this event, we need to enable
* events on the server */
(xdrproc_t) xdr_qemu_connect_domain_monitor_event_register_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
qemu_connect_domain_monitor_event_deregister_args args;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this event, we need to disable
* events on the server */
if (call(conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER,
(xdrproc_t) xdr_qemu_connect_domain_monitor_event_deregister_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
/*----------------------------------------------------------------------*/
remote_connect_find_storage_pool_sources_args args;
remote_connect_find_storage_pool_sources_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.type = (char*)type;
args.srcSpec = srcSpec ? (char **)&srcSpec : NULL;
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_FIND_STORAGE_POOL_SOURCES,
(xdrproc_t) xdr_remote_connect_find_storage_pool_sources_args, (char *) &args,
(xdrproc_t) xdr_remote_connect_find_storage_pool_sources_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
rv = g_steal_pointer(&ret.xml); /* To stop xdr_free free'ing it */
xdr_free((xdrproc_t) xdr_remote_connect_find_storage_pool_sources_ret, (char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
static int
remoteNodeDeviceDettach(virNodeDevicePtr dev)
{
- int rv = -1;
remote_node_device_dettach_args args;
struct private_data *priv = dev->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.name = dev->name;
if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DETTACH,
(xdrproc_t) xdr_remote_node_device_dettach_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
const char *driverName,
unsigned int flags)
{
- int rv = -1;
remote_node_device_detach_flags_args args;
struct private_data *priv = dev->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.name = dev->name;
args.driverName = driverName ? (char**)&driverName : NULL;
if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_DETACH_FLAGS,
(xdrproc_t) xdr_remote_node_device_detach_flags_args,
(char *) &args, (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
remoteNodeDeviceReAttach(virNodeDevicePtr dev)
{
- int rv = -1;
remote_node_device_re_attach_args args;
struct private_data *priv = dev->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.name = dev->name;
if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_RE_ATTACH,
(xdrproc_t) xdr_remote_node_device_re_attach_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
remoteNodeDeviceReset(virNodeDevicePtr dev)
{
- int rv = -1;
remote_node_device_reset_args args;
/* This method is unusual in that it uses the HV driver, not the devMon driver
* hence its use of privateData, instead of nodeDevicePrivateData */
struct private_data *priv = dev->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.name = dev->name;
if (call(dev->conn, priv, 0, REMOTE_PROC_NODE_DEVICE_RESET,
(xdrproc_t) xdr_remote_node_device_reset_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
virFreeCallback freecb)
{
int callbackID;
- int rv = -1;
struct private_data *priv = conn->privateData;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
NULL,
opaque, freecb, true,
&callbackID,
priv->serverEventFilter)) < 0)
- goto done;
+ return -1;
if (count == 1) {
/* Tell the server when we are the first callback registering */
(xdrproc_t) xdr_remote_connect_domain_event_callback_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
(xdrproc_t) xdr_void, (char *) NULL) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
}
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
virConnectDomainEventCallback callback)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
remote_connect_domain_event_callback_deregister_any_args args;
int callbackID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((callbackID = virDomainEventStateCallbackID(conn, priv->eventState,
callback,
&remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
if (count == 0) {
/* Tell the server when we are the last callback deregistering */
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_domain_event_callback_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
} else {
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
remoteSecretGetValue(virSecretPtr secret, size_t *value_size,
unsigned int flags)
{
- unsigned char *rv = NULL;
remote_secret_get_value_args args;
remote_secret_get_value_ret ret;
struct private_data *priv = secret->conn->privateData;
- remoteDriverLock(priv);
-
make_nonnull_secret(&args.secret, secret);
args.flags = flags;
if (call(secret->conn, priv, 0, REMOTE_PROC_SECRET_GET_VALUE,
(xdrproc_t) xdr_remote_secret_get_value_args, (char *) &args,
(xdrproc_t) xdr_remote_secret_get_value_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
*value_size = ret.value.value_len;
- rv = (unsigned char *) ret.value.value_val; /* Caller frees. */
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return (unsigned char *) ret.value.value_val; /* Caller frees. */
}
virNetClientStream *privst = st->privateData;
int ret = -1;
struct remoteStreamCallbackData *cbdata;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
cbdata = g_new0(struct remoteStreamCallbackData, 1);
cbdata->cb = cb;
cbdata->st = st;
virStreamRef(st);
- remoteDriverLock(priv);
-
if ((ret = virNetClientStreamEventAddCallback(privst,
events,
remoteStreamEventCallback,
cbdata,
remoteStreamCallbackFree)) < 0) {
VIR_FREE(cbdata);
- goto cleanup;
+ return -1;
}
- cleanup:
- remoteDriverUnlock(priv);
return ret;
}
{
struct private_data *priv = st->conn->privateData;
virNetClientStream *privst = st->privateData;
- int ret = -1;
-
- remoteDriverLock(priv);
-
- ret = virNetClientStreamEventUpdateCallback(privst, events);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
- remoteDriverUnlock(priv);
- return ret;
+ return virNetClientStreamEventUpdateCallback(privst, events);
}
{
struct private_data *priv = st->conn->privateData;
virNetClientStream *privst = st->privateData;
- int ret = -1;
-
- remoteDriverLock(priv);
-
- ret = virNetClientStreamEventRemoveCallback(privst);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
- remoteDriverUnlock(priv);
- return ret;
+ return virNetClientStreamEventRemoveCallback(privst);
}
void *opaque,
virFreeCallback freecb)
{
- int rv = -1;
struct private_data *priv = conn->privateData;
int callbackID;
int count;
remote_nonnull_domain domain;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
dom, eventID, callback,
opaque, freecb, false,
&callbackID,
priv->serverEventFilter)) < 0)
- goto done;
+ return -1;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
(xdrproc_t) xdr_remote_connect_domain_event_callback_register_any_ret, (char *) &ret) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
ret.callbackID);
(xdrproc_t) xdr_void, (char *)NULL) == -1) {
virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, false);
- goto done;
+ return -1;
}
}
}
- rv = callbackID;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return callbackID;
}
int callbackID)
{
struct private_data *priv = conn->privateData;
- int rv = -1;
int eventID;
int remoteID;
int count;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
callbackID, &remoteID)) < 0)
- goto done;
+ return -1;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
callbackID, true)) < 0)
- goto done;
+ return -1;
/* If that was the last callback for this eventID, we need to disable
* events on the server */
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_domain_event_callback_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
} else {
remote_connect_domain_event_deregister_any_args args;
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY,
(xdrproc_t) xdr_remote_connect_domain_event_deregister_any_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ return -1;
}
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
qemu_domain_monitor_command_args args;
qemu_domain_monitor_command_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.cmd = (char *)cmd;
if (call(domain->conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_DOMAIN_MONITOR_COMMAND,
(xdrproc_t) xdr_qemu_domain_monitor_command_args, (char *) &args,
(xdrproc_t) xdr_qemu_domain_monitor_command_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
*result = g_strdup(ret.result);
xdr_free((xdrproc_t) xdr_qemu_domain_monitor_command_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
char **result,
unsigned int flags)
{
- int rv = -1;
qemu_domain_monitor_command_with_files_args args;
qemu_domain_monitor_command_with_files_ret ret;
struct private_data *priv = domain->conn->privateData;
size_t rpc_noutfiles = 0;
g_autofree int *rpc_outfiles = NULL;
size_t i;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.cmd = (char *)cmd;
QEMU_PROC_DOMAIN_MONITOR_COMMAND_WITH_FILES,
(xdrproc_t) xdr_qemu_domain_monitor_command_with_files_args, (char *) &args,
(xdrproc_t) xdr_qemu_domain_monitor_command_with_files_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (outfiles)
*outfiles = g_steal_pointer(&rpc_outfiles);
*result = g_strdup(ret.result);
- rv = 0;
-
xdr_free((xdrproc_t) xdr_qemu_domain_monitor_command_with_files_ret, (char *) &ret);
- done:
if (rpc_outfiles) {
for (i = 0; i < rpc_noutfiles; i++) {
VIR_FORCE_CLOSE(rpc_outfiles[i]);
}
}
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
remote_domain_migrate_begin3_args args;
remote_domain_migrate_begin3_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_BEGIN3,
(xdrproc_t) xdr_remote_domain_migrate_begin3_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_begin3_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
if (ret.cookie_out.cookie_out_len > 0) {
if (!cookieout || !cookieoutlen) {
rv = ret.xml; /* caller frees */
done:
- remoteDriverUnlock(priv);
return rv;
error:
remote_domain_migrate_prepare3_args args;
remote_domain_migrate_prepare3_ret ret;
struct private_data *priv = dconn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PREPARE3,
(xdrproc_t) xdr_remote_domain_migrate_prepare3_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_prepare3_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.cookie_out.cookie_out_len > 0) {
if (!cookieout || !cookieoutlen) {
done:
VIR_FREE(ret.uri_out);
- remoteDriverUnlock(priv);
return rv;
error:
VIR_FREE(ret.cookie_out.cookie_out_val);
const char *dom_xml)
{
struct private_data *priv = dconn->privateData;
- int rv = -1;
remote_domain_migrate_prepare_tunnel3_args args;
remote_domain_migrate_prepare_tunnel3_ret ret;
virNetClientStream *netst;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
REMOTE_PROC_DOMAIN_MIGRATE_PREPARE_TUNNEL3,
priv->counter,
false)))
- goto done;
+ return -1;
if (virNetClientAddStream(priv->client, netst) < 0) {
virObjectUnref(netst);
- goto done;
+ return -1;
}
st->driver = &remoteStreamDrv;
(xdrproc_t) xdr_remote_domain_migrate_prepare_tunnel3_ret, (char *) &ret) == -1) {
virNetClientRemoveStream(priv->client, netst);
virObjectUnref(netst);
- goto done;
+ return -1;
}
if (ret.cookie_out.cookie_out_len > 0) {
*cookieoutlen = ret.cookie_out.cookie_out_len;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
error:
VIR_FREE(ret.cookie_out.cookie_out_val);
- goto done;
+ return -1;
}
const char *dname,
unsigned long resource)
{
- int rv = -1;
remote_domain_migrate_perform3_args args;
remote_domain_migrate_perform3_ret ret;
struct private_data *priv = dom->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_PERFORM3,
(xdrproc_t) xdr_remote_domain_migrate_perform3_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_perform3_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.cookie_out.cookie_out_len > 0) {
if (!cookieout || !cookieoutlen) {
*cookieoutlen = ret.cookie_out.cookie_out_len;
}
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
error:
VIR_FREE(ret.cookie_out.cookie_out_val);
- goto done;
+ return -1;
}
remote_domain_migrate_finish3_ret ret;
struct private_data *priv = dconn->privateData;
virDomainPtr rv = NULL;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
if (call(dconn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_FINISH3,
(xdrproc_t) xdr_remote_domain_migrate_finish3_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_migrate_finish3_ret, (char *) &ret) == -1)
- goto done;
+ return NULL;
rv = get_nonnull_domain(dconn, ret.dom);
xdr_free((xdrproc_t) &xdr_remote_domain_migrate_finish3_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
error:
VIR_FREE(ret.cookie_out.cookie_out_val);
- goto done;
+ return NULL;
}
unsigned long flags,
int cancelled)
{
- int rv = -1;
remote_domain_migrate_confirm3_args args;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.cookie_in.cookie_in_len = cookieinlen;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_MIGRATE_CONFIRM3,
(xdrproc_t) xdr_remote_domain_migrate_confirm3_args, (char *) &args,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
-
- rv = 0;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
g_auto(GStrv) retmodels = NULL;
remote_connect_get_cpu_model_names_args args;
remote_connect_get_cpu_model_names_ret ret;
-
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.arch = (char *) arch;
args.need_results = !!models;
(char *) &args,
(xdrproc_t) xdr_remote_connect_get_cpu_model_names_ret,
(char *) &ret) < 0)
- goto done;
+ return -1;
/* Check the length of the returned list carefully. */
if (ret.models.models_len > REMOTE_CONNECT_CPU_MODELS_MAX) {
cleanup:
xdr_free((xdrproc_t) xdr_remote_connect_get_cpu_model_names_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
int fd,
unsigned int flags)
{
- int rv = -1;
remote_domain_open_graphics_args args;
struct private_data *priv = dom->conn->privateData;
int fdin[] = { fd };
size_t fdinlen = G_N_ELEMENTS(fdin);
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.idx = idx;
REMOTE_PROC_DOMAIN_OPEN_GRAPHICS,
(xdrproc_t) xdr_remote_domain_open_graphics_args, (char *) &args,
(xdrproc_t) xdr_void, NULL) == -1)
- goto done;
-
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
+ return -1;
- return rv;
+ return 0;
}
struct private_data *priv = dom->conn->privateData;
int *fdout = NULL;
size_t fdoutlen = 0;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.idx = idx;
REMOTE_PROC_DOMAIN_OPEN_GRAPHICS_FD,
(xdrproc_t) xdr_remote_domain_open_graphics_fd_args, (char *) &args,
(xdrproc_t) xdr_void, NULL) == -1)
- goto done;
+ return -1;
if (fdoutlen != 1) {
if (fdoutlen) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("no file descriptor received"));
}
- goto done;
+ return -1;
}
rv = fdout[0];
- done:
VIR_FREE(fdout);
- remoteDriverUnlock(priv);
-
return rv;
}
remoteConnectSetKeepAlive(virConnectPtr conn, int interval, unsigned int count)
{
struct private_data *priv = conn->privateData;
- int ret = -1;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
- remoteDriverLock(priv);
if (!virNetClientKeepAliveIsSupported(priv->client)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("the caller doesn't support keepalive protocol;"
" perhaps it's missing event loop implementation"));
- goto cleanup;
+ return -1;
}
if (!priv->serverKeepAlive) {
- ret = 1;
- goto cleanup;
+ return 1;
}
if (interval > 0) {
- ret = virNetClientKeepAliveStart(priv->client, interval, count);
+ return virNetClientKeepAliveStart(priv->client, interval, count);
} else {
virNetClientKeepAliveStop(priv->client);
- ret = 0;
+ return 0;
}
-
- cleanup:
- remoteDriverUnlock(priv);
- return ret;
}
{
struct private_data *priv = conn->privateData;
bool ret;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
- remoteDriverLock(priv);
ret = virNetClientIsOpen(priv->client);
- remoteDriverUnlock(priv);
if (ret)
return 1;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_disk_errors_args args;
remote_domain_get_disk_errors_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.maxerrors = maxerrors;
(char *) &args,
(xdrproc_t) xdr_remote_domain_get_disk_errors_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (remoteDeserializeDomainDiskErrors(ret.errors.errors_val,
ret.errors.errors_len,
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_disk_errors_ret, (char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_get_interface_parameters_args args;
remote_domain_get_interface_parameters_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.device = (char *)device;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_INTERFACE_PARAMETERS,
(xdrproc_t) xdr_remote_domain_get_interface_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_interface_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Handle the case when the caller does not know the number of parameters
* and is asking for the number of parameters supported
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_interface_parameters_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_node_get_memory_parameters_args args;
remote_node_get_memory_parameters_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.nparams = *nparams;
args.flags = flags;
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_MEMORY_PARAMETERS,
(xdrproc_t) xdr_remote_node_get_memory_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_node_get_memory_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
/* Handle the case when the caller does not know the number of parameters
* and is asking for the number of parameters supported
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_memory_parameters_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_node_get_sev_info_args args;
remote_node_get_sev_info_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.flags = flags;
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_SEV_INFO,
(xdrproc_t) xdr_remote_node_get_sev_info_args, (char *) &args,
(xdrproc_t) xdr_remote_node_get_sev_info_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_sev_info_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_node_get_cpu_map_args args;
remote_node_get_cpu_map_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.need_map = !!cpumap;
args.need_online = !!online;
(char *) &args,
(xdrproc_t) xdr_remote_node_get_cpu_map_ret,
(char *) &ret) == -1)
- goto done;
+ return -1;
if (ret.ret < 0)
goto cleanup;
cleanup:
xdr_free((xdrproc_t) xdr_remote_node_get_cpu_map_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
int **fdlist,
unsigned int flags)
{
- int rv = -1;
lxc_domain_open_namespace_args args;
struct private_data *priv = domain->conn->privateData;
size_t nfds = 0;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
LXC_PROC_DOMAIN_OPEN_NAMESPACE,
(xdrproc_t) xdr_lxc_domain_open_namespace_args, (char *) &args,
(xdrproc_t) xdr_void, NULL) == -1)
- goto done;
-
- rv = nfds;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return nfds;
}
static int
remote_domain_get_job_stats_args args;
remote_domain_get_job_stats_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_JOB_STATS,
(xdrproc_t) xdr_remote_domain_get_job_stats_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_job_stats_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
*type = ret.type;
cleanup:
xdr_free((xdrproc_t) xdr_remote_domain_get_job_stats_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_domain_migrate_begin3_params_args args;
remote_domain_migrate_begin3_params_ret ret;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- remoteDriverUnlock(priv);
return rv;
error:
remote_domain_migrate_prepare3_params_args args;
remote_domain_migrate_prepare3_params_ret ret;
struct private_data *priv = dconn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
VIR_FREE(ret.uri_out);
- remoteDriverUnlock(priv);
return rv;
error:
remote_domain_migrate_prepare_tunnel3_params_args args;
remote_domain_migrate_prepare_tunnel3_params_ret ret;
virNetClientStream *netst;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- remoteDriverUnlock(priv);
return rv;
error:
remote_domain_migrate_perform3_params_args args;
remote_domain_migrate_perform3_params_ret ret;
struct private_data *priv = dom->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- remoteDriverUnlock(priv);
return rv;
error:
remote_domain_migrate_finish3_params_ret ret;
struct private_data *priv = dconn->privateData;
virDomainPtr rv = NULL;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
memset(&ret, 0, sizeof(ret));
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- remoteDriverUnlock(priv);
return rv;
error:
int rv = -1;
remote_domain_migrate_confirm3_params_args args;
struct private_data *priv = domain->conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.cookie_in.cookie_in_len = cookieinlen;
cleanup:
virTypedParamsRemoteFree((struct _virTypedParameterRemote *) args.params.params_val,
args.params.params_len);
- remoteDriverUnlock(priv);
return rv;
}
struct private_data *priv = conn->privateData;
remote_domain_create_xml_with_files_args args;
remote_domain_create_xml_with_files_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.xml_desc = (char *)xml_desc;
args.flags = flags;
NULL, NULL,
REMOTE_PROC_DOMAIN_CREATE_XML_WITH_FILES,
(xdrproc_t)xdr_remote_domain_create_xml_with_files_args, (char *)&args,
- (xdrproc_t)xdr_remote_domain_create_xml_with_files_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t)xdr_remote_domain_create_xml_with_files_ret, (char *)&ret) == -1)
+ return NULL;
rv = get_nonnull_domain(conn, ret.dom);
xdr_free((xdrproc_t)xdr_remote_domain_create_xml_with_files_ret, (char *)&ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
unsigned int nfiles, int *files,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_create_with_files_args args;
remote_domain_create_with_files_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.flags = flags;
NULL, NULL,
REMOTE_PROC_DOMAIN_CREATE_WITH_FILES,
(xdrproc_t)xdr_remote_domain_create_with_files_args, (char *)&args,
- (xdrproc_t)xdr_remote_domain_create_with_files_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t)xdr_remote_domain_create_with_files_ret, (char *)&ret) == -1)
+ return -1;
dom->id = ret.dom.id;
xdr_free((xdrproc_t) &xdr_remote_domain_create_with_files_ret, (char *) &ret);
- rv = 0;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
static int
unsigned int *nseconds,
unsigned int flags)
{
- int rv = -1;
struct private_data *priv = dom->conn->privateData;
remote_domain_get_time_args args;
remote_domain_get_time_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
args.flags = flags;
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_TIME,
(xdrproc_t) xdr_remote_domain_get_time_args, (char *) &args,
(xdrproc_t) xdr_remote_domain_get_time_ret, (char *) &ret) == -1)
- goto cleanup;
+ return -1;
*seconds = ret.seconds;
*nseconds = ret.nseconds;
xdr_free((xdrproc_t) &xdr_remote_domain_get_time_ret, (char *) &ret);
- rv = 0;
-
- cleanup:
- remoteDriverUnlock(priv);
- return rv;
+ return 0;
}
unsigned long long *counts,
unsigned int flags)
{
- int rv = -1;
remote_node_get_free_pages_args args;
remote_node_get_free_pages_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (npages * cellCount > REMOTE_NODE_MAX_CELLS) {
virReportError(VIR_ERR_RPC,
_("too many NUMA cells: %d > %d"),
npages * cellCount, REMOTE_NODE_MAX_CELLS);
- goto done;
+ return -1;
}
args.pages.pages_val = (u_int *) pages;
if (call(conn, priv, 0, REMOTE_PROC_NODE_GET_FREE_PAGES,
(xdrproc_t) xdr_remote_node_get_free_pages_args, (char *)&args,
(xdrproc_t) xdr_remote_node_get_free_pages_ret, (char *)&ret) == -1)
- goto done;
+ return -1;
memcpy(counts, ret.counts.counts_val, ret.counts.counts_len * sizeof(*counts));
xdr_free((xdrproc_t) xdr_remote_node_get_free_pages_ret, (char *) &ret);
- rv = ret.counts.counts_len;
-
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return ret.counts.counts_len;
}
struct private_data *priv = net->conn->privateData;
remote_network_get_dhcp_leases_args args;
remote_network_get_dhcp_leases_ret ret;
-
virNetworkDHCPLeasePtr *leases_ret = NULL;
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_network(&args.net, net);
args.mac = mac ? (char **) &mac : NULL;
if (call(net->conn, priv, 0, REMOTE_PROC_NETWORK_GET_DHCP_LEASES,
(xdrproc_t)xdr_remote_network_get_dhcp_leases_args, (char *)&args,
(xdrproc_t)xdr_remote_network_get_dhcp_leases_ret, (char *)&ret) == -1)
- goto done;
+ return -1;
if (ret.leases.leases_len > REMOTE_NETWORK_DHCP_LEASES_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
xdr_free((xdrproc_t)xdr_remote_network_get_dhcp_leases_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
remote_connect_get_all_domain_stats_ret ret;
virDomainStatsRecordPtr elem = NULL;
virDomainStatsRecordPtr *tmpret = NULL;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (ndoms) {
args.doms.doms_val = g_new0(remote_nonnull_domain, ndoms);
memset(&ret, 0, sizeof(ret));
- remoteDriverLock(priv);
if (call(conn, priv, 0, REMOTE_PROC_CONNECT_GET_ALL_DOMAIN_STATS,
(xdrproc_t)xdr_remote_connect_get_all_domain_stats_args, (char *)&args,
(xdrproc_t)xdr_remote_connect_get_all_domain_stats_ret, (char *)&ret) == -1) {
- remoteDriverUnlock(priv);
goto cleanup;
}
- remoteDriverUnlock(priv);
if (ret.retStats.retStats_len > REMOTE_DOMAIN_LIST_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
unsigned int cellCount,
unsigned int flags)
{
- int rv = -1;
remote_node_alloc_pages_args args;
remote_node_alloc_pages_ret ret;
struct private_data *priv = conn->privateData;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (npages > REMOTE_NODE_MAX_CELLS) {
virReportError(VIR_ERR_RPC,
_("too many NUMA cells: %d > %d"),
npages, REMOTE_NODE_MAX_CELLS);
- goto done;
+ return -1;
}
args.pageSizes.pageSizes_val = (u_int *) pageSizes;
if (call(conn, priv, 0, REMOTE_PROC_NODE_ALLOC_PAGES,
(xdrproc_t) xdr_remote_node_alloc_pages_args, (char *) &args,
(xdrproc_t) xdr_remote_node_alloc_pages_ret, (char *) &ret) == -1)
- goto done;
-
- rv = ret.ret;
+ return -1;
- done:
- remoteDriverUnlock(priv);
- return rv;
+ return ret.ret;
}
remote_domain_get_fsinfo_args args;
remote_domain_get_fsinfo_ret ret;
remote_domain_fsinfo *src;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_FSINFO,
(xdrproc_t)xdr_remote_domain_get_fsinfo_args, (char *)&args,
(xdrproc_t)xdr_remote_domain_get_fsinfo_ret, (char *)&ret) == -1)
- goto done;
+ return -1;
if (ret.info.info_len > REMOTE_DOMAIN_FSINFO_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
cleanup:
xdr_free((xdrproc_t)xdr_remote_domain_get_fsinfo_ret,
(char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
virDomainInterfacePtr *ifaces_ret = NULL;
remote_domain_interface_addresses_args args;
remote_domain_interface_addresses_ret ret;
-
struct private_data *priv = dom->conn->privateData;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
args.source = source;
args.flags = flags;
make_nonnull_domain(&args.dom, dom);
- remoteDriverLock(priv);
-
memset(&ret, 0, sizeof(ret));
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_INTERFACE_ADDRESSES,
(xdrproc_t)xdr_remote_domain_interface_addresses_args,
(char *)&args,
(xdrproc_t)xdr_remote_domain_interface_addresses_ret,
- (char *)&ret) == -1) {
- goto done;
- }
+ (char *)&ret) == -1)
+ return -1;
if (ret.ifaces.ifaces_len > REMOTE_DOMAIN_INTERFACE_MAX) {
virReportError(VIR_ERR_INTERNAL_ERROR,
}
xdr_free((xdrproc_t)xdr_remote_domain_interface_addresses_ret,
(char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
virFreeCallback freecb)
{
struct private_data *priv = conn->privateData;
- int ret = -1;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (virConnectCloseCallbackDataGetCallback(priv->closeCallback) != NULL) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("A close callback is already registered"));
- goto cleanup;
+ return -1;
}
if (priv->serverCloseCallback &&
call(conn, priv, 0, REMOTE_PROC_CONNECT_REGISTER_CLOSE_CALLBACK,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto cleanup;
+ return -1;
virConnectCloseCallbackDataRegister(priv->closeCallback, conn, cb,
opaque, freecb);
- ret = 0;
-
- cleanup:
- remoteDriverUnlock(priv);
-
- return ret;
+ return 0;
}
static int
virConnectCloseFunc cb)
{
struct private_data *priv = conn->privateData;
- int ret = -1;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
if (virConnectCloseCallbackDataGetCallback(priv->closeCallback) != cb) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("A different callback was requested"));
- goto cleanup;
+ return -1;
}
if (priv->serverCloseCallback &&
call(conn, priv, 0, REMOTE_PROC_CONNECT_UNREGISTER_CLOSE_CALLBACK,
(xdrproc_t) xdr_void, (char *) NULL,
(xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto cleanup;
+ return -1;
virConnectCloseCallbackDataUnregister(priv->closeCallback, cb);
- ret = 0;
-
- cleanup:
- remoteDriverUnlock(priv);
-
- return ret;
+ return 0;
}
static int
remote_domain_rename_args args;
remote_domain_rename_ret ret;
char *tmp = NULL;
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
tmp = g_strdup(new_name);
- remoteDriverLock(priv);
-
make_nonnull_domain(&args.dom, dom);
args.new_name = new_name ? (char **)&new_name : NULL;
args.flags = flags;
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_RENAME,
(xdrproc_t)xdr_remote_domain_rename_args, (char *)&args,
- (xdrproc_t)xdr_remote_domain_rename_ret, (char *)&ret) == -1) {
- goto done;
- }
+ (xdrproc_t)xdr_remote_domain_rename_ret, (char *)&ret) == -1)
+ return -1;
rv = ret.retcode;
dom->name = g_steal_pointer(&tmp);
}
- done:
- remoteDriverUnlock(priv);
VIR_FREE(tmp);
return rv;
}
struct private_data *priv = port->net->conn->privateData;
remote_network_port_get_parameters_args args;
remote_network_port_get_parameters_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_network_port(&args.port, port);
args.flags = flags;
if (call(port->net->conn, priv, 0, REMOTE_PROC_NETWORK_PORT_GET_PARAMETERS,
(xdrproc_t) xdr_remote_network_port_get_parameters_args, (char *) &args,
(xdrproc_t) xdr_remote_network_port_get_parameters_ret, (char *) &ret) == -1)
- goto done;
+ return -1;
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
cleanup:
xdr_free((xdrproc_t) xdr_remote_network_port_get_parameters_ret, (char *) &ret);
- done:
- remoteDriverUnlock(priv);
return rv;
}
struct private_data *priv = dom->conn->privateData;
remote_domain_get_guest_info_args args;
remote_domain_get_guest_info_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, dom);
if (call(dom->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_GUEST_INFO,
(xdrproc_t)xdr_remote_domain_get_guest_info_args, (char *)&args,
(xdrproc_t)xdr_remote_domain_get_guest_info_ret, (char *)&ret) == -1)
- goto done;
+ return -1;
if (virTypedParamsDeserialize((struct _virTypedParameterRemote *) ret.params.params_val,
ret.params.params_len,
cleanup:
xdr_free((xdrproc_t)xdr_remote_domain_get_guest_info_ret,
(char *) &ret);
-
- done:
- remoteDriverUnlock(priv);
return rv;
}
struct private_data *priv = domain->conn->privateData;
remote_domain_authorized_ssh_keys_get_args args;
remote_domain_authorized_ssh_keys_get_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.user = (char *) user;
if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_AUTHORIZED_SSH_KEYS_GET,
(xdrproc_t) xdr_remote_domain_authorized_ssh_keys_get_args, (char *)&args,
- (xdrproc_t) xdr_remote_domain_authorized_ssh_keys_get_ret, (char *)&ret) == -1) {
- goto cleanup;
- }
+ (xdrproc_t) xdr_remote_domain_authorized_ssh_keys_get_ret, (char *)&ret) == -1)
+ return -1;
if (ret.keys.keys_len > REMOTE_DOMAIN_AUTHORIZED_SSH_KEYS_MAX) {
virReportError(VIR_ERR_RPC, "%s",
rv = ret.keys.keys_len;
cleanup:
- remoteDriverUnlock(priv);
xdr_free((xdrproc_t)xdr_remote_domain_authorized_ssh_keys_get_ret,
(char *) &ret);
return rv;
struct private_data *priv = domain->conn->privateData;
remote_domain_get_messages_args args;
remote_domain_get_messages_ret ret;
-
- remoteDriverLock(priv);
+ VIR_LOCK_GUARD lock = remoteDriverLock(priv);
make_nonnull_domain(&args.dom, domain);
args.flags = flags;
rv = ret.msgs.msgs_len;
cleanup:
- remoteDriverUnlock(priv);
xdr_free((xdrproc_t)xdr_remote_domain_get_messages_ret,
(char *) &ret);
return rv;
projects / libvirt.git / commitdiff