External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-22 03:12:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu: remove dbus-vmstate code

Browse Source 
This code was based on a per-helper instance and peer-to-peer
connections. The code that landed in qemu master for v5.0 is relying
on a single instance and DBus bus.

Instead of trying to adapt the existing dbus-vmstate code, let's
remove it and resubmit. That should make reviewing easier.

Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
This commit is contained in:
Marc-André Lureau 2020-02-25 10:55:05 +01:00 committed by Michal Privoznik
parent 463379af87
commit 62f696c333
16 changed files with 7 additions and 486 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
po/POTFILES.in
View File

@ -150,7 +150,6 @@
@SRCDIR@/src/qemu/qemu_checkpoint.c
@SRCDIR@/src/qemu/qemu_command.c
@SRCDIR@/src/qemu/qemu_conf.c
@SRCDIR@/src/qemu/qemu_dbus.c
@SRCDIR@/src/qemu/qemu_domain.c
@SRCDIR@/src/qemu/qemu_domain_address.c
@SRCDIR@/src/qemu/qemu_driver.c

2
src/qemu/Makefile.inc.am
View File

@ -13,8 +13,6 @@ QEMU_DRIVER_SOURCES = \
qemu/qemu_capabilities.h \
qemu/qemu_command.c \
qemu/qemu_command.h \
qemu/qemu_dbus.c \
qemu/qemu_dbus.h \
qemu/qemu_domain.c \
qemu/qemu_domain.h \
qemu/qemu_domain_address.c \

16
src/qemu/qemu_alias.c
View File

@ -829,19 +829,3 @@ qemuDomainGetUnmanagedPRAlias(const char *parentalias)
return ret;
}
char *
qemuAliasDBusVMStateFromId(const char *id)
{
char *ret;
size_t i;
ret = g_strdup_printf("dbus-vms-%s", id);
for (i = 0; ret[i]; i++) {
if (ret[i] == ':')
ret[i] = '_';
}
return ret;
}

3
src/qemu/qemu_alias.h
View File

@ -95,6 +95,3 @@ char *qemuAliasChardevFromDevAlias(const char *devAlias)
const char *qemuDomainGetManagedPRAlias(void);
char *qemuDomainGetUnmanagedPRAlias(const char *parentalias);
char *qemuAliasDBusVMStateFromId(const char *id)
ATTRIBUTE_NONNULL(1);

83
src/qemu/qemu_command.c
View File

