NuKVM/libvirt
3
0
Fork 0
mirror of https://github.com/libvirt/libvirt.git synced 2025-02-25 18:55:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Always set async job when starting a domain

Browse Source 
We only started an async job for incoming migration from another host.
When we were starting a domain from scratch or restoring from a saved
state (migration from file) we didn't set any async job. Let's introduce
a new QEMU_ASYNC_JOB_START for these cases.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
This commit is contained in:
Jiri Denemark 2015-10-21 10:55:43 +02:00
parent 2bf5333f45
commit 04c721f22d
5 changed files with 85 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/qemu/qemu_domain.c
View File

@ -73,6 +73,7 @@ VIR_ENUM_IMPL(qemuDomainAsyncJob, QEMU_ASYNC_JOB_LAST,
"save", "save",
"dump", "dump",
"snapshot", "snapshot",
"start",
); );
@ -88,6 +89,7 @@ qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
case QEMU_ASYNC_JOB_SAVE: case QEMU_ASYNC_JOB_SAVE:
case QEMU_ASYNC_JOB_DUMP: case QEMU_ASYNC_JOB_DUMP:
case QEMU_ASYNC_JOB_SNAPSHOT: case QEMU_ASYNC_JOB_SNAPSHOT:
case QEMU_ASYNC_JOB_START:
case QEMU_ASYNC_JOB_NONE: case QEMU_ASYNC_JOB_NONE:
case QEMU_ASYNC_JOB_LAST: case QEMU_ASYNC_JOB_LAST:
; /* fall through */ ; /* fall through */
@ -111,6 +113,7 @@ qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
case QEMU_ASYNC_JOB_SAVE: case QEMU_ASYNC_JOB_SAVE:
case QEMU_ASYNC_JOB_DUMP: case QEMU_ASYNC_JOB_DUMP:
case QEMU_ASYNC_JOB_SNAPSHOT: case QEMU_ASYNC_JOB_SNAPSHOT:
case QEMU_ASYNC_JOB_START:
case QEMU_ASYNC_JOB_NONE: case QEMU_ASYNC_JOB_NONE:
case QEMU_ASYNC_JOB_LAST: case QEMU_ASYNC_JOB_LAST:
; /* fall through */ ; /* fall through */

1
src/qemu/qemu_domain.h
View File

@ -90,6 +90,7 @@ typedef enum {
QEMU_ASYNC_JOB_SAVE, QEMU_ASYNC_JOB_SAVE,
QEMU_ASYNC_JOB_DUMP, QEMU_ASYNC_JOB_DUMP,
QEMU_ASYNC_JOB_SNAPSHOT, QEMU_ASYNC_JOB_SNAPSHOT,
QEMU_ASYNC_JOB_START,
QEMU_ASYNC_JOB_LAST QEMU_ASYNC_JOB_LAST
} qemuDomainAsyncJob; } qemuDomainAsyncJob;

72
src/qemu/qemu_driver.c
View File

