There are a number of locks on various objects
- * struct qemud_driver: RWLock
+ * virQEMUDriverPtr
- This is the top level lock on the entire driver. Every API call in
- the QEMU driver is blocked while this is held, though some internal
- callbacks may still run asynchronously. This lock must never be held
- for anything which sleeps/waits (i.e. monitor commands)
+ The qemu_conf.h file has inline comments describing the locking
+ needs for each field. Any field marked immutable, self-locking
+ can be accessed without the driver lock. For other fields there
+ are typically helper APIs in qemu_conf.c that provide serialized
+ access to the data. No code outside qemu_conf.c should ever
+ acquire this lock
- When obtaining the driver lock, under *NO* circumstances must
- any lock be held on a virDomainObjPtr. This *WILL* result in
- deadlock.
-
-
-
- * virDomainObjPtr: Mutex
+ * virDomainObjPtr
Will be locked after calling any of the virDomainFindBy{ID,Name,UUID}
methods.
Lock must be held when changing/reading any variable in the virDomainObjPtr
- Once the lock is held, you must *NOT* try to lock the driver. You must
- release all virDomainObjPtr locks before locking the driver, or deadlock
- *WILL* occur.
-
If the lock needs to be dropped & then re-acquired for a short period of
time, the reference count must be incremented first using virDomainObjRef().
- If the reference count is incremented in this way, it is not necessary
- to have the driver locked when re-acquiring the dropped locked, since the
- reference count prevents it being freed by another thread.
This lock must not be held for anything which sleeps/waits (i.e. monitor
commands).
The virDomainObjPtr lock *MUST* then be released when invoking the
monitor command.
- The driver lock *MUST* be released when invoking the monitor commands.
-
- This ensures that the virDomainObjPtr & driver are both unlocked while
- sleeping/waiting for the monitor response.
-
-
Helper methods
--------------
-To lock the driver
-
- qemuDriverLock()
- - Acquires the driver lock
-
- qemuDriverUnlock()
- - Releases the driver lock
-
-
-
To lock the virDomainObjPtr
virObjectLock()
To acquire the normal job condition
- qemuDomainObjBeginJob() (if driver is unlocked)
+ qemuDomainObjBeginJob()
- Increments ref count on virDomainObjPtr
- Waits until the job is compatible with current async job or no
async job is running
isn't
- Sets job.active to the job type
- qemuDomainObjBeginJobWithDriver() (if driver needs to be locked)
- - Increments ref count on virDomainObjPtr
- - Unlocks driver
- - Waits until the job is compatible with current async job or no
- async job is running
- - Waits for job.cond condition 'job.active != 0' using virDomainObjPtr
- mutex
- - Rechecks if the job is still compatible and repeats waiting if it
- isn't
- - Sets job.active to the job type
- - Unlocks virDomainObjPtr
- - Locks driver
- - Locks virDomainObjPtr
-
- NB: this variant is required in order to comply with lock ordering
- rules for virDomainObjPtr vs. driver
-
qemuDomainObjEndJob()
- Sets job.active to 0
To acquire the asynchronous job condition
- qemuDomainObjBeginAsyncJob() (if driver is unlocked)
+ qemuDomainObjBeginAsyncJob()
- Increments ref count on virDomainObjPtr
- Waits until no async job is running
- Waits for job.cond condition 'job.active != 0' using virDomainObjPtr
and repeats waiting in that case
- Sets job.asyncJob to the asynchronous job type
- qemuDomainObjBeginAsyncJobWithDriver() (if driver needs to be locked)
- - Increments ref count on virDomainObjPtr
- - Unlocks driver
- - Waits until no async job is running
- - Waits for job.cond condition 'job.active != 0' using virDomainObjPtr
- mutex
- - Rechecks if any async job was started while waiting on job.cond
- and repeats waiting in that case
- - Sets job.asyncJob to the asynchronous job type
- - Unlocks virDomainObjPtr
- - Locks driver
- - Locks virDomainObjPtr
-
- NB: this variant is required in order to comply with lock ordering
- rules for virDomainObjPtr vs driver
-
qemuDomainObjEndAsyncJob()
- Sets job.asyncJob to 0
- Releases the qemuMonitorObjPtr lock
- Acquires the virDomainObjPtr lock
- NB: caller must take care to drop the driver lock if necessary
-
These functions must not be used by an asynchronous job.
-To acquire the QEMU monitor lock with the driver lock held
-
- qemuDomainObjEnterMonitorWithDriver()
- - Acquires the qemuMonitorObjPtr lock
- - Releases the virDomainObjPtr lock
- - Releases the driver lock
-
- qemuDomainObjExitMonitorWithDriver()
- - Releases the qemuMonitorObjPtr lock
- - Acquires the driver lock
- - Acquires the virDomainObjPtr lock
-
- NB: caller must take care to drop the driver lock if necessary
-
- These functions must not be used inside an asynchronous job.
-
-
-To acquire the QEMU monitor lock with the driver lock held and as part
-of an asynchronous job
+To acquire the QEMU monitor lock as part of an asynchronous job
qemuDomainObjEnterMonitorAsync()
- Validates that the right async job is still running
- Acquires the qemuMonitorObjPtr lock
- Releases the virDomainObjPtr lock
- - Releases the driver lock
- Validates that the VM is still active
- qemuDomainObjExitMonitorWithDriver()
+ qemuDomainObjExitMonitor()
- Releases the qemuMonitorObjPtr lock
- - Acquires the driver lock
- Acquires the virDomainObjPtr lock
- NB: caller must take care to drop the driver lock if necessary
-
These functions are for use inside an asynchronous job; the caller
must check for a return of -1 (VM not running, so nothing to exit).
Helper functions may also call this with QEMU_ASYNC_JOB_NONE when
used from a sync job (such as when first starting a domain).
-To keep a domain alive while waiting on a remote command, starting
-with the driver lock held
+To keep a domain alive while waiting on a remote command
- qemuDomainObjEnterRemoterWithDriver()
+ qemuDomainObjEnterRemote()
- Increments ref count on virDomainObjPtr
- Releases the virDomainObjPtr lock
- - Releases the driver lock
- qemuDomainObjExitRemoteWithDriver()
- - Acquires the driver lock
+ qemuDomainObjExitRemote()
- Acquires the virDomainObjPtr lock
- Decrements ref count on virDomainObjPtr
---------------
- * Accessing or updating something with just the driver
-
- qemuDriverLock(driver);
-
- ...do work...
-
- qemuDriverUnlock(driver);
-
-
-
* Accessing something directly to do with a virDomainObjPtr
virDomainObjPtr obj;
- qemuDriverLock(driver);
- obj = virDomainFindByUUID(driver->domains, dom->uuid);
- qemuDriverUnlock(driver);
-
- ...do work...
-
- virDomainObjUnlock(obj);
-
-
-
- * Accessing something directly to do with a virDomainObjPtr and driver
-
- virDomainObjPtr obj;
-
- qemuDriverLock(driver);
obj = virDomainFindByUUID(driver->domains, dom->uuid);
...do work...
virDomainObjUnlock(obj);
- qemuDriverUnlock(driver);
-
* Updating something directly to do with a virDomainObjPtr
virDomainObjPtr obj;
- qemuDriverLock(driver);
obj = virDomainFindByUUID(driver->domains, dom->uuid);
- qemuDriverUnlock(driver);
qemuDomainObjBeginJob(obj, QEMU_JOB_TYPE);
virDomainObjPtr obj;
qemuDomainObjPrivatePtr priv;
- qemuDriverLock(driver);
obj = virDomainFindByUUID(driver->domains, dom->uuid);
- qemuDriverUnlock(driver);
qemuDomainObjBeginJob(obj, QEMU_JOB_TYPE);
-
- * Invoking a monitor command on a virDomainObjPtr with driver locked too
-
-
- virDomainObjPtr obj;
- qemuDomainObjPrivatePtr priv;
-
- qemuDriverLock(driver);
- obj = virDomainFindByUUID(driver->domains, dom->uuid);
-
- qemuDomainObjBeginJobWithDriver(obj, QEMU_JOB_TYPE);
-
- ...do prep work...
-
- if (virDomainObjIsActive(vm)) {
- qemuDomainObjEnterMonitorWithDriver(driver, obj);
- qemuMonitorXXXX(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, obj);
- }
-
- ...do final work...
-
- qemuDomainObjEndJob(obj);
- virDomainObjUnlock(obj);
- qemuDriverUnlock(driver);
-
-
- * Running asynchronous job with driver lock held
+ * Running asynchronous job
virDomainObjPtr obj;
qemuDomainObjPrivatePtr priv;
- qemuDriverLock(driver);
obj = virDomainFindByUUID(driver->domains, dom->uuid);
- qemuDomainObjBeginAsyncJobWithDriver(obj, QEMU_ASYNC_JOB_TYPE);
+ qemuDomainObjBeginAsyncJob(obj, QEMU_ASYNC_JOB_TYPE);
qemuDomainObjSetAsyncJobMask(obj, allowedJobs);
...do prep work...
goto error;
}
...start qemu job...
- qemuDomainObjExitMonitorWithDriver(driver, obj);
+ qemuDomainObjExitMonitor(driver, obj);
while (!finished) {
if (qemuDomainObjEnterMonitorAsync(driver, obj,
goto error;
}
...monitor job progress...
- qemuDomainObjExitMonitorWithDriver(driver, obj);
+ qemuDomainObjExitMonitor(driver, obj);
virObjectUnlock(obj);
sleep(aWhile);
qemuDomainObjEndAsyncJob(obj);
virDomainObjUnlock(obj);
- qemuDriverUnlock(driver);
* Coordinating with a remote server for migration
virDomainObjPtr obj;
qemuDomainObjPrivatePtr priv;
- qemuDriverLock(driver);
obj = virDomainFindByUUID(driver->domains, dom->uuid);
- qemuDomainObjBeginAsyncJobWithDriver(obj, QEMU_ASYNC_JOB_TYPE);
+ qemuDomainObjBeginAsyncJob(obj, QEMU_ASYNC_JOB_TYPE);
...do prep work...
if (virDomainObjIsActive(vm)) {
- qemuDomainObjEnterRemoteWithDriver(driver, obj);
+ qemuDomainObjEnterRemote(obj);
...communicate with remote...
- qemuDomainObjExitRemoteWithDriver(driver, obj);
+ qemuDomainObjExitRemote(obj);
/* domain may have been stopped while we were talking to remote */
if (!virDomainObjIsActive(vm)) {
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
qemuDomainObjEndAsyncJob(obj);
virDomainObjUnlock(obj);
- qemuDriverUnlock(driver);
-
-
-Summary
--------
-
- * Respect lock ordering rules: never lock driver if anything else is
- already locked
-
- * Don't hold locks in code which sleeps: unlock driver & virDomainObjPtr
- when using monitor
/*
* qemu_conf.c: QEMU configuration management
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2013 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
qemuDriverCloseCallback cb;
};
-void qemuDriverLock(virQEMUDriverPtr driver)
+static void
+qemuDriverLock(virQEMUDriverPtr driver)
{
virMutexLock(&driver->lock);
}
-void qemuDriverUnlock(virQEMUDriverPtr driver)
+static void
+qemuDriverUnlock(virQEMUDriverPtr driver)
{
virMutexUnlock(&driver->lock);
}
virQEMUDriverConfigPtr virQEMUDriverGetConfig(virQEMUDriverPtr driver)
{
- return virObjectRef(driver->config);
+ virQEMUDriverConfigPtr conf;
+ qemuDriverLock(driver);
+ conf = virObjectRef(driver->config);
+ qemuDriverUnlock(driver);
+ return conf;
}
virCapsPtr virQEMUDriverGetCapabilities(virQEMUDriverPtr driver,
bool refresh)
{
+ virCapsPtr ret = NULL;
if (refresh) {
virCapsPtr caps = NULL;
if ((caps = virQEMUDriverCreateCapabilities(driver)) == NULL)
return NULL;
+ qemuDriverLock(driver);
virObjectUnref(driver->caps);
driver->caps = caps;
+ } else {
+ qemuDriverLock(driver);
}
- return virObjectRef(driver->caps);
+ ret = virObjectRef(driver->caps);
+ qemuDriverUnlock(driver);
+ return ret;
}
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
qemuDriverCloseDefPtr closeDef;
+ int ret = -1;
+ qemuDriverLock(driver);
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s, uuid=%s, conn=%p, cb=%p",
vm->def->name, uuidstr, conn, cb);
_("Close callback for domain %s already registered"
" with another connection %p"),
vm->def->name, closeDef->conn);
- return -1;
+ goto cleanup;
}
if (closeDef->cb && closeDef->cb != cb) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Another close callback is already defined for"
" domain %s"), vm->def->name);
- return -1;
+ goto cleanup;
}
closeDef->cb = cb;
} else {
if (VIR_ALLOC(closeDef) < 0) {
virReportOOMError();
- return -1;
+ goto cleanup;
}
closeDef->conn = conn;
closeDef->cb = cb;
if (virHashAddEntry(driver->closeCallbacks, uuidstr, closeDef) < 0) {
VIR_FREE(closeDef);
- return -1;
+ goto cleanup;
}
}
- return 0;
+
+ ret = 0;
+cleanup:
+ qemuDriverUnlock(driver);
+ return ret;
}
int
{
char uuidstr[VIR_UUID_STRING_BUFLEN];
qemuDriverCloseDefPtr closeDef;
+ int ret = -1;
+ qemuDriverLock(driver);
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s, uuid=%s, cb=%p",
vm->def->name, uuidstr, cb);
closeDef = virHashLookup(driver->closeCallbacks, uuidstr);
if (!closeDef)
- return -1;
+ goto cleanup;
if (closeDef->cb && closeDef->cb != cb) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Trying to remove mismatching close callback for"
" domain %s"), vm->def->name);
- return -1;
+ goto cleanup;
}
- return virHashRemoveEntry(driver->closeCallbacks, uuidstr);
+ ret = virHashRemoveEntry(driver->closeCallbacks, uuidstr);
+cleanup:
+ qemuDriverUnlock(driver);
+ return ret;
}
qemuDriverCloseCallback
qemuDriverCloseDefPtr closeDef;
qemuDriverCloseCallback cb = NULL;
+ qemuDriverLock(driver);
virUUIDFormat(vm->def->uuid, uuidstr);
VIR_DEBUG("vm=%s, uuid=%s, conn=%p",
vm->def->name, uuidstr, conn);
cb = closeDef->cb;
VIR_DEBUG("cb=%p", cb);
+ qemuDriverUnlock(driver);
return cb;
}
driver, conn
};
VIR_DEBUG("conn=%p", conn);
-
+ qemuDriverLock(driver);
virHashForEach(driver->closeCallbacks, qemuDriverCloseCallbackRun, &data);
+ qemuDriverUnlock(driver);
}
/* Construct the hash key for sharedDisks as "major:minor" */
char *key = NULL;
int ret = -1;
+ qemuDriverLock(driver);
if (!(key = qemuGetSharedDiskKey(disk_path)))
goto cleanup;
ret = 0;
cleanup:
+ qemuDriverUnlock(driver);
VIR_FREE(key);
return ret;
}
char *key = NULL;
int ret = -1;
+ qemuDriverLock(driver);
if (!(key = qemuGetSharedDiskKey(disk_path)))
goto cleanup;
ret = 0;
cleanup:
+ qemuDriverUnlock(driver);
VIR_FREE(key);
return ret;
}
/*
* qemu_conf.h: QEMU configuration management
*
- * Copyright (C) 2006-2007, 2009-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2007, 2009-2013 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
# define QEMUD_MIGRATION_NUM_PORTS 64
-void qemuDriverLock(virQEMUDriverPtr driver);
-void qemuDriverUnlock(virQEMUDriverPtr driver);
-
virQEMUDriverConfigPtr virQEMUDriverConfigNew(bool privileged);
int virQEMUDriverConfigLoadFile(virQEMUDriverConfigPtr cfg,
/*
* qemu_domain.h: QEMU domain private state
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2013 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
}
-/* driver must be locked before calling */
void qemuDomainEventQueue(virQEMUDriverPtr driver,
virDomainEventPtr event)
{
#define QEMU_JOB_WAIT_TIME (1000ull * 30)
/*
- * obj must be locked before calling; driver_locked says if qemu_driver is
- * locked or not.
+ * obj must be locked before calling
*/
static int ATTRIBUTE_NONNULL(1)
qemuDomainObjBeginJobInternal(virQEMUDriverPtr driver,
- bool driver_locked,
virDomainObjPtr obj,
enum qemuDomainJob job,
enum qemuDomainAsyncJob asyncJob)
then = now + QEMU_JOB_WAIT_TIME;
virObjectRef(obj);
- if (driver_locked)
- qemuDriverUnlock(driver);
retry:
if (cfg->maxQueuedJobs &&
priv->job.start = now;
}
- if (driver_locked) {
- virObjectUnlock(obj);
- qemuDriverLock(driver);
- virObjectLock(obj);
- }
-
if (qemuDomainTrackJob(job))
qemuDomainObjSaveJob(driver, obj);
virReportSystemError(errno,
"%s", _("cannot acquire job mutex"));
priv->jobs_queued--;
- if (driver_locked) {
- virObjectUnlock(obj);
- qemuDriverLock(driver);
- virObjectLock(obj);
- }
virObjectUnref(obj);
virObjectUnref(cfg);
return -1;
}
/*
- * obj must be locked before calling, driver must NOT be locked
+ * obj must be locked before calling
*
* This must be called by anything that will change the VM state
* in any way, or anything that will use the QEMU monitor.
virDomainObjPtr obj,
enum qemuDomainJob job)
{
- return qemuDomainObjBeginJobInternal(driver, false, obj, job,
+ return qemuDomainObjBeginJobInternal(driver, obj, job,
QEMU_ASYNC_JOB_NONE);
}
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
- return qemuDomainObjBeginJobInternal(driver, false, obj, QEMU_JOB_ASYNC,
+ return qemuDomainObjBeginJobInternal(driver, obj, QEMU_JOB_ASYNC,
asyncJob);
}
-/*
- * obj and driver must be locked before calling.
- *
- * This must be called by anything that will change the VM state
- * in any way, or anything that will use the QEMU monitor.
- *
- * Upon successful return, the object will have its ref count increased,
- * successful calls must be followed by EndJob eventually
- */
-int qemuDomainObjBeginJobWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- enum qemuDomainJob job)
-{
- if (job <= QEMU_JOB_NONE || job >= QEMU_JOB_ASYNC) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Attempt to start invalid job"));
- return -1;
- }
-
- return qemuDomainObjBeginJobInternal(driver, true, obj, job,
- QEMU_ASYNC_JOB_NONE);
-}
-
-int qemuDomainObjBeginAsyncJobWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- enum qemuDomainAsyncJob asyncJob)
-{
- return qemuDomainObjBeginJobInternal(driver, true, obj, QEMU_JOB_ASYNC,
- asyncJob);
-}
/*
- * obj must be locked before calling, driver does not matter
+ * obj must be locked before calling
*
* To be called after completing the work associated with the
* earlier qemuDomainBeginJob() call
priv->job.asyncAbort = true;
}
+/*
+ * obj must be locked before calling
+ *
+ * To be called immediately before any QEMU monitor API call
+ * Must have already either called qemuDomainObjBeginJob() and checked
+ * that the VM is still active; may not be used for nested async jobs.
+ *
+ * To be followed with qemuDomainObjExitMonitor() once complete
+ */
static int
qemuDomainObjEnterMonitorInternal(virQEMUDriverPtr driver,
- bool driver_locked,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
if (priv->job.asyncOwner != virThreadSelfID())
VIR_WARN("This thread doesn't seem to be the async job owner: %d",
priv->job.asyncOwner);
- if (qemuDomainObjBeginJobInternal(driver, driver_locked, obj,
+ if (qemuDomainObjBeginJobInternal(driver, obj,
QEMU_JOB_ASYNC_NESTED,
QEMU_ASYNC_JOB_NONE) < 0)
return -1;
virObjectRef(priv->mon);
ignore_value(virTimeMillisNow(&priv->monStart));
virObjectUnlock(obj);
- if (driver_locked)
- qemuDriverUnlock(driver);
return 0;
}
static void ATTRIBUTE_NONNULL(1)
qemuDomainObjExitMonitorInternal(virQEMUDriverPtr driver,
- bool driver_locked,
virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
if (hasRefs)
virObjectUnlock(priv->mon);
- if (driver_locked)
- qemuDriverLock(driver);
virObjectLock(obj);
priv->monStart = 0;
}
}
-/*
- * obj must be locked before calling, driver must be unlocked
- *
- * To be called immediately before any QEMU monitor API call
- * Must have already either called qemuDomainObjBeginJob() and checked
- * that the VM is still active; may not be used for nested async jobs.
- *
- * To be followed with qemuDomainObjExitMonitor() once complete
- */
void qemuDomainObjEnterMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
- ignore_value(qemuDomainObjEnterMonitorInternal(driver, false, obj,
+ ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
QEMU_ASYNC_JOB_NONE));
}
-/* obj must NOT be locked before calling, driver must be unlocked
+/* obj must NOT be locked before calling
*
* Should be paired with an earlier qemuDomainObjEnterMonitor() call
*/
void qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
{
- qemuDomainObjExitMonitorInternal(driver, false, obj);
+ qemuDomainObjExitMonitorInternal(driver, obj);
}
/*
- * obj must be locked before calling, driver must be locked
- *
- * To be called immediately before any QEMU monitor API call
- * Must have already either called qemuDomainObjBeginJobWithDriver() and
- * checked that the VM is still active; may not be used for nested async jobs.
- *
- * To be followed with qemuDomainObjExitMonitorWithDriver() once complete
- */
-void qemuDomainObjEnterMonitorWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- ignore_value(qemuDomainObjEnterMonitorInternal(driver, true, obj,
- QEMU_ASYNC_JOB_NONE));
-}
-
-/*
- * obj and driver must be locked before calling
+ * obj must be locked before calling
*
* To be called immediately before any QEMU monitor API call.
- * Must have already either called qemuDomainObjBeginJobWithDriver()
+ * Must have already either called qemuDomainObjBeginJob()
* and checked that the VM is still active, with asyncJob of
* QEMU_ASYNC_JOB_NONE; or already called qemuDomainObjBeginAsyncJob,
* with the same asyncJob.
*
* Returns 0 if job was started, in which case this must be followed with
- * qemuDomainObjExitMonitorWithDriver(); or -1 if the job could not be
+ * qemuDomainObjExitMonitor(); or -1 if the job could not be
* started (probably because the vm exited in the meantime).
*/
int
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
{
- return qemuDomainObjEnterMonitorInternal(driver, true, obj, asyncJob);
-}
-
-/* obj must NOT be locked before calling, driver must be unlocked,
- * and will be locked after returning
- *
- * Should be paired with an earlier qemuDomainObjEnterMonitorWithDriver() call
- */
-void qemuDomainObjExitMonitorWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- qemuDomainObjExitMonitorInternal(driver, true, obj);
+ return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
}
-static int
-qemuDomainObjEnterAgentInternal(virQEMUDriverPtr driver,
- bool driver_locked,
- virDomainObjPtr obj)
+/*
+ * obj must be locked before calling
+ *
+ * To be called immediately before any QEMU agent API call.
+ * Must have already called qemuDomainObjBeginJob() and checked
+ * that the VM is still active.
+ *
+ * To be followed with qemuDomainObjExitAgent() once complete
+ */
+void
+qemuDomainObjEnterAgent(virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
virObjectRef(priv->agent);
ignore_value(virTimeMillisNow(&priv->agentStart));
virObjectUnlock(obj);
- if (driver_locked)
- qemuDriverUnlock(driver);
-
- return 0;
}
-static void ATTRIBUTE_NONNULL(1)
-qemuDomainObjExitAgentInternal(virQEMUDriverPtr driver,
- bool driver_locked,
- virDomainObjPtr obj)
+
+/* obj must NOT be locked before calling
+ *
+ * Should be paired with an earlier qemuDomainObjEnterAgent() call
+ */
+void
+qemuDomainObjExitAgent(virDomainObjPtr obj)
{
qemuDomainObjPrivatePtr priv = obj->privateData;
bool hasRefs;
if (hasRefs)
virObjectUnlock(priv->agent);
- if (driver_locked)
- qemuDriverLock(driver);
virObjectLock(obj);
priv->agentStart = 0;
priv->agent = NULL;
}
-/*
- * obj must be locked before calling, driver must be unlocked
- *
- * To be called immediately before any QEMU agent API call.
- * Must have already called qemuDomainObjBeginJob() and checked
- * that the VM is still active.
- *
- * To be followed with qemuDomainObjExitAgent() once complete
- */
-void qemuDomainObjEnterAgent(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- ignore_value(qemuDomainObjEnterAgentInternal(driver, false, obj));
-}
-
-/* obj must NOT be locked before calling, driver must be unlocked
- *
- * Should be paired with an earlier qemuDomainObjEnterAgent() call
- */
-void qemuDomainObjExitAgent(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- qemuDomainObjExitAgentInternal(driver, false, obj);
-}
-
-/*
- * obj must be locked before calling, driver must be locked
- *
- * To be called immediately before any QEMU agent API call.
- * Must have already called qemuDomainObjBeginJobWithDriver() and
- * checked that the VM is still active; may not be used for nested async jobs.
- *
- * To be followed with qemuDomainObjExitAgentWithDriver() once complete
- */
-void qemuDomainObjEnterAgentWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- ignore_value(qemuDomainObjEnterAgentInternal(driver, true, obj));
-}
-
-/* obj must NOT be locked before calling, driver must be unlocked,
- * and will be locked after returning
- *
- * Should be paired with an earlier qemuDomainObjEnterAgentWithDriver() call
- */
-void qemuDomainObjExitAgentWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
-{
- qemuDomainObjExitAgentInternal(driver, true, obj);
-}
-
-void qemuDomainObjEnterRemoteWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+void qemuDomainObjEnterRemote(virDomainObjPtr obj)
{
virObjectRef(obj);
virObjectUnlock(obj);
- qemuDriverUnlock(driver);
}
-void qemuDomainObjExitRemoteWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
+void qemuDomainObjExitRemote(virDomainObjPtr obj)
{
- qemuDriverLock(driver);
virObjectLock(obj);
virObjectUnref(obj);
}
goto cleanup;
} else {
priv = vm->privateData;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
/* we continue on even in the face of error */
qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
}
}
/*
- * The caller must hold a lock on both driver and vm, and there must
+ * The caller must hold a lock the vm and there must
* be no remaining references to vm.
*/
void
/*
* qemu_domain.h: QEMU domain private state
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2013 Red Hat, Inc.
* Copyright (C) 2006 Daniel P. Berrange
*
* This library is free software; you can redistribute it and/or
void qemuDomainEventFlush(int timer, void *opaque);
-/* driver must be locked before calling */
void qemuDomainEventQueue(virQEMUDriverPtr driver,
virDomainEventPtr event);
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
ATTRIBUTE_RETURN_CHECK;
-int qemuDomainObjBeginJobWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- enum qemuDomainJob job)
- ATTRIBUTE_RETURN_CHECK;
-int qemuDomainObjBeginAsyncJobWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj,
- enum qemuDomainAsyncJob asyncJob)
- ATTRIBUTE_RETURN_CHECK;
bool qemuDomainObjEndJob(virQEMUDriverPtr driver,
virDomainObjPtr obj)
void qemuDomainObjExitMonitor(virQEMUDriverPtr driver,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterMonitorWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuDomainObjEnterMonitorAsync(virQEMUDriverPtr driver,
virDomainObjPtr obj,
enum qemuDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_RETURN_CHECK;
-void qemuDomainObjExitMonitorWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterAgent(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitAgent(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjEnterAgentWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitAgentWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+void qemuDomainObjEnterAgent(virDomainObjPtr obj)
+ ATTRIBUTE_NONNULL(1);
+void qemuDomainObjExitAgent(virDomainObjPtr obj)
+ ATTRIBUTE_NONNULL(1);
-void qemuDomainObjEnterRemoteWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-void qemuDomainObjExitRemoteWithDriver(virQEMUDriverPtr driver,
- virDomainObjPtr obj)
- ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
+void qemuDomainObjEnterRemote(virDomainObjPtr obj)
+ ATTRIBUTE_NONNULL(1);
+void qemuDomainObjExitRemote(virDomainObjPtr obj)
+ ATTRIBUTE_NONNULL(1);
int qemuDomainDefFormatBuf(virQEMUDriverPtr driver,
virDomainDefPtr vm,
static void
-qemuVMDriverLock(void) {
- qemuDriverLock(qemu_driver);
-};
-
-
+qemuVMDriverLock(void) {}
static void
-qemuVMDriverUnlock(void) {
- qemuDriverUnlock(qemu_driver);
-};
-
+qemuVMDriverUnlock(void) {}
static int
qemuVMFilterRebuild(virConnectPtr conn ATTRIBUTE_UNUSED,
virConnectPtr conn;
};
+
/**
- * qemuDomObjFromDomainDriver:
+ * qemuDomObjFromDomain:
* @domain: Domain pointer that has to be looked up
- * @drv: Pointer to virQEMUDriverPtr to return the driver object
*
- * This function looks up @domain in the domain list and returns the
- * appropriate virDomainObjPtr. On successful lookup, both driver and domain
- * object are returned locked.
+ * This function looks up @domain and returns the appropriate
+ * virDomainObjPtr.
*
- * Returns the domain object if it's found and the driver. Both are locked.
- * In case of failure NULL is returned and the driver isn't locked.
+ * Returns the domain object which is locked on success, NULL
+ * otherwise.
*/
static virDomainObjPtr
-qemuDomObjFromDomainDriver(virDomainPtr domain, virQEMUDriverPtr *drv)
+qemuDomObjFromDomain(virDomainPtr domain)
{
- virQEMUDriverPtr driver = domain->conn->privateData;
virDomainObjPtr vm;
+ virQEMUDriverPtr driver = domain->conn->privateData;
char uuidstr[VIR_UUID_STRING_BUFLEN];
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
virUUIDFormat(domain->uuid, uuidstr);
virReportError(VIR_ERR_NO_DOMAIN,
_("no domain with matching uuid '%s'"), uuidstr);
- qemuDriverUnlock(driver);
- *drv = NULL;
return NULL;
}
- *drv = driver;
- return vm;
-}
-
-/**
- * qemuDomObjFromDomain:
- * @domain: Domain pointer that has to be looked up
- *
- * This function looks up @domain and returns the appropriate
- * virDomainObjPtr. The driver is unlocked after the call.
- *
- * Returns the domain object which is locked on success, NULL
- * otherwise. The driver remains unlocked after the call.
- */
-static virDomainObjPtr
-qemuDomObjFromDomain(virDomainPtr domain)
-{
- virDomainObjPtr vm;
- virQEMUDriverPtr driver;
-
- if (!(vm = qemuDomObjFromDomainDriver(domain, &driver)))
- return NULL;
-
- qemuDriverUnlock(driver);
-
return vm;
}
virResetLastError();
if (vm->autostart &&
!virDomainObjIsActive(vm)) {
- if (qemuDomainObjBeginJobWithDriver(data->driver, vm,
- QEMU_JOB_MODIFY) < 0) {
+ if (qemuDomainObjBeginJob(data->driver, vm,
+ QEMU_JOB_MODIFY) < 0) {
err = virGetLastError();
VIR_ERROR(_("Failed to start job on VM '%s': %s"),
vm->def->name,
/* Ignoring NULL conn which is mostly harmless here */
struct qemuAutostartData data = { driver, conn };
- qemuDriverLock(driver);
virDomainObjListForEach(driver->domains, qemuAutostartDomain, &data);
- qemuDriverUnlock(driver);
if (conn)
virConnectClose(conn);
VIR_FREE(qemu_driver);
return -1;
}
- qemuDriverLock(qemu_driver);
qemu_driver->inhibitCallback = callback;
qemu_driver->inhibitOpaque = opaque;
if (!qemu_driver->workerPool)
goto error;
- qemuDriverUnlock(qemu_driver);
-
qemuAutostartDomains(qemu_driver);
if (conn)
out_of_memory:
virReportOOMError();
error:
- if (qemu_driver)
- qemuDriverUnlock(qemu_driver);
if (conn)
virConnectClose(conn);
VIR_FREE(driverConf);
if (!qemu_driver)
return 0;
- qemuDriverLock(qemu_driver);
if (!(caps = virQEMUDriverGetCapabilities(qemu_driver, false)))
goto cleanup;
cfg->autostartDir,
0, QEMU_EXPECTED_VIRT_TYPES,
qemuNotifyLoadDomain, qemu_driver);
-
cleanup:
- qemuDriverUnlock(qemu_driver);
virObjectUnref(cfg);
virObjectUnref(caps);
return 0;
if (!qemu_driver)
return -1;
- qemuDriverLock(qemu_driver);
virNWFilterUnRegisterCallbackDriver(&qemuCallbackDriver);
virObjectUnref(qemu_driver->activePciHostdevs);
virObjectUnref(qemu_driver->inactivePciHostdevs);
virLockManagerPluginUnref(qemu_driver->lockManager);
- qemuDriverUnlock(qemu_driver);
virMutexDestroy(&qemu_driver->lock);
virThreadPoolFree(qemu_driver->workerPool);
VIR_FREE(qemu_driver);
virQEMUDriverPtr driver = conn->privateData;
/* Get rid of callbacks registered for this conn */
- qemuDriverLock(driver);
qemuDriverCloseCallbackRunAll(driver, conn);
- qemuDriverUnlock(driver);
conn->privateData = NULL;
virCapsPtr caps = NULL;
char *xml = NULL;
- qemuDriverLock(driver);
-
- if (!(caps = virQEMUDriverGetCapabilities(qemu_driver, true)))
+ if (!(caps = virQEMUDriverGetCapabilities(driver, true)))
goto cleanup;
if ((xml = virCapabilitiesFormatXML(caps)) == NULL)
virObjectUnref(caps);
cleanup:
- qemuDriverUnlock(driver);
return xml;
}
virDomainObjPtr vm;
virDomainPtr dom = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByID(driver->domains, id);
- qemuDriverUnlock(driver);
if (!vm) {
virReportError(VIR_ERR_NO_DOMAIN,
virDomainObjPtr vm;
virDomainPtr dom = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, uuid);
- qemuDriverUnlock(driver);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
virDomainObjPtr vm;
virDomainPtr dom = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByName(driver->domains, name);
- qemuDriverUnlock(driver);
if (!vm) {
virReportError(VIR_ERR_NO_DOMAIN,
unsigned int qemuVersion;
virCapsPtr caps = NULL;
- qemuDriverLock(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
cleanup:
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
int n;
- qemuDriverLock(driver);
n = virDomainObjListGetActiveIDs(driver->domains, ids, nids);
- qemuDriverUnlock(driver);
return n;
}
virQEMUDriverPtr driver = conn->privateData;
int n;
- qemuDriverLock(driver);
n = virDomainObjListNumOfDomains(driver->domains, 1);
- qemuDriverUnlock(driver);
return n;
}
if (flags & VIR_DOMAIN_START_AUTODESTROY)
start_flags |= VIR_QEMU_PROCESS_START_AUTODESROY;
- qemuDriverLock(driver);
-
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
def = NULL;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup; /* XXXX free the 'vm' we created ? */
if (qemuProcessStart(conn, driver, vm, NULL, -1, NULL, NULL,
}
virObjectUnref(caps);
virObjectUnref(qemuCaps);
- qemuDriverUnlock(driver);
return dom;
}
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
cfg = virQEMUDriverGetConfig(driver);
priv = vm->privateData;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_SUSPEND) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_SUSPEND) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
cfg = virQEMUDriverGetConfig(driver);
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
}
if (useAgent) {
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
ret = qemuAgentShutdown(priv->agent, QEMU_AGENT_SHUTDOWN_POWERDOWN);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
} else {
qemuDomainSetFakeReboot(driver, vm, false);
}
if (useAgent) {
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
ret = qemuAgentShutdown(priv->agent, QEMU_AGENT_SHUTDOWN_REBOOT);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
} else {
qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemPowerdown(priv->mon);
virCheckFlags(VIR_DOMAIN_DESTROY_GRACEFUL, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
* it now means the job will be released
*/
if (flags & VIR_DOMAIN_DESTROY_GRACEFUL) {
- if (qemuProcessKill(driver, vm, 0) < 0) {
+ if (qemuProcessKill(vm, 0) < 0) {
priv->beingDestroyed = false;
goto cleanup;
}
} else {
- if (qemuProcessKill(driver, vm, VIR_QEMU_PROCESS_KILL_FORCE) < 0) {
+ if (qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_FORCE) < 0) {
priv->beingDestroyed = false;
goto cleanup;
}
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_DESTROY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_DESTROY) < 0)
goto cleanup;
priv->beingDestroyed = false;
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(0, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
priv = vm->privateData;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
goto endjob;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorInjectNMI(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
endjob:
if (qemuDomainObjEndJob(driver, vm) == 0) {
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
return ret;
}
-/* This internal function expects the driver lock to already be held on
- * entry and the vm must be active + locked. Vm will be unlocked and
+/* The vm must be active + locked. Vm will be unlocked and
* potentially free'd after this returns (eg transient VMs are freed
* shutdown). So 'vm' must not be referenced by the caller after
* this returns (whether returning success or failure).
if (!qemuMigrationIsAllowed(driver, vm, vm->def, false))
goto cleanup;
- if (qemuDomainObjBeginAsyncJobWithDriver(driver, vm,
+ if (qemuDomainObjBeginAsyncJob(driver, vm,
QEMU_ASYNC_JOB_SAVE) < 0)
memset(&priv->job.info, 0, sizeof(priv->job.info));
VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
- qemuDriverLock(driver);
-
cfg = virQEMUDriverGetConfig(driver);
if (cfg->saveImageFormat == NULL)
compressed = QEMU_SAVE_FORMAT_RAW;
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(cfg);
return ret;
}
static int
qemuDomainManagedSave(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
char *name = NULL;
int ret = -1;
VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
- if (!(vm = qemuDomObjFromDomainDriver(dom, &driver)))
+ if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
if (!virDomainObjIsActive(vm)) {
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
VIR_FREE(name);
return ret;
static int
qemuDomainManagedSaveRemove(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriverPtr driver;
+ virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
char *name = NULL;
virCheckFlags(0, -1);
- if (!(vm = qemuDomObjFromDomainDriver(dom, &driver)))
+ if (!(vm = qemuDomObjFromDomain(dom)))
return -1;
if (!(name = qemuDomainManagedSavePath(driver, vm)))
cleanup:
VIR_FREE(name);
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
return -1;
ret = qemuMonitorDumpToFd(priv->mon, fd);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
return ret;
}
VIR_DUMP_BYPASS_CACHE | VIR_DUMP_RESET |
VIR_DUMP_MEMORY_ONLY, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginAsyncJobWithDriver(driver, vm,
- QEMU_ASYNC_JOB_DUMP) < 0)
+ if (qemuDomainObjBeginAsyncJob(driver, vm,
+ QEMU_ASYNC_JOB_DUMP) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
virDomainObjIsActive(vm)) {
if ((ret == 0) && (flags & VIR_DUMP_RESET)) {
priv = vm->privateData;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSystemReset(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
if (resume && qemuProcessStartCPUs(driver, vm, dom->conn,
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = opaque;
virQEMUDriverConfigPtr cfg;
- qemuDriverLock(driver);
virObjectLock(wdEvent->vm);
cfg = virQEMUDriverGetConfig(driver);
goto unlock;
}
- if (qemuDomainObjBeginAsyncJobWithDriver(driver, wdEvent->vm,
+ if (qemuDomainObjBeginAsyncJob(driver, wdEvent->vm,
QEMU_ASYNC_JOB_DUMP) < 0) {
VIR_FREE(dumpfile);
goto unlock;
unlock:
virObjectUnlock(wdEvent->vm);
virObjectUnref(wdEvent->vm);
- qemuDriverUnlock(driver);
VIR_FREE(wdEvent);
virObjectUnref(cfg);
}
virDomainObjPtr vm;
int ret = -1;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
memset(seclabel, 0, sizeof(*seclabel));
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
int i, ret = -1;
/* Protect domain data with qemu lock */
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
+
+
static int qemuNodeGetSecurityModel(virConnectPtr conn,
virSecurityModelPtr secmodel)
{
int ret = 0;
virCapsPtr caps = NULL;
- qemuDriverLock(driver);
memset(secmodel, 0, sizeof(*secmodel));
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
strcpy(secmodel->doi, p);
cleanup:
- qemuDriverUnlock(driver);
virObjectUnref(caps);
return ret;
}
VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
- qemuDriverLock(driver);
if (flags & VIR_DOMAIN_SAVE_RUNNING)
state = 1;
goto cleanup;
def = NULL;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
ret = qemuDomainSaveImageStartVM(conn, driver, vm, &fd, &header, path,
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
/* We only take subset of virDomainDefFormat flags. */
virCheckFlags(VIR_DOMAIN_XML_SECURE, NULL);
- qemuDriverLock(driver);
-
fd = qemuDomainSaveImageOpen(driver, path, &def, &header, false, NULL,
NULL, -1, false, false);
cleanup:
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(VIR_DOMAIN_SAVE_RUNNING |
VIR_DOMAIN_SAVE_PAUSED, -1);
- qemuDriverLock(driver);
-
if (flags & VIR_DOMAIN_SAVE_RUNNING)
state = 1;
else if (flags & VIR_DOMAIN_SAVE_PAUSED)
virDomainDefFree(def);
VIR_FORCE_CLOSE(fd);
VIR_FREE(xml);
- qemuDriverUnlock(driver);
return ret;
}
/* Flags checked by virDomainDefFormat */
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
/* Don't delay if someone's using the monitor, just use
* existing most recent data instead */
if (qemuDomainJobAllowed(priv, QEMU_JOB_QUERY)) {
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
goto endjob;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
endjob:
if (qemuDomainObjEndJob(driver, vm) == 0) {
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
goto cleanup;
}
- qemuDriverLock(driver);
-
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
def = qemuParseCommandLineString(caps, config,
NULL, NULL, NULL);
- qemuDriverUnlock(driver);
if (!def)
goto cleanup;
virCheckFlags(0, NULL);
- qemuDriverLock(driver);
cfg = virQEMUDriverGetConfig(driver);
if (STRNEQ(format, QEMU_CONFIG_FORMAT_ARGV)) {
ret = virCommandToString(cmd);
cleanup:
- qemuDriverUnlock(driver);
virObjectUnref(qemuCaps);
virCommandFree(cmd);
virQEMUDriverPtr driver = conn->privateData;
int n;
- qemuDriverLock(driver);
n = virDomainObjListGetInactiveNames(driver->domains, names, nnames);
- qemuDriverUnlock(driver);
return n;
}
virQEMUDriverPtr driver = conn->privateData;
int n;
- qemuDriverLock(driver);
n = virDomainObjListNumOfDomains(driver->domains, 0);
- qemuDriverUnlock(driver);
return n;
}
VIR_DOMAIN_START_BYPASS_CACHE |
VIR_DOMAIN_START_FORCE_BOOT, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjIsActive(vm)) {
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverConfigPtr cfg;
virCapsPtr caps = NULL;
- qemuDriverLock(driver);
cfg = virQEMUDriverGetConfig(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
if (event)
qemuDomainEventQueue(driver, event);
virObjectUnref(qemuCaps);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return dom;
virCheckFlags(VIR_DOMAIN_UNDEFINE_MANAGED_SAVE |
VIR_DOMAIN_UNDEFINE_SNAPSHOTS_METADATA, -1);
- qemuDriverLock(driver);
cfg = virQEMUDriverGetConfig(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
virObjectUnref(cfg);
return ret;
}
affect = flags & (VIR_DOMAIN_AFFECT_LIVE | VIR_DOMAIN_AFFECT_CONFIG);
- qemuDriverLock(driver);
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
}
priv = vm->privateData;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjIsActive(vm)) {
virDomainDeviceDefFree(dev);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
int ret = -1;
virQEMUDriverConfigPtr cfg = NULL;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
cfg = virQEMUDriverGetConfig(driver);
if (!vm) {
VIR_FREE(autostartLink);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(cfg);
return ret;
}
char *ret = NULL;
int rc;
- qemuDriverLock(driver);
if (!qemuCgroupControllerActive(driver, VIR_CGROUP_CONTROLLER_CPU)) {
virReportError(VIR_ERR_OPERATION_INVALID,
"%s", _("cgroup CPU controller is not mounted"));
virReportOOMError();
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
NULL) < 0)
return -1;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
virCheckFlags(VIR_DOMAIN_AFFECT_LIVE |
VIR_DOMAIN_AFFECT_CONFIG |
VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
/* We blindly return a string, and let libvirt.c and
* remote_driver.c do the filtering on behalf of older clients
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
NULL) < 0)
return -1;
- qemuDriverLock(driver);
-
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) {
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
VIR_DOMAIN_AFFECT_CONFIG |
VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
-
/* We don't return strings, and thus trivially support this flag. */
flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
NULL) < 0)
return -1;
- qemuDriverLock(driver);
-
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) {
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
VIR_DOMAIN_AFFECT_CONFIG |
VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
-
/* We blindly return a string, and let libvirt.c and
* remote_driver.c do the filtering on behalf of older clients
* that can't parse it. */
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
NULL) < 0)
return -1;
- qemuDriverLock(driver);
-
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) {
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
VIR_DOMAIN_AFFECT_CONFIG |
VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
-
/* We don't return strings, and thus trivially support this flag. */
flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
NULL) < 0)
return -1;
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm == NULL) {
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
VIR_DOMAIN_AFFECT_CONFIG |
VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
-
flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
int ret;
- qemuDriverLock(driver);
ret = virDomainEventStateRegister(conn,
driver->domainEventState,
callback, opaque, freecb);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
int ret;
- qemuDriverLock(driver);
ret = virDomainEventStateDeregister(conn,
driver->domainEventState,
callback);
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
int ret;
- qemuDriverLock(driver);
if (virDomainEventStateRegisterID(conn,
driver->domainEventState,
dom, eventID,
callback, opaque, freecb, &ret) < 0)
ret = -1;
- qemuDriverUnlock(driver);
return ret;
}
virQEMUDriverPtr driver = conn->privateData;
int ret;
- qemuDriverLock(driver);
ret = virDomainEventStateDeregisterID(conn,
driver->domainEventState,
callbackID);
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- qemuDriverLock(driver);
-
if (!dom_xml) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("no domain XML passed"));
st, dname, dom_xml, flags);
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
*uri_out = NULL;
- qemuDriverLock(driver);
-
if (virLockManagerPluginUsesState(driver->lockManager)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Cannot use migrate v2 protocol with lock manager %s"),
dname, dom_xml, flags);
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- qemuDriverLock(driver);
if (virLockManagerPluginUsesState(driver->lockManager)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Cannot use migrate v2 protocol with lock manager %s"),
flags, dname, resource, false);
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
- qemuDriverLock(driver);
vm = virDomainObjListFindByName(driver->domains, dname);
if (!vm) {
virReportError(VIR_ERR_NO_DOMAIN,
flags, retcode, false);
cleanup:
- qemuDriverUnlock(driver);
return dom;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
goto cleanup;
asyncJob = QEMU_ASYNC_JOB_MIGRATION_OUT;
} else {
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
asyncJob = QEMU_ASYNC_JOB_NONE;
}
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return xml;
endjob:
*uri_out = NULL;
- qemuDriverLock(driver);
if (flags & VIR_MIGRATE_TUNNELLED) {
/* this is a logical error; we never should have gotten here with
* VIR_MIGRATE_TUNNELLED set
dname, dom_xml, flags);
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
goto cleanup;
}
- qemuDriverLock(driver);
ret = qemuMigrationPrepareTunnel(driver, dconn,
cookiein, cookieinlen,
cookieout, cookieoutlen,
st, dname, dom_xml, flags);
- qemuDriverUnlock(driver);
cleanup:
return ret;
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
flags, dname, resource, true);
cleanup:
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, NULL);
- qemuDriverLock(driver);
vm = virDomainObjListFindByName(driver->domains, dname);
if (!vm) {
virReportError(VIR_ERR_NO_DOMAIN,
flags, cancelled, true);
cleanup:
- qemuDriverUnlock(driver);
return dom;
}
virCheckFlags(QEMU_MIGRATION_FLAGS, -1);
- qemuDriverLock(driver);
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
char uuidstr[VIR_UUID_STRING_BUFLEN];
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(cfg);
return ret;
}
if (!pci)
return -1;
- qemuDriverLock(driver);
virObjectLock(driver->activePciHostdevs);
virObjectLock(driver->inactivePciHostdevs);
in_inactive_list = virPCIDeviceListFind(driver->inactivePciHostdevs, pci);
out:
virObjectUnlock(driver->inactivePciHostdevs);
virObjectUnlock(driver->activePciHostdevs);
- qemuDriverUnlock(driver);
if (in_inactive_list)
virPCIDeviceFree(pci);
return ret;
if (!pci)
return -1;
- qemuDriverLock(driver);
virObjectLock(driver->activePciHostdevs);
virObjectLock(driver->inactivePciHostdevs);
other = virPCIDeviceListFind(driver->activePciHostdevs, pci);
out:
virObjectUnlock(driver->inactivePciHostdevs);
virObjectUnlock(driver->activePciHostdevs);
- qemuDriverUnlock(driver);
virPCIDeviceFree(pci);
return ret;
}
if (!pci)
return -1;
- qemuDriverLock(driver);
virObjectLock(driver->activePciHostdevs);
virObjectLock(driver->inactivePciHostdevs);
out:
virObjectUnlock(driver->inactivePciHostdevs);
virObjectUnlock(driver->activePciHostdevs);
- qemuDriverUnlock(driver);
virPCIDeviceFree(pci);
return ret;
}
virCheckFlags(0, VIR_CPU_COMPARE_ERROR);
- qemuDriverLock(driver);
-
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
cleanup:
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
}
-
-/* this function expects the driver lock to be held by the caller */
static int
-qemuDomainSnapshotFSFreeze(virQEMUDriverPtr driver,
- virDomainObjPtr vm) {
+qemuDomainSnapshotFSFreeze(virDomainObjPtr vm) {
qemuDomainObjPrivatePtr priv = vm->privateData;
int freezed;
return -1;
}
- qemuDomainObjEnterAgentWithDriver(driver, vm);
+ qemuDomainObjEnterAgent(vm);
freezed = qemuAgentFSFreeze(priv->agent);
- qemuDomainObjExitAgentWithDriver(driver, vm);
+ qemuDomainObjExitAgent(vm);
return freezed;
}
static int
-qemuDomainSnapshotFSThaw(virQEMUDriverPtr driver,
- virDomainObjPtr vm, bool report)
+qemuDomainSnapshotFSThaw(virDomainObjPtr vm, bool report)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int thawed;
return -1;
}
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
if (!report)
err = virSaveLastError();
thawed = qemuAgentFSThaw(priv->agent);
if (!report)
virSetError(err);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
virFreeError(err);
return thawed;
bool resume = false;
int ret = -1;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
return -1;
if (!virDomainObjIsActive(vm)) {
}
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorCreateSnapshot(priv->mon, snap->def->name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto cleanup;
}
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
cleanup:
virCgroupFree(&cgroup);
int thaw = 0; /* 1 if freeze succeeded, -1 if freeze failed */
bool pmsuspended = false;
- if (qemuDomainObjBeginAsyncJobWithDriver(driver, vm,
+ if (qemuDomainObjBeginAsyncJob(driver, vm,
QEMU_ASYNC_JOB_SNAPSHOT) < 0)
goto cleanup;
* fail if the guest is paused or the guest agent is not
* running. */
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) {
- if (qemuDomainSnapshotFSFreeze(driver, vm) < 0) {
+ if (qemuDomainSnapshotFSFreeze(vm) < 0) {
/* helper reported the error */
thaw = -1;
goto endjob;
goto cleanup;
}
if (vm && thaw != 0 &&
- qemuDomainSnapshotFSThaw(driver, vm, thaw > 0) < 0) {
+ qemuDomainSnapshotFSThaw(vm, thaw > 0) < 0) {
/* helper reported the error, if it was needed */
if (thaw > 0)
ret = -1;
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE)
parse_flags |= VIR_DOMAIN_SNAPSHOT_PARSE_REDEFINE;
- qemuDriverLock(driver);
virUUIDFormat(domain->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (!vm) {
}
virDomainSnapshotDefFree(def);
VIR_FREE(xml);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return snapshot;
* and use of FORCE can cause multiple transitions.
*/
- qemuDriverLock(driver);
virUUIDFormat(snapshot->domain->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, snapshot->domain->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (snap->def->state == VIR_DOMAIN_RUNNING
goto endjob;
}
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
rc = qemuMonitorLoadSnapshot(priv->mon, snap->def->name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (rc < 0) {
/* XXX resume domain if it was running before the
* failed loadvm attempt? */
}
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY |
VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, -1);
- qemuDriverLock(driver);
virUUIDFormat(snapshot->domain->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, snapshot->domain->uuid);
if (!vm) {
}
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (flags & (VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN |
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(cfg);
return ret;
}
virCheckFlags(0, NULL);
- qemuDriverLock(driver);
-
if (!(caps = virQEMUDriverGetCapabilities(driver, false)))
goto cleanup;
def = NULL;
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (qemuProcessAttach(conn, driver, vm, pid,
virDomainChrSourceDefFree(monConfig);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
VIR_FREE(pidfile);
virObjectUnref(caps);
return dom;
/* Probe the status, if needed. */
if (!disk->mirroring) {
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorBlockJob(priv->mon, device, NULL, 0, &info,
BLOCK_JOB_INFO, true);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
}
/* Attempt the pivot. */
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorDrivePivot(priv->mon, device, disk->mirror, format);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret == 0) {
/* XXX We want to revoke security labels and disk lease, as
int idx;
virDomainDiskDefPtr disk;
- qemuDriverLock(driver);
virUUIDFormat(dom->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
goto endjob;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
/* XXX - libvirt should really be tracking the backing file chain
* itself, and validating that base is on the chain, rather than
* relying on qemu to do this. */
ret = qemuMonitorBlockJob(priv->mon, device, base, bandwidth, info, mode,
async);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto endjob;
.tv_nsec = 50 * 1000 * 1000ull };
virDomainBlockJobInfo dummy;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorBlockJob(priv->mon, device, NULL, 0, &dummy,
BLOCK_JOB_INFO, async);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret <= 0)
break;
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
nanosleep(&ts, NULL);
- qemuDriverLock(driver);
virObjectLock(vm);
if (!virDomainObjIsActive(vm)) {
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH, -1);
- qemuDriverLock(driver);
virUUIDFormat(dom->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorOpenGraphics(priv->mon, protocol, fd, "graphicsfd",
(flags & VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH) != 0);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (qemuDomainObjEndJob(driver, vm) == 0) {
vm = NULL;
goto cleanup;
cleanup:
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
memset(&info, 0, sizeof(info));
- qemuDriverLock(driver);
virUUIDFormat(dom->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
info.read_iops_sec = oldinfo->read_iops_sec;
info.write_iops_sec = oldinfo->write_iops_sec;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSetBlockIoThrottle(priv->mon, device, &info);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto endjob;
vm->def->disks[idx]->blkdeviotune = info;
VIR_FREE(device);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
virObjectUnref(caps);
virObjectUnref(cfg);
return ret;
/* We don't return strings, and thus trivially support this flag. */
flags &= ~VIR_TYPED_PARAM_STRING_OKAY;
- qemuDriverLock(driver);
virUUIDFormat(dom->uuid, uuidstr);
vm = virDomainObjListFindByUUID(driver->domains, dom->uuid);
if (!vm) {
goto cleanup;
}
- if (qemuDomainObjBeginJobWithDriver(driver, vm, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainLiveConfigHelperMethod(caps, vm, &flags,
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
priv = vm->privateData;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetBlockIoThrottle(priv->mon, device, &reply);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto endjob;
}
if (vm)
virObjectUnlock(vm);
virObjectUnref(caps);
- qemuDriverUnlock(driver);
return ret;
}
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
- qemuDriverLock(driver);
-
vm = virDomainObjListFindByUUID(driver->domains, domain->uuid);
if (vm == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
virCgroupFree(&group);
if (vm)
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return ret;
}
goto endjob;
}
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
ret = qemuAgentSuspend(priv->agent, target);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
endjob:
if (qemuDomainObjEndJob(driver, vm) == 0)
virCheckFlags(VIR_CONNECT_LIST_DOMAINS_FILTERS_ALL, -1);
- qemuDriverLock(driver);
ret = virDomainObjListExport(driver->domains, conn, domains, flags);
- qemuDriverUnlock(driver);
return ret;
}
goto endjob;
}
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
ret = qemuAgentArbitraryCommand(priv->agent, cmd, &result, timeout);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
if (ret < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Failed to execute agent command"));
goto endjob;
}
- qemuDomainObjEnterAgent(driver, vm);
+ qemuDomainObjEnterAgent(vm);
ret = qemuAgentFSTrim(priv->agent, minimum);
- qemuDomainObjExitAgent(driver, vm);
+ qemuDomainObjExitAgent(vm);
endjob:
if (qemuDomainObjEndJob(driver, vm) == 0)
if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
goto error;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorEjectMedia(priv->mon, driveAlias, force);
/* we don't want to report errors from media tray_open polling */
disk->src, format);
}
exit_monitor:
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, origdisk->src, disk->src, "update", ret >= 0);
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
table = qemuMonitorGetBlockInfo(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
if (!table)
goto error;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
memcpy(&disk->info.addr.pci, &guestAddr, sizeof(guestAddr));
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
} else {
type,
&controller->info.addr.pci);
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret == 0) {
controller->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
goto error;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
disk->info.addr.drive.unit = driveAddr.unit;
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0);
goto error;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
} else {
ret = qemuMonitorAddUSBDisk(priv->mon, disk->src);
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret >= 0);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto cleanup;
}
} else {
if (qemuMonitorAddHostNetwork(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto cleanup;
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
VIR_FORCE_CLOSE(tapfd);
VIR_FORCE_CLOSE(vhostfd);
goto try_remove;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
guestAddr = net->info.addr.pci;
if (qemuMonitorAddPCINetwork(priv->mon, nicstr,
&guestAddr) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
net->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
memcpy(&net->info.addr.pci, &guestAddr, sizeof(guestAddr));
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
/* set link state */
if (net->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("device alias not found: cannot set link state to down"));
} else {
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
goto try_remove;
}
_("setting of link state not supported: Link is up"));
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
/* link set to down */
}
char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorRemoveNetdev(priv->mon, netdev_name) < 0)
VIR_WARN("Failed to remove network backend for netdev %s",
netdev_name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
VIR_FREE(netdev_name);
} else {
VIR_WARN("Unable to remove network backend");
char *hostnet_name;
if (virAsprintf(&hostnet_name, "host%s", net->info.alias) < 0)
goto no_memory;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0)
VIR_WARN("Failed to remove network backend for vlan %d, net %s",
vlan, hostnet_name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
VIR_FREE(hostnet_name);
}
goto cleanup;
priv->qemuCaps)))
goto error;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorAddDeviceWithFd(priv->mon, devstr,
configfd, configfd_name);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
} else {
virDevicePCIAddress guestAddr = hostdev->info->addr.pci;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorAddPCIHostDevice(priv->mon,
&hostdev->source.subsys.u.pci,
&guestAddr);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
hostdev->info->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
memcpy(&hostdev->info->addr.pci, &guestAddr, sizeof(guestAddr));
goto error;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
goto error;
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditRedirdev(vm, redirdev, "attach", ret == 0);
if (ret < 0)
goto error;
virUSBDeviceFree(usb);
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
hostdev->source.subsys.u.usb.bus,
hostdev->source.subsys.u.usb.device);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
if (ret < 0)
goto error;
return -1;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSetLink(priv->mon, dev->info.alias, linkstate);
if (ret < 0)
dev->linkstate = linkstate;
cleanup:
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
return ret;
}
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
goto cleanup;
}
} else {
if (qemuMonitorRemovePCIDevice(priv->mon,
&detach->info.addr.pci) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
goto cleanup;
}
/* disconnect guest from host device */
qemuMonitorDriveDel(priv->mon, drivestr);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
goto cleanup;
}
/* disconnect guest from host device */
qemuMonitorDriveDel(priv->mon, drivestr);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
} else {
if (qemuMonitorRemovePCIDevice(priv->mon,
&detach->info.addr.pci) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainControllerRemove(vm->def, idx);
virDomainControllerDefFree(detach);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
rv = qemuMonitorDelDevice(priv->mon, detach->info->alias);
} else {
rv = qemuMonitorRemovePCIDevice(priv->mon, &detach->info->addr.pci);
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditHostdev(vm, detach, "detach", rv == 0);
if (rv < 0)
goto cleanup;
return -1;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditHostdev(vm, detach, "detach", ret == 0);
if (ret < 0)
return -1;
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
goto cleanup;
}
} else {
if (qemuMonitorRemovePCIDevice(priv->mon,
&detach->info.addr.pci) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
goto cleanup;
}
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
goto cleanup;
}
} else {
if (qemuMonitorRemoveHostNetwork(priv->mon, vlan, hostnet_name) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
goto cleanup;
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", true);
if (auth->connected)
connected = virDomainGraphicsAuthConnectedTypeToString(auth->connected);
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSetPassword(priv->mon,
type,
auth->passwd ? auth->passwd : defaultPasswd,
}
end_job:
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
cleanup:
virObjectUnref(cfg);
return ret;
/*
* qemu_migration.c: QEMU migration handling
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2013 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
ret = qemuMonitorGetSpiceMigrationStatus(priv->mon,
&spice_migrated);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0 || virTimeMillisNow(&priv->job.info.timeElapsed) < 0) {
priv->job.info.type = VIR_DOMAIN_JOB_FAILED;
}
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
nanosleep(&ts, NULL);
- qemuDriverLock(driver);
virObjectLock(vm);
}
cookie->graphics->port,
cookie->graphics->tlsPort,
cookie->graphics->tlsSubject);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
return ret;
/* explicitly do this *after* we entered the monitor,
* as this is a critical section so we are guaranteed
* priv->job.asyncAbort will not change */
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virReportError(VIR_ERR_OPERATION_ABORTED, _("%s: %s"),
qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
_("canceled by client"));
}
if (qemuMonitorSetMigrationSpeed(priv->mon, migrate_speed) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
/* connect to the destination qemu if needed */
if (spec->destType == MIGRATION_DEST_CONNECT_HOST &&
qemuMigrationConnect(driver, vm, spec) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
VIR_FORCE_CLOSE(spec->dest.fd.qemu);
break;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto cleanup;
ret = -1;
if (qemuDomainObjEnterMonitorAsync(driver, vm,
QEMU_ASYNC_JOB_MIGRATION_OUT) == 0) {
qemuMonitorMigrateCancel(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
}
goto cleanup;
if (!(st = virStreamNew(dconn, 0)))
goto cleanup;
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ret = dconn->driver->domainMigratePrepareTunnel
(dconn, st, flags, dname, resource, dom_xml);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
} else {
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ret = dconn->driver->domainMigratePrepare2
(dconn, &cookie, &cookielen, NULL, &uri_out,
flags, dname, resource, dom_xml);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
}
VIR_FREE(dom_xml);
if (ret == -1)
goto cleanup;
/* the domain may have shutdown or crashed while we had the locks dropped
- * in qemuDomainObjEnterRemoteWithDriver, so check again
+ * in qemuDomainObjEnterRemote, so check again
*/
if (!virDomainObjIsActive(vm)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
*/
dname = dname ? dname : vm->def->name;
VIR_DEBUG("Finish2 %p ret=%d", dconn, ret);
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ddomain = dconn->driver->domainMigrateFinish2
(dconn, dname, cookie, cookielen,
uri_out ? uri_out : dconnuri, flags, cancelled);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
cleanup:
if (ddomain) {
if (!(st = virStreamNew(dconn, 0)))
goto cleanup;
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ret = dconn->driver->domainMigratePrepareTunnel3
(dconn, st, cookiein, cookieinlen,
&cookieout, &cookieoutlen,
flags, dname, resource, dom_xml);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
} else {
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ret = dconn->driver->domainMigratePrepare3
(dconn, cookiein, cookieinlen, &cookieout, &cookieoutlen,
uri, &uri_out, flags, dname, resource, dom_xml);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
}
VIR_FREE(dom_xml);
if (ret == -1)
cookieout = NULL;
cookieoutlen = 0;
dname = dname ? dname : vm->def->name;
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
ddomain = dconn->driver->domainMigrateFinish3
(dconn, dname, cookiein, cookieinlen, &cookieout, &cookieoutlen,
dconnuri, uri_out ? uri_out : uri, flags, cancelled);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
/* If ddomain is NULL, then we were unable to start
* the guest on the target, and must restart on the
* destination side is completely setup before we touch the source
*/
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
dconn = virConnectOpen(dconnuri);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
if (dconn == NULL) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("Failed to connect to remote libvirt URI %s"), dconnuri);
cfg->keepAliveCount) < 0)
goto cleanup;
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
p2p = VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn,
VIR_DRV_FEATURE_MIGRATION_P2P);
/* v3proto reflects whether the caller used Perform3, but with
if (flags & VIR_MIGRATE_OFFLINE)
offline = VIR_DRV_SUPPORTS_FEATURE(dconn->driver, dconn,
VIR_DRV_FEATURE_MIGRATION_OFFLINE);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
if (!p2p) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
cleanup:
orig_err = virSaveLastError();
- qemuDomainObjEnterRemoteWithDriver(driver, vm);
+ qemuDomainObjEnterRemote(vm);
virConnectClose(dconn);
- qemuDomainObjExitRemoteWithDriver(driver, vm);
+ qemuDomainObjExitRemote(vm);
if (orig_err) {
virSetError(orig_err);
virFreeError(orig_err);
}
-/* Helper function called while driver lock is held and vm is active. */
+/* Helper function called while vm is active. */
int
qemuMigrationToFile(virQEMUDriverPtr driver, virDomainObjPtr vm,
int fd, off_t offset, const char *path,
qemuMonitorSetMigrationSpeed(priv->mon,
QEMU_DOMAIN_MIG_BANDWIDTH_MAX);
priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
if (virSetCloseExec(pipeFD[1]) < 0) {
virReportSystemError(errno, "%s",
_("Unable to set cloexec flag"));
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
if (virCommandRunAsync(cmd, NULL) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
rc = qemuMonitorMigrateToFd(priv->mon,
args, path, offset);
}
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (rc < 0)
goto cleanup;
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
qemuMonitorSetMigrationSpeed(priv->mon, saveMigBandwidth);
priv->migMaxBandwidth = saveMigBandwidth;
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
VIR_FORCE_CLOSE(pipeFD[0]);
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- if (qemuDomainObjBeginAsyncJobWithDriver(driver, vm, job) < 0)
+ if (qemuDomainObjBeginAsyncJob(driver, vm, job) < 0)
return -1;
if (job == QEMU_ASYNC_JOB_MIGRATION_IN) {
/*
* qemu_process.h: QEMU process management
*
- * Copyright (C) 2006-2012 Red Hat, Inc.
+ * Copyright (C) 2006-2013 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
qemuProcessHandleAgentEOF(qemuAgentPtr agent,
virDomainObjPtr vm)
{
- virQEMUDriverPtr driver = qemu_driver;
qemuDomainObjPrivatePtr priv;
VIR_DEBUG("Received EOF from agent on %p '%s'", vm, vm->def->name);
- qemuDriverLock(driver);
virObjectLock(vm);
priv = vm->privateData;
priv->agent = NULL;
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
qemuAgentClose(agent);
return;
unlock:
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
return;
}
qemuProcessHandleAgentError(qemuAgentPtr agent ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
- virQEMUDriverPtr driver = qemu_driver;
qemuDomainObjPrivatePtr priv;
VIR_DEBUG("Received error from agent on %p '%s'", vm, vm->def->name);
- qemuDriverLock(driver);
virObjectLock(vm);
priv = vm->privateData;
priv->agentError = true;
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
}
static void qemuProcessHandleAgentDestroy(qemuAgentPtr agent,
ignore_value(virTimeMillisNow(&priv->agentStart));
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
agent = qemuAgentOpen(vm,
config,
&agentCallbacks);
- qemuDriverLock(driver);
virObjectLock(vm);
priv->agentStart = 0;
VIR_DEBUG("Received EOF on %p '%s'", vm, vm->def->name);
- qemuDriverLock(driver);
virObjectLock(vm);
priv = vm->privateData;
cleanup:
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
}
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
- qemuDriverLock(driver);
virObjectLock(vm);
((qemuDomainObjPrivatePtr) vm->privateData)->monError = true;
qemuDomainEventQueue(driver, event);
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
}
virObjectUnlock(vm);
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
return 0;
}
virDomainEventPtr event = NULL;
int ret = -1;
VIR_DEBUG("vm=%p", vm);
- qemuDriverLock(driver);
virObjectLock(vm);
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MODIFY) < 0)
goto cleanup;
goto endjob;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorSystemReset(priv->mon) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto endjob;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (!virDomainObjIsActive(vm)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
cleanup:
if (vm) {
if (ret == -1) {
- ignore_value(qemuProcessKill(driver, vm,
- VIR_QEMU_PROCESS_KILL_FORCE));
+ ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_FORCE));
}
if (virObjectUnref(vm))
virObjectUnlock(vm);
}
if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
}
qemuProcessFakeReboot,
vm) < 0) {
VIR_ERROR(_("Failed to create reboot thread, killing domain"));
- ignore_value(qemuProcessKill(driver, vm,
- VIR_QEMU_PROCESS_KILL_NOWAIT));
+ ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_NOWAIT));
virObjectUnref(vm);
}
} else {
- ignore_value(qemuProcessKill(driver, vm, VIR_QEMU_PROCESS_KILL_NOWAIT));
+ ignore_value(qemuProcessKill(vm, VIR_QEMU_PROCESS_KILL_NOWAIT));
}
}
unlock:
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
unlock:
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (watchdogEvent || lifecycleEvent) {
- qemuDriverLock(driver);
- if (watchdogEvent)
- qemuDomainEventQueue(driver, watchdogEvent);
- if (lifecycleEvent)
- qemuDomainEventQueue(driver, lifecycleEvent);
- qemuDriverUnlock(driver);
- }
+ if (watchdogEvent)
+ qemuDomainEventQueue(driver, watchdogEvent);
+ if (lifecycleEvent)
+ qemuDomainEventQueue(driver, lifecycleEvent);
virObjectUnref(caps);
virObjectUnref(cfg);
virObjectUnlock(vm);
cleanup:
- if (ioErrorEvent || ioErrorEvent2 || lifecycleEvent) {
- qemuDriverLock(driver);
- if (ioErrorEvent)
- qemuDomainEventQueue(driver, ioErrorEvent);
- if (ioErrorEvent2)
- qemuDomainEventQueue(driver, ioErrorEvent2);
- if (lifecycleEvent)
- qemuDomainEventQueue(driver, lifecycleEvent);
- qemuDriverUnlock(driver);
- }
+ if (ioErrorEvent)
+ qemuDomainEventQueue(driver, ioErrorEvent);
+ if (ioErrorEvent2)
+ qemuDomainEventQueue(driver, ioErrorEvent2);
+ if (lifecycleEvent)
+ qemuDomainEventQueue(driver, lifecycleEvent);
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
return 0;
}
event = virDomainEventGraphicsNewFromObj(vm, phase, localAddr, remoteAddr, authScheme, subject);
virObjectUnlock(vm);
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
return 0;
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (event || lifecycleEvent) {
- qemuDriverLock(driver);
- if (event)
- qemuDomainEventQueue(driver, event);
- if (lifecycleEvent)
- qemuDomainEventQueue(driver, lifecycleEvent);
- qemuDriverUnlock(driver);
- }
+ if (event)
+ qemuDomainEventQueue(driver, event);
+ if (lifecycleEvent)
+ qemuDomainEventQueue(driver, lifecycleEvent);
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (event || lifecycleEvent) {
- qemuDriverLock(driver);
- if (event)
- qemuDomainEventQueue(driver, event);
- if (lifecycleEvent)
- qemuDomainEventQueue(driver, lifecycleEvent);
- qemuDriverUnlock(driver);
- }
+ if (event)
+ qemuDomainEventQueue(driver, event);
+ if (lifecycleEvent)
+ qemuDomainEventQueue(driver, lifecycleEvent);
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (event) {
- qemuDriverLock(driver);
+ if (event)
qemuDomainEventQueue(driver, event);
- qemuDriverUnlock(driver);
- }
virObjectUnref(caps);
virObjectUnref(cfg);
return 0;
virObjectUnlock(vm);
cleanup:
- if (event || lifecycleEvent) {
- qemuDriverLock(driver);
- if (event)
- qemuDomainEventQueue(driver, event);
- if (lifecycleEvent)
- qemuDomainEventQueue(driver, lifecycleEvent);
- qemuDriverUnlock(driver);
- }
+ if (event)
+ qemuDomainEventQueue(driver, event);
+ if (lifecycleEvent)
+ qemuDomainEventQueue(driver, lifecycleEvent);
virObjectUnref(caps);
virObjectUnref(cfg);
ignore_value(virTimeMillisNow(&priv->monStart));
virObjectUnlock(vm);
- qemuDriverUnlock(driver);
mon = qemuMonitorOpen(vm,
priv->monConfig,
priv->monJSON,
&monitorCallbacks);
- qemuDriverLock(driver);
virObjectLock(vm);
priv->monStart = 0;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSetCapabilities(priv->mon);
if (ret == 0 &&
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON))
ret = virQEMUCapsProbeQMP(priv->qemuCaps, priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
error:
goto cleanup;
priv = vm->privateData;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetPtyPaths(priv->mon, paths);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
if (ret == 0)
int ncpupids;
qemuDomainObjPrivatePtr priv = vm->privateData;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
/* failure to get the VCPU<-> PID mapping or to execute the query
* command will not be treated fatal as some versions of qemu don't
* support this command */
if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) <= 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
virResetLastError();
priv->nvcpupids = 1;
priv->vcpupids[0] = vm->pid;
return 0;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ncpupids != vm->def->vcpus) {
virReportError(VIR_ERR_INTERNAL_ERROR,
goto cleanup;
alias = vm->def->disks[i]->info.alias;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorSetDrivePassphrase(priv->mon, alias, secret);
VIR_FREE(secret);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0)
goto cleanup;
}
int ret;
qemuMonitorPCIAddress *addrs = NULL;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
naddrs = qemuMonitorGetAllPCIAddresses(priv->mon,
&addrs);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
ret = qemuProcessDetectPCIAddresses(vm, addrs, naddrs);
/*
- * Precondition: Both driver and vm must be locked,
- * and a job must be active. This method will call
- * {Enter,Exit}MonitorWithDriver
+ * Precondition: vm must be locked, and a job must be active.
+ * This method will call {Enter,Exit}Monitor
*/
int
qemuProcessStartCPUs(virQEMUDriverPtr driver, virDomainObjPtr vm,
ret = qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob);
if (ret == 0) {
ret = qemuMonitorStartCPUs(priv->mon, conn);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
if (ret == 0) {
ret = qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob);
if (ret == 0) {
ret = qemuMonitorStopCPUs(priv->mon);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
}
if (ret == 0) {
char *msg = NULL;
int ret;
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
ret = qemuMonitorGetStatus(priv->mon, &running, &reason);
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (ret < 0 || !virDomainObjIsActive(vm))
return -1;
VIR_FREE(data);
- qemuDriverLock(driver);
virObjectLock(obj);
cfg = virQEMUDriverGetConfig(driver);
if (obj && virObjectUnref(obj))
virObjectUnlock(obj);
- qemuDriverUnlock(driver);
-
virConnectClose(conn);
virObjectUnref(cfg);
virObjectUnref(caps);
if (!virDomainObjIsActive(obj)) {
if (virObjectUnref(obj))
virObjectUnlock(obj);
- qemuDriverUnlock(driver);
return;
}
virObjectUnlock(obj);
}
}
- qemuDriverUnlock(driver);
virConnectClose(conn);
virObjectUnref(caps);
virObjectUnref(cfg);
memcpy(data, src, sizeof(*data));
data->payload = obj;
- /* This iterator is called with driver being locked.
+ /*
* We create a separate thread to run qemuProcessReconnect in it.
* However, qemuProcessReconnect needs to:
- * 1. lock driver
- * 2. just before monitor reconnect do lightweight MonitorEnter
+ * 1. just before monitor reconnect do lightweight MonitorEnter
* (increase VM refcount, unlock VM & driver)
- * 3. reconnect to monitor
- * 4. do lightweight MonitorExit (lock driver & VM)
- * 5. continue reconnect process
- * 6. EndJob
- * 7. unlock driver
- *
- * It is necessary to NOT hold driver lock for the entire run
- * of reconnect, otherwise we will get blocked if there is
- * unresponsive qemu.
- * However, iterating over hash table MUST be done on locked
- * driver.
+ * 2. reconnect to monitor
+ * 3. do lightweight MonitorExit (lock VM)
+ * 4. continue reconnect process
+ * 5. EndJob
*
* NB, we can't do normal MonitorEnter & MonitorExit because
* these two lock the monitor lock, which does not exists in
qemuDomainObjRestoreJob(obj, &data->oldjob);
- if (qemuDomainObjBeginJobWithDriver(src->driver, obj, QEMU_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(src->driver, obj, QEMU_JOB_MODIFY) < 0)
goto error;
/* Since we close the connection later on, we have to make sure
/* qemu doesn't support setting this on the command line, so
* enter the monitor */
VIR_DEBUG("Setting network link states");
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuProcessSetLinkStates(vm) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
/* Technically, qemuProcessStart can be called from inside
* QEMU_ASYNC_JOB_MIGRATION_IN, but we are okay treating this like
vm->def->mem.cur_balloon);
goto cleanup;
}
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorSetBalloon(priv->mon, cur_balloon) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (!(flags & VIR_QEMU_PROCESS_START_PAUSED)) {
VIR_DEBUG("Starting domain CPUs");
int
-qemuProcessKill(virQEMUDriverPtr driver,
- virDomainObjPtr vm, unsigned int flags)
+qemuProcessKill(virDomainObjPtr vm, unsigned int flags)
{
int ret;
return 0;
}
- if (driver)
- qemuDriverUnlock(driver);
-
ret = virProcessKillPainfully(vm->pid,
!!(flags & VIR_QEMU_PROCESS_KILL_FORCE));
- if (driver) {
- virObjectRef(vm);
- virObjectUnlock(vm);
- qemuDriverLock(driver);
- virObjectLock(vm);
- virObjectUnref(vm);
- }
-
return ret;
}
}
/*
- * We may unlock the driver and vm in qemuProcessKill(), and another thread
- * can lock driver and vm, and then call qemuProcessStop(). So we should
+ * We may unlock the vm in qemuProcessKill(), and another thread
+ * can lock the vm, and then call qemuProcessStop(). So we should
* set vm->def->id to -1 here to avoid qemuProcessStop() to be called twice.
*/
vm->def->id = -1;
}
/* shut it off for sure */
- ignore_value(qemuProcessKill(driver, vm, VIR_QEMU_PROCESS_KILL_FORCE|
- VIR_QEMU_PROCESS_KILL_NOCHECK));
+ ignore_value(qemuProcessKill(vm,
+ VIR_QEMU_PROCESS_KILL_FORCE|
+ VIR_QEMU_PROCESS_KILL_NOCHECK));
qemuDomainCleanupRun(driver, vm);
}
VIR_DEBUG("Getting initial memory amount");
- qemuDomainObjEnterMonitorWithDriver(driver, vm);
+ qemuDomainObjEnterMonitor(driver, vm);
if (qemuMonitorGetBalloonInfo(priv->mon, &vm->def->mem.cur_balloon) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
if (qemuMonitorGetStatus(priv->mon, &running, &reason) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
if (qemuMonitorGetVirtType(priv->mon, &vm->def->virtType) < 0) {
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
goto cleanup;
}
- qemuDomainObjExitMonitorWithDriver(driver, vm);
+ qemuDomainObjExitMonitor(driver, vm);
if (!virDomainObjIsActive(vm))
goto cleanup;
qemuDomainObjDiscardAsyncJob(driver, dom);
}
- if (qemuDomainObjBeginJobWithDriver(driver, dom,
- QEMU_JOB_DESTROY) < 0)
+ if (qemuDomainObjBeginJob(driver, dom,
+ QEMU_JOB_DESTROY) < 0)
goto cleanup;
VIR_DEBUG("Killing domain");
VIR_QEMU_PROCESS_KILL_NOCHECK = 1 << 2, /* bypass the running vm check */
} virQemuProcessKillMode;
-int qemuProcessKill(virQEMUDriverPtr driver,
- virDomainObjPtr vm, unsigned int flags);
+int qemuProcessKill(virDomainObjPtr vm, unsigned int flags);
int qemuProcessAutoDestroyInit(virQEMUDriverPtr driver);
void qemuProcessAutoDestroyShutdown(virQEMUDriverPtr driver);
projects / thirdparty / libvirt.git / commitdiff