@ -27,7 +27,6 @@
#include "qemu_interface.h"
#include "qemu_alias.h"
#include "qemu_security.h"
#include "qemu_dbus.h"
#include "qemu_slirp.h"
#include "qemu_block.h"
#include "cpu/cpu.h"
@ -9571,85 +9570,6 @@ qemuBuildPflashBlockdevCommandLine(virCommandPtr cmd,
}
static virJSONValuePtr
qemuBuildDBusVMStateInfoPropsInternal(const char *alias,
const char *addr)
{
virJSONValuePtr ret = NULL;
if (qemuMonitorCreateObjectProps(&ret,
"dbus-vmstate", alias,
"s:addr", addr, NULL) < 0)
return NULL;
return ret;
}
virJSONValuePtr
qemuBuildDBusVMStateInfoProps(const char *id,
const char *addr)
{
g_autofree char *alias = qemuAliasDBusVMStateFromId(id);
if (!alias)
return NULL;
return qemuBuildDBusVMStateInfoPropsInternal(alias, addr);
}
typedef struct qemuBuildDBusVMStateCommandLineData {
virCommandPtr cmd;
} qemuBuildDBusVMStateCommandLineData;
static int
qemuBuildDBusVMStateCommandLineEach(void *payload,
const void *id,
void *user_data)
{
qemuBuildDBusVMStateCommandLineData *data = user_data;
qemuDBusVMStatePtr vms = payload;
g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
g_autoptr(virJSONValue) props = NULL;
if (!(props = qemuBuildDBusVMStateInfoProps(id, vms->addr)))
return -1;
if (virQEMUBuildObjectCommandlineFromJSON(&buf, props) < 0)
return -1;
virCommandAddArg(data->cmd, "-object");
virCommandAddArgBuffer(data->cmd, &buf);
return 0;
}
static int
qemuBuildDBusVMStateCommandLine(virCommandPtr cmd,
qemuDomainObjPrivatePtr priv)
{
qemuBuildDBusVMStateCommandLineData data = {
.cmd = cmd,
};
if (virHashSize(priv->dbusVMStates) == 0)
return 0;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("dbus-vmstate object is not supported by this QEMU binary"));
return 0;
}
if (virHashForEach(priv->dbusVMStates, qemuBuildDBusVMStateCommandLineEach, &data) < 0)
return -1;
return 0;
}
/**
* qemuBuildCommandLineValidate:
*
@ -9881,9 +9801,6 @@ qemuBuildCommandLine(virQEMUDriverPtr driver,
if (qemuBuildMasterKeyCommandLine(cmd, priv) < 0)
return NULL;
if (qemuBuildDBusVMStateCommandLine(cmd, priv) < 0)
return NULL;
if (qemuBuildManagedPRCommandLine(cmd, def, priv) < 0)
return NULL;

3
src/qemu/qemu_command.h
View File

@ -63,9 +63,6 @@ virJSONValuePtr qemuBuildPRManagedManagerInfoProps(qemuDomainObjPrivatePtr priv)
int qemuBuildSecretInfoProps(qemuDomainSecretInfoPtr secinfo,
virJSONValuePtr *propsret);
virJSONValuePtr qemuBuildDBusVMStateInfoProps(const char *id,
const char *addr);
/* Generate the object properties for a tls-creds-x509 */
int qemuBuildTLSx509BackendProps(const char *tlspath,
bool isListen,

94
src/qemu/qemu_dbus.c
View File

@ -1,94 +0,0 @@
/*
* qemu_dbus.c: QEMU DBus-related helpers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#include <config.h>
#include "qemu_extdevice.h"
#include "qemu_dbus.h"
#include "qemu_hotplug.h"
#include "qemu_security.h"
#include "viralloc.h"
#include "virlog.h"
#include "virstring.h"
#include "virtime.h"
#include "virpidfile.h"
#define VIR_FROM_THIS VIR_FROM_QEMU
VIR_LOG_INIT("qemu.dbus");
qemuDBusVMStatePtr
qemuDBusVMStateNew(const char *id, const char *addr)
{
g_autoptr(qemuDBusVMState) self = NULL;
if (VIR_ALLOC(self) < 0)
return NULL;
self->id = g_strdup(id);
self->addr = g_strdup(addr);
return g_steal_pointer(&self);
}
void
qemuDBusVMStateFree(qemuDBusVMStatePtr self)
{
if (!self)
return;
VIR_FREE(self->id);
VIR_FREE(self->addr);
VIR_FREE(self);
}
int
qemuDBusVMStateAdd(virQEMUDriverPtr driver, virDomainObjPtr vm,
const char *id, const char *addr, bool hot)
{
qemuDBusVMStatePtr d = qemuDBusVMStateNew(id, addr);
qemuDomainObjPrivatePtr priv = vm->privateData;
if (virHashAddEntry(priv->dbusVMStates, id, d) < 0) {
qemuDBusVMStateFree(d);
return -1;
}
if (hot && virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE) &&
qemuDomainAttachDBusVMState(driver, vm, id, addr, QEMU_ASYNC_JOB_NONE) < 0)
return -1;
return 0;
}
void
qemuDBusVMStateRemove(virQEMUDriverPtr driver, virDomainObjPtr vm,
const char *id, bool hot)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
if (virHashRemoveEntry(priv->dbusVMStates, id) < 0 ||
(hot && virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE) &&
qemuDomainDetachDBusVMState(driver, vm, id, QEMU_ASYNC_JOB_NONE) < 0))
VIR_ERROR(_("Failed to remove vmstate id '%s'"), vm->def->name);
}

42
src/qemu/qemu_dbus.h
View File

@ -1,42 +0,0 @@
/*
* qemu_dbus.h: QEMU DBus-related helpers
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#pragma once
#include "qemu_conf.h"
#include "qemu_domain.h"
typedef struct _qemuDBusVMState qemuDBusVMState;
typedef qemuDBusVMState *qemuDBusVMStatePtr;
struct _qemuDBusVMState {
char *id;
char *addr;
};
qemuDBusVMStatePtr qemuDBusVMStateNew(const char *id, const char *addr);
void qemuDBusVMStateFree(qemuDBusVMStatePtr self);
int qemuDBusVMStateAdd(virQEMUDriverPtr driver, virDomainObjPtr vm,
const char *id, const char *addr, bool hot);
void qemuDBusVMStateRemove(virQEMUDriverPtr driver, virDomainObjPtr vm,
const char *id, bool hot);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDBusVMState, qemuDBusVMStateFree);

13
src/qemu/qemu_domain.c
View File

@ -26,7 +26,6 @@
#include "qemu_block.h"
#include "qemu_cgroup.h"
#include "qemu_command.h"
#include "qemu_dbus.h"
#include "qemu_process.h"
#include "qemu_capabilities.h"
#include "qemu_hostdev.h"
@ -2170,13 +2169,6 @@ qemuDomainSetPrivatePaths(virQEMUDriverPtr driver,
}
static void
dbusVMStateHashFree(void *opaque)
{
qemuDBusVMStateFree(opaque);
}
int
qemuDomainObjStartWorker(virDomainObjPtr dom)
{
@ -2224,9 +2216,6 @@ qemuDomainObjPrivateAlloc(void *opaque)
if (!(priv->blockjobs = virHashCreate(5, virObjectFreeHashData)))
goto error;
if (!(priv->dbusVMStates = virHashCreate(5, dbusVMStateHashFree)))
goto error;
/* agent commands block by default, user can choose different behavior */
priv->agentTimeout = VIR_DOMAIN_AGENT_RESPONSE_TIMEOUT_BLOCK;
priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
@ -2297,7 +2286,6 @@ qemuDomainObjPrivateDataClear(qemuDomainObjPrivatePtr priv)
priv->migrationCaps = NULL;
virHashRemoveAll(priv->blockjobs);
virHashRemoveAll(priv->dbusVMStates);
virObjectUnref(priv->pflash0);
priv->pflash0 = NULL;
@ -2341,7 +2329,6 @@ qemuDomainObjPrivateFree(void *data)
qemuDomainMasterKeyFree(priv);
virHashFree(priv->blockjobs);
virHashFree(priv->dbusVMStates);
/* This should never be non-NULL if we get here, but just in case... */
if (priv->eventThread) {

1
src/qemu/qemu_domain.h
View File

@ -411,7 +411,6 @@ struct _qemuDomainObjPrivate {
/* running block jobs */
virHashTablePtr blockjobs;
virHashTablePtr dbusVMStates;
bool disableSlirp;
/* Until we add full support for backing chains for pflash drives, these

4
src/qemu/qemu_extdevice.c
View File

@ -190,7 +190,7 @@ qemuExtDevicesStart(virQEMUDriverPtr driver,
qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp &&
qemuSlirpStart(slirp, vm, driver, net, false, incomingMigration) < 0)
qemuSlirpStart(slirp, vm, driver, net, incomingMigration) < 0)
return -1;
}
@ -232,7 +232,7 @@ qemuExtDevicesStop(virQEMUDriverPtr driver,
qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;
if (slirp)
qemuSlirpStop(slirp, vm, driver, net, false);
qemuSlirpStop(slirp, vm, driver, net);
}
for (i = 0; i < def->nfss; i++) {

83
src/qemu/qemu_hotplug.c
View File

@ -404,83 +404,6 @@ qemuHotplugRemoveManagedPR(virQEMUDriverPtr driver,
}
/**
* qemuDomainAttachDBusVMState:
* @driver: QEMU driver object
* @vm: domain object
* @id
* @addr
* @asyncJob: asynchronous job identifier
*
* Add dbus-vmstate object.
*
* Returns: 0 on success, -1 on error.
*/
int
qemuDomainAttachDBusVMState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *id,
const char *addr,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
g_autoptr(virJSONValue) props = NULL;
int ret;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("dbus-vmstate object is not supported by this QEMU binary"));
return -1;
}
if (!(props = qemuBuildDBusVMStateInfoProps(id, addr)))
return -1;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1;
ret = qemuMonitorAddObject(priv->mon, &props, NULL);
if (qemuDomainObjExitMonitor(driver, vm) < 0)
return -1;
return ret;
}
/**
* qemuDomainDetachDBusVMState:
* @driver: QEMU driver object
* @vm: domain object
* @asyncJob: asynchronous job identifier
*
* Remove dbus-vmstate object from @vm.
*
* Returns: 0 on success, -1 on error.
*/
int
qemuDomainDetachDBusVMState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *id,
qemuDomainAsyncJob asyncJob)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
g_autofree char *alias = qemuAliasDBusVMStateFromId(id);
int ret;
if (!alias ||
qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1;
ret = qemuMonitorDelObject(priv->mon, alias, true);
if (qemuDomainObjExitMonitor(driver, vm) < 0)
return -1;
return ret;
}
/**
* qemuDomainChangeMediaBlockdev:
* @driver: qemu driver structure
@ -1312,7 +1235,7 @@ qemuDomainAttachNetDevice(virQEMUDriverPtr driver,
QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
if (qemuSlirpOpen(slirp, driver, vm->def) < 0 ||
qemuSlirpStart(slirp, vm, driver, net, true, NULL) < 0) {
qemuSlirpStart(slirp, vm, driver, net, NULL) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Failed to start slirp"));
goto cleanup;
@ -1519,7 +1442,7 @@ qemuDomainAttachNetDevice(virQEMUDriverPtr driver,
virErrorPreserveLast(&originalError);
netdev_name = g_strdup_printf("host%s", net->info.alias);
if (QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp)
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net, true);
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net);
qemuDomainObjEnterMonitor(driver, vm);
if (charDevPlugged &&
qemuMonitorDetachCharDev(priv->mon, charDevAlias) < 0)
@ -4620,7 +4543,7 @@ qemuDomainRemoveNetDevice(virQEMUDriverPtr driver,
return -1;
if (QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp)
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net, true);
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net);
virDomainAuditNet(vm, net, NULL, "detach", true);

11
src/qemu/qemu_hotplug.h
View File

@ -151,15 +151,4 @@ int qemuDomainSetVcpuInternal(virQEMUDriverPtr driver,
virBitmapPtr vcpus,
bool state);
int qemuDomainAttachDBusVMState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *id,
const char *addr,
qemuDomainAsyncJob asyncJob);
int qemuDomainDetachDBusVMState(virQEMUDriverPtr driver,
virDomainObjPtr vm,
const char *id,
qemuDomainAsyncJob asyncJob);
unsigned long long qemuDomainGetUnplugTimeout(virDomainObjPtr vm);

8
src/qemu/qemu_migration.c
View File

@ -1169,7 +1169,6 @@ qemuMigrationSrcIsAllowed(virQEMUDriverPtr driver,
bool remote,
unsigned int flags)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int nsnapshots;
int pauseReason;
size_t i;
@ -1264,13 +1263,6 @@ qemuMigrationSrcIsAllowed(virQEMUDriverPtr driver,
return false;
}
if (virHashSize(priv->dbusVMStates) > 0 &&
!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain requires dbus-vmstate support"));
return false;
}
for (i = 0; i < vm->def->nnets; i++) {
virDomainNetDefPtr net = vm->def->nets[i];
qemuSlirpPtr slirp = QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp;

125
src/qemu/qemu_slirp.c
View File

@ -18,7 +18,6 @@
#include <config.h>
#include "qemu_dbus.h"
#include "qemu_extdevice.h"
#include "qemu_security.h"
#include "qemu_slirp.h"
@ -203,48 +202,14 @@ qemuSlirpGetFD(qemuSlirpPtr slirp)
}
static char *
qemuSlirpGetDBusVMStateId(virDomainNetDefPtr net)
{
char macstr[VIR_MAC_STRING_BUFLEN] = "";
char *id = NULL;
/* can't use alias, because it's not stable across restarts */
id = g_strdup_printf("slirp-%s", virMacAddrFormat(&net->mac, macstr));
return id;
}
static char *
qemuSlirpGetDBusPath(virQEMUDriverConfigPtr cfg,
const virDomainDef *def,
const char *alias)
{
g_autofree char *shortName = NULL;
char *path = NULL;
if (!(shortName = virDomainDefGetShortName(def)))
return NULL;
path = g_strdup_printf("%s/%s-%s-slirp",
cfg->slirpStateDir, shortName, alias);
return path;
}
void
qemuSlirpStop(qemuSlirpPtr slirp,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
bool hot)
virDomainNetDefPtr net)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autofree char *pidfile = NULL;
g_autofree char *dbus_path = NULL;
g_autofree char *id = qemuSlirpGetDBusVMStateId(net);
virErrorPtr orig_err;
if (!(pidfile = qemuSlirpCreatePidFilename(cfg, vm->def, net->info.alias))) {
@ -252,12 +217,6 @@ qemuSlirpStop(qemuSlirpPtr slirp,
return;
}
if (id) {
qemuDBusVMStateRemove(driver, vm, id, hot);
} else {
VIR_WARN("Unable to construct vmstate id");
}
virErrorPreserveLast(&orig_err);
if (virPidFileForceCleanupPath(pidfile) < 0) {
VIR_WARN("Unable to kill slirp process");
@ -265,18 +224,6 @@ qemuSlirpStop(qemuSlirpPtr slirp,
slirp->pid = 0;
}
dbus_path = qemuSlirpGetDBusPath(cfg, vm->def, net->info.alias);
if (dbus_path) {
if (unlink(dbus_path) < 0 &&
errno != ENOENT) {
virReportSystemError(errno,
_("Unable to remove stale dbus socket %s"),
dbus_path);
}
} else {
VIR_WARN("Unable to construct dbus socket path");
}
virErrorRestore(&orig_err);
}
@ -286,17 +233,12 @@ qemuSlirpStart(qemuSlirpPtr slirp,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
bool hotplug,
bool incoming)
{
g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(driver);
g_autoptr(virCommand) cmd = NULL;
g_autofree char *pidfile = NULL;
g_autofree char *dbus_path = NULL;
g_autofree char *dbus_addr = NULL;
g_autofree char *id = NULL;
size_t i;
const unsigned long long timeout = 5 * 1000; /* ms */
pid_t pid = (pid_t) -1;
int rc;
int exitstatus = 0;
@ -360,29 +302,6 @@ qemuSlirpStart(qemuSlirpPtr slirp,
}
}
if (qemuSlirpHasFeature(slirp, QEMU_SLIRP_FEATURE_DBUS_P2P)) {
if (!(id = qemuSlirpGetDBusVMStateId(net)))
return -1;
if (!(dbus_path = qemuSlirpGetDBusPath(cfg, vm->def, net->info.alias)))
return -1;
if (unlink(dbus_path) < 0 && errno != ENOENT) {
virReportSystemError(errno, _("Unable to unlink %s"), dbus_path);
return -1;
}
dbus_addr = g_strdup_printf("unix:path=%s", dbus_path);
virCommandAddArgFormat(cmd, "--dbus-id=%s", id);
virCommandAddArgFormat(cmd, "--dbus-p2p=%s", dbus_addr);
if (incoming &&
qemuSlirpHasFeature(slirp, QEMU_SLIRP_FEATURE_MIGRATE))
virCommandAddArg(cmd, "--dbus-incoming");
}
if (qemuSlirpHasFeature(slirp, QEMU_SLIRP_FEATURE_EXIT_WITH_PARENT))
virCommandAddArg(cmd, "--exit-with-parent");
@ -406,46 +325,6 @@ qemuSlirpStart(qemuSlirpPtr slirp,
goto error;
}
if (dbus_path) {
virTimeBackOffVar timebackoff;
if (virTimeBackOffStart(&timebackoff, 1, timeout) < 0)
goto error;
while (virTimeBackOffWait(&timebackoff)) {
char errbuf[1024] = { 0 };
if (virFileExists(dbus_path))
break;
if (virProcessKill(pid, 0) == 0)
continue;
if (saferead(errfd, errbuf, sizeof(errbuf) - 1) < 0) {
virReportSystemError(errno,
_("slirp helper %s died unexpectedly"),
cfg->prHelperName);
} else {
virReportError(VIR_ERR_OPERATION_FAILED,
_("slirp helper died and reported: %s"), errbuf);
}
goto error;
}
if (!virFileExists(dbus_path)) {
virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s",
_("slirp dbus socket did not show up"));
goto error;
}
}
if (qemuSlirpHasFeature(slirp, QEMU_SLIRP_FEATURE_MIGRATE) &&
qemuDBusVMStateAdd(driver, vm, id, dbus_addr, hotplug) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Failed to register slirp migration"));
goto error;
}
slirp->pid = pid;
return 0;
@ -454,7 +333,5 @@ qemuSlirpStart(qemuSlirpPtr slirp,
virProcessKillPainfully(pid, true);
if (pidfile)
unlink(pidfile);
if (dbus_path)
unlink(dbus_path);
return -1;
}

4
src/qemu/qemu_slirp.h
View File

@ -66,14 +66,12 @@ int qemuSlirpStart(qemuSlirpPtr slirp,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
bool hot,
bool incoming);
void qemuSlirpStop(qemuSlirpPtr slirp,
virDomainObjPtr vm,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
bool hot);
virDomainNetDefPtr net);
int qemuSlirpGetFD(qemuSlirpPtr slirp);