@ -155,7 +155,8 @@ static int qemuStateCleanup(void);
static int qemuDomainObjStart(virConnectPtr conn, static int qemuDomainObjStart(virConnectPtr conn,
virQEMUDriverPtr driver, virQEMUDriverPtr driver,
virDomainObjPtr vm, virDomainObjPtr vm,
unsigned int flags); unsigned int flags,
qemuDomainAsyncJob asyncJob);
static int qemuDomainGetMaxVcpus(virDomainPtr dom); static int qemuDomainGetMaxVcpus(virDomainPtr dom);
@ -287,8 +288,7 @@ qemuAutostartDomain(virDomainObjPtr vm,
virResetLastError(); virResetLastError();
if (vm->autostart && if (vm->autostart &&
!virDomainObjIsActive(vm)) { !virDomainObjIsActive(vm)) {
if (qemuDomainObjBeginJob(data->driver, vm, if (qemuProcessBeginJob(data->driver, vm) < 0) {
QEMU_JOB_MODIFY) < 0) {
err = virGetLastError(); err = virGetLastError();
VIR_ERROR(_("Failed to start job on VM '%s': %s"), VIR_ERROR(_("Failed to start job on VM '%s': %s"),
vm->def->name, vm->def->name,
@ -296,14 +296,15 @@ qemuAutostartDomain(virDomainObjPtr vm,
goto cleanup; goto cleanup;
} }
if (qemuDomainObjStart(data->conn, data->driver, vm, flags) < 0) { if (qemuDomainObjStart(data->conn, data->driver, vm, flags,
QEMU_ASYNC_JOB_START) < 0) {
err = virGetLastError(); err = virGetLastError();
VIR_ERROR(_("Failed to autostart VM '%s': %s"), VIR_ERROR(_("Failed to autostart VM '%s': %s"),
vm->def->name, vm->def->name,
err ? err->message : _("unknown error")); err ? err->message : _("unknown error"));
} }
qemuDomainObjEndJob(data->driver, vm); qemuProcessEndJob(data->driver, vm);
} }
ret = 0; ret = 0;
@ -1754,17 +1755,17 @@ static virDomainPtr qemuDomainCreateXML(virConnectPtr conn,
virObjectRef(vm); virObjectRef(vm);
def = NULL; def = NULL;
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) { if (qemuProcessBeginJob(driver, vm) < 0) {
qemuDomainRemoveInactive(driver, vm); qemuDomainRemoveInactive(driver, vm);
goto cleanup; goto cleanup;
} }
if (qemuProcessStart(conn, driver, vm, QEMU_ASYNC_JOB_NONE, if (qemuProcessStart(conn, driver, vm, QEMU_ASYNC_JOB_START,
NULL, -1, NULL, NULL, NULL, -1, NULL, NULL,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
start_flags) < 0) { start_flags) < 0) {
virDomainAuditStart(vm, "booted", false); virDomainAuditStart(vm, "booted", false);
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
qemuDomainRemoveInactive(driver, vm); qemuDomainRemoveInactive(driver, vm);
goto cleanup; goto cleanup;
} }
@ -1788,7 +1789,7 @@ static virDomainPtr qemuDomainCreateXML(virConnectPtr conn,
if (dom) if (dom)
dom->id = vm->def->id; dom->id = vm->def->id;
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
cleanup: cleanup:
virDomainDefFree(def); virDomainDefFree(def);
@ -6634,7 +6635,8 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
int *fd, int *fd,
const virQEMUSaveHeader *header, const virQEMUSaveHeader *header,
const char *path, const char *path,
bool start_paused) bool start_paused,
qemuDomainAsyncJob asyncJob)
{ {
int ret = -1; int ret = -1;
virObjectEventPtr event; virObjectEventPtr event;
@ -6663,7 +6665,7 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
} }
/* Set the migration source and start it up. */ /* Set the migration source and start it up. */
ret = qemuProcessStart(conn, driver, vm, QEMU_ASYNC_JOB_NONE, ret = qemuProcessStart(conn, driver, vm, asyncJob,
"stdio", *fd, path, NULL, "stdio", *fd, path, NULL,
VIR_NETDEV_VPORT_PROFILE_OP_RESTORE, VIR_NETDEV_VPORT_PROFILE_OP_RESTORE,
VIR_QEMU_PROCESS_START_PAUSED); VIR_QEMU_PROCESS_START_PAUSED);
@ -6707,7 +6709,7 @@ qemuDomainSaveImageStartVM(virConnectPtr conn,
if (header->was_running && !start_paused) { if (header->was_running && !start_paused) {
if (qemuProcessStartCPUs(driver, vm, conn, if (qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_RESTORED, VIR_DOMAIN_RUNNING_RESTORED,
QEMU_ASYNC_JOB_NONE) < 0) { asyncJob) < 0) {
if (virGetLastError() == NULL) if (virGetLastError() == NULL)
virReportError(VIR_ERR_OPERATION_FAILED, virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("failed to resume domain")); "%s", _("failed to resume domain"));
@ -6819,15 +6821,15 @@ qemuDomainRestoreFlags(virConnectPtr conn,
priv->hookRun = true; priv->hookRun = true;
} }
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) if (qemuProcessBeginJob(driver, vm) < 0)
goto cleanup; goto cleanup;
ret = qemuDomainSaveImageStartVM(conn, driver, vm, &fd, &header, path, ret = qemuDomainSaveImageStartVM(conn, driver, vm, &fd, &header, path,
false); false, QEMU_ASYNC_JOB_START);
if (virFileWrapperFdClose(wrapperFd) < 0) if (virFileWrapperFdClose(wrapperFd) < 0)
VIR_WARN("Failed to close %s", path); VIR_WARN("Failed to close %s", path);
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
cleanup: cleanup:
virDomainDefFree(def); virDomainDefFree(def);
@ -6970,7 +6972,8 @@ qemuDomainObjRestore(virConnectPtr conn,
virDomainObjPtr vm, virDomainObjPtr vm,
const char *path, const char *path,
bool start_paused, bool start_paused,
bool bypass_cache) bool bypass_cache,
qemuDomainAsyncJob asyncJob)
{ {
virDomainDefPtr def = NULL; virDomainDefPtr def = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
@ -7030,7 +7033,7 @@ qemuDomainObjRestore(virConnectPtr conn,
def = NULL; def = NULL;
ret = qemuDomainSaveImageStartVM(conn, driver, vm, &fd, &header, path, ret = qemuDomainSaveImageStartVM(conn, driver, vm, &fd, &header, path,
start_paused); start_paused, asyncJob);
if (virFileWrapperFdClose(wrapperFd) < 0) if (virFileWrapperFdClose(wrapperFd) < 0)
VIR_WARN("Failed to close %s", path); VIR_WARN("Failed to close %s", path);
@ -7325,7 +7328,8 @@ static int
qemuDomainObjStart(virConnectPtr conn, qemuDomainObjStart(virConnectPtr conn,
virQEMUDriverPtr driver, virQEMUDriverPtr driver,
virDomainObjPtr vm, virDomainObjPtr vm,
unsigned int flags) unsigned int flags,
qemuDomainAsyncJob asyncJob)
{ {
int ret = -1; int ret = -1;
char *managed_save; char *managed_save;
@ -7358,7 +7362,7 @@ qemuDomainObjStart(virConnectPtr conn,
vm->hasManagedSave = false; vm->hasManagedSave = false;
} else { } else {
ret = qemuDomainObjRestore(conn, driver, vm, managed_save, ret = qemuDomainObjRestore(conn, driver, vm, managed_save,
start_paused, bypass_cache); start_paused, bypass_cache, asyncJob);
if (ret == 0) { if (ret == 0) {
if (unlink(managed_save) < 0) if (unlink(managed_save) < 0)
@ -7377,7 +7381,7 @@ qemuDomainObjStart(virConnectPtr conn,
} }
} }
ret = qemuProcessStart(conn, driver, vm, QEMU_ASYNC_JOB_NONE, ret = qemuProcessStart(conn, driver, vm, asyncJob,
NULL, -1, NULL, NULL, NULL, -1, NULL, NULL,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags); VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags);
virDomainAuditStart(vm, "booted", ret >= 0); virDomainAuditStart(vm, "booted", ret >= 0);
@ -7422,7 +7426,7 @@ qemuDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0) if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup; goto cleanup;
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) if (qemuProcessBeginJob(driver, vm) < 0)
goto cleanup; goto cleanup;
if (virDomainObjIsActive(vm)) { if (virDomainObjIsActive(vm)) {
@ -7431,13 +7435,14 @@ qemuDomainCreateWithFlags(virDomainPtr dom, unsigned int flags)
goto endjob; goto endjob;
} }
if (qemuDomainObjStart(dom->conn, driver, vm, flags) < 0) if (qemuDomainObjStart(dom->conn, driver, vm, flags,
QEMU_ASYNC_JOB_START) < 0)
goto endjob; goto endjob;
ret = 0; ret = 0;
endjob: endjob:
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
cleanup: cleanup:
virDomainObjEndAPI(&vm); virDomainObjEndAPI(&vm);
@ -15334,7 +15339,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
goto cleanup; goto cleanup;
} }
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0) if (qemuProcessBeginJob(driver, vm) < 0)
goto cleanup; goto cleanup;
if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot))) if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
@ -15439,7 +15444,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
was_running = true; was_running = true;
if (qemuProcessStopCPUs(driver, vm, if (qemuProcessStopCPUs(driver, vm,
VIR_DOMAIN_PAUSED_FROM_SNAPSHOT, VIR_DOMAIN_PAUSED_FROM_SNAPSHOT,
QEMU_ASYNC_JOB_NONE) < 0) QEMU_ASYNC_JOB_START) < 0)
goto endjob; goto endjob;
/* Create an event now in case the restore fails, so /* Create an event now in case the restore fails, so
* that user will be alerted that they are now paused. * that user will be alerted that they are now paused.
@ -15454,7 +15459,10 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
goto endjob; goto endjob;
} }
} }
qemuDomainObjEnterMonitor(driver, vm);
if (qemuDomainObjEnterMonitorAsync(driver, vm,
QEMU_ASYNC_JOB_START) < 0)
goto endjob;
rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name); rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name);
if (qemuDomainObjExitMonitor(driver, vm) < 0) if (qemuDomainObjExitMonitor(driver, vm) < 0)
goto endjob; goto endjob;
@ -15473,7 +15481,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
virDomainObjAssignDef(vm, config, false, NULL); virDomainObjAssignDef(vm, config, false, NULL);
rc = qemuProcessStart(snapshot->domain->conn, driver, vm, rc = qemuProcessStart(snapshot->domain->conn, driver, vm,
QEMU_ASYNC_JOB_NONE, NULL, -1, NULL, snap, QEMU_ASYNC_JOB_START, NULL, -1, NULL, snap,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
VIR_QEMU_PROCESS_START_PAUSED); VIR_QEMU_PROCESS_START_PAUSED);
virDomainAuditStart(vm, "from-snapshot", rc >= 0); virDomainAuditStart(vm, "from-snapshot", rc >= 0);
@ -15508,7 +15516,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
} }
rc = qemuProcessStartCPUs(driver, vm, snapshot->domain->conn, rc = qemuProcessStartCPUs(driver, vm, snapshot->domain->conn,
VIR_DOMAIN_RUNNING_FROM_SNAPSHOT, VIR_DOMAIN_RUNNING_FROM_SNAPSHOT,
QEMU_ASYNC_JOB_NONE); QEMU_ASYNC_JOB_START);
if (rc < 0) if (rc < 0)
goto endjob; goto endjob;
virObjectUnref(event); virObjectUnref(event);
@ -15549,7 +15557,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
} }
if (qemuDomainSnapshotRevertInactive(driver, vm, snap) < 0) { if (qemuDomainSnapshotRevertInactive(driver, vm, snap) < 0) {
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
qemuDomainRemoveInactive(driver, vm); qemuDomainRemoveInactive(driver, vm);
goto cleanup; goto cleanup;
} }
@ -15566,12 +15574,12 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
qemuDomainEventQueue(driver, event); qemuDomainEventQueue(driver, event);
rc = qemuProcessStart(snapshot->domain->conn, driver, vm, rc = qemuProcessStart(snapshot->domain->conn, driver, vm,
QEMU_ASYNC_JOB_NONE, NULL, -1, NULL, NULL, QEMU_ASYNC_JOB_START, NULL, -1, NULL, NULL,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, VIR_NETDEV_VPORT_PROFILE_OP_CREATE,
start_flags); start_flags);
virDomainAuditStart(vm, "from-snapshot", rc >= 0); virDomainAuditStart(vm, "from-snapshot", rc >= 0);
if (rc < 0) { if (rc < 0) {
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
qemuDomainRemoveInactive(driver, vm); qemuDomainRemoveInactive(driver, vm);
goto cleanup; goto cleanup;
} }
@ -15607,7 +15615,7 @@ qemuDomainRevertToSnapshot(virDomainSnapshotPtr snapshot,
ret = 0; ret = 0;
endjob: endjob:
qemuDomainObjEndJob(driver, vm); qemuProcessEndJob(driver, vm);
cleanup: cleanup:
if (ret == 0) { if (ret == 0) {

36
src/qemu/qemu_process.c
View File

@ -3412,6 +3412,10 @@ qemuProcessRecoverJob(virQEMUDriverPtr driver,
} }
break; break;
case QEMU_ASYNC_JOB_START:
/* Already handled in VIR_DOMAIN_PAUSED_STARTING_UP check. */
break;
case QEMU_ASYNC_JOB_NONE: case QEMU_ASYNC_JOB_NONE:
case QEMU_ASYNC_JOB_LAST: case QEMU_ASYNC_JOB_LAST:
break; break;
@ -4202,10 +4206,40 @@ qemuProcessIncomingDefNew(virQEMUCapsPtr qemuCaps,
} }
/*
* This function starts a new QEMU_ASYNC_JOB_START async job. The user is
* responsible for calling qemuProcessEndJob to stop this job and for passing
* QEMU_ASYNC_JOB_START as @asyncJob argument to any function requiring this
* parameter between qemuProcessBeginJob and qemuProcessEndJob.
*/
int
qemuProcessBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuDomainObjBeginAsyncJob(driver, vm, QEMU_ASYNC_JOB_START) < 0)
return -1;
qemuDomainObjSetAsyncJobMask(vm, QEMU_JOB_NONE);
priv->job.current->type = VIR_DOMAIN_JOB_UNBOUNDED;
return 0;
}
void
qemuProcessEndJob(virQEMUDriverPtr driver,
virDomainObjPtr vm)
{
qemuDomainObjEndAsyncJob(driver, vm);
}
int qemuProcessStart(virConnectPtr conn, int qemuProcessStart(virConnectPtr conn,
virQEMUDriverPtr driver, virQEMUDriverPtr driver,
virDomainObjPtr vm, virDomainObjPtr vm,
int asyncJob, qemuDomainAsyncJob asyncJob,
const char *migrateFrom, const char *migrateFrom,
int stdin_fd, int stdin_fd,
const char *stdin_path, const char *stdin_path,

7
src/qemu/qemu_process.h
View File

@ -58,6 +58,11 @@ qemuProcessIncomingDefPtr qemuProcessIncomingDefNew(virQEMUCapsPtr qemuCaps,
const char *path); const char *path);
void qemuProcessIncomingDefFree(qemuProcessIncomingDefPtr inc); void qemuProcessIncomingDefFree(qemuProcessIncomingDefPtr inc);
int qemuProcessBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr vm);
void qemuProcessEndJob(virQEMUDriverPtr driver,
virDomainObjPtr vm);
typedef enum { typedef enum {
VIR_QEMU_PROCESS_START_COLD = 1 << 0, VIR_QEMU_PROCESS_START_COLD = 1 << 0,
VIR_QEMU_PROCESS_START_PAUSED = 1 << 1, VIR_QEMU_PROCESS_START_PAUSED = 1 << 1,
@ -67,7 +72,7 @@ typedef enum {
int qemuProcessStart(virConnectPtr conn, int qemuProcessStart(virConnectPtr conn,
virQEMUDriverPtr driver, virQEMUDriverPtr driver,
virDomainObjPtr vm, virDomainObjPtr vm,
int asyncJob, qemuDomainAsyncJob asyncJob,
const char *migrateFrom, const char *migrateFrom,
int stdin_fd, int stdin_fd,
const char *stdin_path, const char *stdin_path,