External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-01-09 06:25:19 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Make autodestroy utilize connection close callbacks

Browse Source
This commit is contained in:
Jiri Denemark 2012-03-19 14:31:41 +01:00
parent 791273603e
commit 527d867a94
3 changed files with 24 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/qemu/qemu_conf.h
View File

@ -141,11 +141,6 @@ struct qemud_driver {
virLockManagerPluginPtr lockManager;
/* Mapping of 'char *uuidstr' -> virConnectPtr
* of guests which will be automatically killed
* when the virConnectPtr is closed*/
virHashTablePtr autodestroy;
/* Mapping of 'char *uuidstr' -> qemuDriverCloseDefPtr of domains
* which want a specific cleanup to be done when a connection is
* closed. Such cleanup may be to automatically destroy the

5
src/qemu/qemu_driver.c
View File

@ -659,9 +659,6 @@ qemudStartup(int privileged) {
qemu_driver->hugepage_path = mempath;
}
if (qemuProcessAutoDestroyInit(qemu_driver) < 0)
goto error;
if (qemuDriverCloseCallbackInit(qemu_driver) < 0)
goto error;
@ -803,7 +800,6 @@ qemudShutdown(void) {
virSysinfoDefFree(qemu_driver->hostsysinfo);
qemuProcessAutoDestroyShutdown(qemu_driver);
qemuDriverCloseCallbackShutdown(qemu_driver);
VIR_FREE(qemu_driver->configDir);
@ -925,7 +921,6 @@ static int qemudClose(virConnectPtr conn) {
qemuDriverLock(driver);
virDomainEventStateDeregisterConn(conn,
driver->domainEventState);
qemuProcessAutoDestroyRun(driver, conn);
qemuDriverCloseCallbackRunAll(driver, conn);
qemuDriverUnlock(driver);

107
src/qemu/qemu_process.c
View File

@ -4120,124 +4120,65 @@ cleanup:
}
int qemuProcessAutoDestroyInit(struct qemud_driver *driver)
static virDomainObjPtr
qemuProcessAutoDestroy(struct qemud_driver *driver,
virDomainObjPtr dom,
virConnectPtr conn)
{
if (!(driver->autodestroy = virHashCreate(5, NULL)))
return -1;
return 0;
}
struct qemuProcessAutoDestroyData {
struct qemud_driver *driver;
virConnectPtr conn;
};
static void qemuProcessAutoDestroyDom(void *payload,
const void *name,
void *opaque)
{
struct qemuProcessAutoDestroyData *data = opaque;
virConnectPtr conn = payload;
const char *uuidstr = name;
unsigned char uuid[VIR_UUID_BUFLEN];
virDomainObjPtr dom;
qemuDomainObjPrivatePtr priv;
qemuDomainObjPrivatePtr priv = dom->privateData;
virDomainEventPtr event = NULL;
VIR_DEBUG("conn=%p uuidstr=%s thisconn=%p", conn, uuidstr, data->conn);
VIR_DEBUG("vm=%s, conn=%p", dom->def->name, conn);
if (data->conn != conn)
return;
if (virUUIDParse(uuidstr, uuid) < 0) {
VIR_WARN("Failed to parse %s", uuidstr);
return;
}
if (!(dom = virDomainFindByUUID(&data->driver->domains,
uuid))) {
VIR_DEBUG("No domain object to kill");
return;
}
priv = dom->privateData;
if (priv->job.asyncJob) {
VIR_DEBUG("vm=%s has long-term job active, cancelling",
dom->def->name);
qemuDomainObjDiscardAsyncJob(data->driver, dom);
qemuDomainObjDiscardAsyncJob(driver, dom);
}
if (qemuDomainObjBeginJobWithDriver(data->driver, dom,
if (qemuDomainObjBeginJobWithDriver(driver, dom,
QEMU_JOB_DESTROY) < 0)
goto cleanup;
VIR_DEBUG("Killing domain");
qemuProcessStop(data->driver, dom, 1, VIR_DOMAIN_SHUTOFF_DESTROYED);
qemuProcessStop(driver, dom, 1, VIR_DOMAIN_SHUTOFF_DESTROYED);
virDomainAuditStop(dom, "destroyed");
event = virDomainEventNewFromObj(dom,
VIR_DOMAIN_EVENT_STOPPED,
VIR_DOMAIN_EVENT_STOPPED_DESTROYED);
if (qemuDomainObjEndJob(data->driver, dom) == 0)
if (qemuDomainObjEndJob(driver, dom) == 0)
dom = NULL;
if (dom && !dom->persistent)
qemuDomainRemoveInactive(data->driver, dom);
qemuDomainRemoveInactive(driver, dom);
if (event)
qemuDomainEventQueue(driver, event);
cleanup:
if (dom)
virDomainObjUnlock(dom);
if (event)
qemuDomainEventQueue(data->driver, event);
virHashRemoveEntry(data->driver->autodestroy, uuidstr);
}
/*
* Precondition: driver is locked
*/
void qemuProcessAutoDestroyRun(struct qemud_driver *driver, virConnectPtr conn)
{
struct qemuProcessAutoDestroyData data = {
driver, conn
};
VIR_DEBUG("conn=%p", conn);
virHashForEach(driver->autodestroy, qemuProcessAutoDestroyDom, &data);
}
void qemuProcessAutoDestroyShutdown(struct qemud_driver *driver)
{
virHashFree(driver->autodestroy);
return dom;
}
int qemuProcessAutoDestroyAdd(struct qemud_driver *driver,
virDomainObjPtr vm,
virConnectPtr conn)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s uuid=%s conn=%p", vm->def->name, uuidstr, conn);
if (virHashAddEntry(driver->autodestroy, uuidstr, conn) < 0)
return -1;
return 0;
VIR_DEBUG("vm=%s, conn=%p", vm->def->name, conn);
return qemuDriverCloseCallbackSet(driver, vm, conn,
qemuProcessAutoDestroy);
}
int qemuProcessAutoDestroyRemove(struct qemud_driver *driver,
virDomainObjPtr vm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s uuid=%s", vm->def->name, uuidstr);
if (virHashRemoveEntry(driver->autodestroy, uuidstr) < 0)
return -1;
return 0;
VIR_DEBUG("vm=%s", vm->def->name);
return qemuDriverCloseCallbackUnset(driver, vm, qemuProcessAutoDestroy);
}
bool qemuProcessAutoDestroyActive(struct qemud_driver *driver,
virDomainObjPtr vm)
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s uuid=%s", vm->def->name, uuidstr);
if (virHashLookup(driver->autodestroy, uuidstr) != NULL)
return true;
return false;
qemuDriverCloseCallback cb;
VIR_DEBUG("vm=%s", vm->def->name);
cb = qemuDriverCloseCallbackGet(driver, vm, NULL);
return cb == qemuProcessAutoDestroy;
}