if (!dd->started) {
if (dd->added) {
- qemuDomainObjEnterMonitor(priv->driver, vm);
+ qemuDomainObjEnterMonitor(vm);
qemuBlockStorageSourceAttachRollback(priv->mon, dd->crdata->srcdata[0]);
qemuDomainObjExitMonitor(vm);
}
VIR_ASYNC_JOB_BACKUP) < 0)
return -1;
} else {
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, VIR_ASYNC_JOB_BACKUP) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_BACKUP) < 0)
return -1;
rc = qemuBlockStorageSourceAttachApply(priv->mon, dd->crdata->srcdata[0]);
if (backupdisk->state != VIR_DOMAIN_BACKUP_DISK_STATE_RUNNING)
continue;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
rc = qemuMonitorBlockJobCancel(priv->mon, job->name, true);
* infrastructure for async jobs. We'll allow standard modify-type jobs
* as the interlocking of conflicting operations is handled on the block
* job level */
- if (qemuDomainObjBeginAsyncJob(priv->driver, vm, VIR_ASYNC_JOB_BACKUP,
+ if (qemuDomainObjBeginAsyncJob(vm, VIR_ASYNC_JOB_BACKUP,
VIR_DOMAIN_JOB_OPERATION_BACKUP, flags) < 0)
return -1;
priv->backup = g_steal_pointer(&def);
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, VIR_ASYNC_JOB_BACKUP) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_BACKUP) < 0)
goto endjob;
if (pull) {
}
if (pull) {
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, VIR_ASYNC_JOB_BACKUP) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_BACKUP) < 0)
goto endjob;
/* note that if the export fails we've already created the checkpoint
* and we will not delete it */
qemuCheckpointRollbackMetadata(vm, chk);
if (!job_started && (nbd_running || tlsAlias || tlsSecretAlias) &&
- qemuDomainObjEnterMonitorAsync(priv->driver, vm, VIR_ASYNC_JOB_BACKUP) == 0) {
+ qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_BACKUP) == 0) {
if (nbd_running)
ignore_value(qemuMonitorNBDServerStop(priv->mon));
if (tlsAlias)
return;
if (backup->type == VIR_DOMAIN_BACKUP_TYPE_PULL) {
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
ignore_value(qemuMonitorNBDServerStop(priv->mon));
if (backup->tlsAlias)
int
-qemuBackupGetJobInfoStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBackupGetJobInfoStats(virDomainObj *vm,
virDomainJobData *jobData)
{
qemuDomainJobDataPrivate *privJob = jobData->privateData;
jobData->status = VIR_DOMAIN_JOB_STATUS_ACTIVE;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorGetJobInfo(priv->mon, &blockjobs, &nblockjobs);
virDomainJobStatus jobstatus);
int
-qemuBackupGetJobInfoStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBackupGetJobInfoStats(virDomainObj *vm,
virDomainJobData *jobData);
/* exported for testing */
int
-qemuBlockNodeNamesDetect(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBlockNodeNamesDetect(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_NAMED_BLOCK_NODES))
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
data = qemuMonitorQueryNamedBlockNodes(qemuDomainGetMonitor(vm));
* monitor internally.
*/
int
-qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBlockStorageSourceDetachOneBlockdev(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virStorageSource *src)
{
int ret;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorBlockdevDel(qemuDomainGetMonitor(vm), src->nodeformat);
qemuBlockJobSyncBegin(job);
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuMonitorBlockdevCreate(priv->mon, job->name, &props);
false, true) < 0)
return -1;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuBlockStorageSourceAttachApplyStorageDeps(priv->mon, data);
if (qemuBlockStorageSourceCreateStorage(vm, src, chain, asyncJob) < 0)
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuBlockStorageSourceAttachApplyStorage(priv->mon, data);
false, true) < 0)
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuBlockStorageSourceAttachApplyFormat(priv->mon, data);
cleanup:
if (ret < 0 &&
virDomainObjIsActive(vm) &&
- qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) == 0) {
+ qemuDomainObjEnterMonitorAsync(vm, asyncJob) == 0) {
qemuBlockStorageSourceAttachRollback(priv->mon, data);
qemuDomainObjExitMonitor(vm);
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
g_autoptr(GHashTable) blockNamedNodeData = NULL;
bool supports_flat = virQEMUCapsGet(priv->qemuCaps,
QEMU_CAPS_QMP_QUERY_NAMED_BLOCK_NODES_FLAT);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return NULL;
blockNamedNodeData = qemuMonitorBlockGetNamedNodeData(priv->mon, supports_flat);
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
int rc;
/* If we are lacking the object here, qemu might have opened an image with
return -1;
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuBlockReopenFormatMon(priv->mon, src);
virJSONValue *blockstats);
int
-qemuBlockNodeNamesDetect(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBlockNodeNamesDetect(virDomainObj *vm,
virDomainAsyncJob asyncJob);
GHashTable *
qemuBlockStorageSourceAttachData *data);
int
-qemuBlockStorageSourceDetachOneBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuBlockStorageSourceDetachOneBlockdev(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virStorageSource *src);
int
-qemuBlockJobRefreshJobs(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuBlockJobRefreshJobs(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorJobInfo **jobinfo = NULL;
int ret = -1;
int rc;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorGetJobInfo(priv->mon, &jobinfo, &njobinfo);
qemuBlockJobMarkBroken(job);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorBlockJobCancel(priv->mon, job->name, true);
if (rc == -1 && jobinfo[i]->status == QEMU_MONITOR_JOB_STATUS_CONCLUDED)
disk->src->id = 0;
virStorageSourceBackingStoreClear(disk->src);
ignore_value(qemuDomainDetermineDiskChain(driver, vm, disk, NULL, true));
- ignore_value(qemuBlockNodeNamesDetect(driver, vm, asyncJob));
+ ignore_value(qemuBlockNodeNamesDetect(vm, asyncJob));
qemuBlockJobUnregister(job, vm);
qemuDomainSaveConfig(vm);
}
if (!(data = qemuBlockStorageSourceChainDetachPrepareBlockdev(chain)))
return;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
qemuBlockStorageSourceChainDetach(qemuDomainGetMonitor(vm), data);
if (!actions)
return 0;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
qemuMonitorTransaction(priv->mon, &actions);
return -1;
}
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
qemuMonitorTransaction(priv->mon, &actions);
if (!actions)
return 0;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
qemuMonitorTransaction(priv->mon, &actions);
if (!disk)
return;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
qemuMonitorBitmapRemove(priv->mon,
VIR_FREE(backend->encryptsecretAlias);
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm), backend);
!(backend = qemuBlockStorageSourceDetachPrepare(job->data.backup.store, NULL)))
return;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return;
if (backend)
unsigned long long progressCurrent = 0;
unsigned long long progressTotal = 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
/* we need to fetch the error state as the event does not propagate it */
qemuBlockJobData *job);
int
-qemuBlockJobRefreshJobs(virQEMUDriver *driver,
- virDomainObj *vm);
+qemuBlockJobRefreshJobs(virDomainObj *vm);
void
qemuBlockJobUpdate(virDomainObj *vm,
relabelimages = g_slist_prepend(relabelimages, src);
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorTransaction(priv->mon, &actions);
qemuDomainObjExitMonitor(vm);
if (qemuCheckpointCreateCommon(driver, vm, def, &actions, &chk) < 0)
return NULL;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorTransaction(qemuDomainGetMonitor(vm), &actions);
qemuDomainObjExitMonitor(vm);
if (rc < 0) {
/* Unlike snapshots, the RNG schema already ensured a sane filename. */
/* We are going to modify the domain below. */
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return NULL;
if (redefine) {
virDomainCheckpointDef *chkdef)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
g_autoptr(GHashTable) nodedataMerge = NULL;
g_autoptr(GHashTable) nodedataStats = NULL;
g_autofree struct qemuCheckpointDiskMap *diskmap = NULL;
size_t i;
int ret = -1;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (rc == 0 && recoveractions)
rc = qemuMonitorTransaction(priv->mon, &recoveractions);
if (!(nodedataStats = qemuBlockGetNamedNodeData(vm, VIR_ASYNC_JOB_NONE)))
goto endjob;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorTransaction(priv->mon, &cleanupactions);
VIR_DOMAIN_CHECKPOINT_DELETE_METADATA_ONLY |
VIR_DOMAIN_CHECKPOINT_DELETE_CHILDREN_ONLY, -1);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (!metadata_only) {
* To be followed with qemuDomainObjExitMonitor() once complete
*/
static int
-qemuDomainObjEnterMonitorInternal(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjEnterMonitorInternal(virDomainObj *obj,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = obj->privateData;
if (asyncJob != VIR_ASYNC_JOB_NONE) {
int ret;
- if ((ret = qemuDomainObjBeginNestedJob(driver, obj, asyncJob)) < 0)
+ if ((ret = qemuDomainObjBeginNestedJob(obj, asyncJob)) < 0)
return ret;
if (!virDomainObjIsActive(obj)) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
qemuDomainObjEndJob(obj);
}
-void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
- virDomainObj *obj)
+void qemuDomainObjEnterMonitor(virDomainObj *obj)
{
- ignore_value(qemuDomainObjEnterMonitorInternal(driver, obj,
+ ignore_value(qemuDomainObjEnterMonitorInternal(obj,
VIR_ASYNC_JOB_NONE));
}
* in the meantime).
*/
int
-qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjEnterMonitorAsync(virDomainObj *obj,
virDomainAsyncJob asyncJob)
{
- return qemuDomainObjEnterMonitorInternal(driver, obj, asyncJob);
+ return qemuDomainObjEnterMonitorInternal(obj, asyncJob);
}
return -1;
} else {
priv = vm->privateData;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
/* we continue on even in the face of error */
qemuMonitorDeleteSnapshot(priv->mon, snap->def->name);
qemuDomainObjExitMonitor(vm);
virDomainObjListRemoveLocked(driver->domains, vm);
}
-
void
qemuDomainSetFakeReboot(virDomainObj *vm,
bool value)
int
-qemuDomainUpdateDeviceList(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainUpdateDeviceList(virDomainObj *vm,
int asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
char **aliases;
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetDeviceAliases(priv->mon, &aliases);
qemuDomainObjExitMonitor(vm);
int
-qemuDomainUpdateMemoryDeviceInfo(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainUpdateMemoryDeviceInfo(virDomainObj *vm,
int asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (vm->def->nmems == 0)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetMemoryDeviceInfo(priv->mon, &meminfo);
* Returns 0 on success and -1 on fatal error.
*/
int
-qemuDomainRefreshVcpuInfo(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRefreshVcpuInfo(virDomainObj *vm,
int asyncJob,
bool state)
{
hotplug = qemuDomainSupportsNewVcpuHotplug(vm);
VIR_DEBUG("Maxvcpus %zu hotplug %d", maxvcpus, hotplug);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetCPUInfo(qemuDomainGetMonitor(vm), &info, maxvcpus,
* Returns 0 on success and -1 on error
*/
int
-qemuDomainRefreshVcpuHalted(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRefreshVcpuHalted(virDomainObj *vm,
int asyncJob)
{
virDomainVcpuDef *vcpu;
if (!ARCH_IS_S390(vm->def->os.arch))
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
haltedmap = qemuMonitorGetCpuHalted(qemuDomainGetMonitor(vm), maxvcpus);
int
-qemuDomainCheckMonitor(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainCheckMonitor(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorCheck(priv->mon);
qemuMonitor *qemuDomainGetMonitor(virDomainObj *vm)
ATTRIBUTE_NONNULL(1);
-void qemuDomainObjEnterMonitor(virQEMUDriver *driver,
- virDomainObj *obj)
+void qemuDomainObjEnterMonitor(virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
void qemuDomainObjExitMonitor(virDomainObj *obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainObjEnterMonitorAsync(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjEnterMonitorAsync(virDomainObj *obj,
virDomainAsyncJob asyncJob)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
extern virDomainABIStability virQEMUDriverDomainABIStability;
extern virSaveCookieCallbacks virQEMUDriverDomainSaveCookie;
-int qemuDomainUpdateDeviceList(virQEMUDriver *driver,
- virDomainObj *vm, int asyncJob);
+int qemuDomainUpdateDeviceList(virDomainObj *vm, int asyncJob);
-int qemuDomainUpdateMemoryDeviceInfo(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainUpdateMemoryDeviceInfo(virDomainObj *vm,
int asyncJob);
bool qemuDomainDefCheckABIStability(virQEMUDriver *driver,
bool qemuDomainHasVcpuPids(virDomainObj *vm);
pid_t qemuDomainGetVcpuPid(virDomainObj *vm, unsigned int vcpuid);
int qemuDomainValidateVcpuInfo(virDomainObj *vm);
-int qemuDomainRefreshVcpuInfo(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainRefreshVcpuInfo(virDomainObj *vm,
int asyncJob,
bool state);
bool qemuDomainGetVcpuHalted(virDomainObj *vm, unsigned int vcpu);
-int qemuDomainRefreshVcpuHalted(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainRefreshVcpuHalted(virDomainObj *vm,
int asyncJob);
bool qemuDomainSupportsNicdev(virDomainDef *def,
void qemuDomainVcpuPersistOrder(virDomainDef *def)
ATTRIBUTE_NONNULL(1);
-int qemuDomainCheckMonitor(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainCheckMonitor(virDomainObj *vm,
virDomainAsyncJob asyncJob);
bool qemuDomainSupportsVideoVga(const virDomainVideoDef *video,
/**
* qemuDomainObjBeginJobInternal:
- * @driver: qemu driver
* @obj: domain object
* @job: virDomainJob to start
* @asyncJob: virDomainAsyncJob to start
* -1 otherwise.
*/
static int ATTRIBUTE_NONNULL(1)
-qemuDomainObjBeginJobInternal(virQEMUDriver *driver G_GNUC_UNUSED,
- virDomainObj *obj,
+qemuDomainObjBeginJobInternal(virDomainObj *obj,
virDomainJob job,
virDomainAgentJob agentJob,
virDomainAsyncJob asyncJob,
*
* Successful calls must be followed by EndJob eventually
*/
-int qemuDomainObjBeginJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginJob(virDomainObj *obj,
virDomainJob job)
{
- if (qemuDomainObjBeginJobInternal(driver, obj, job,
+ if (qemuDomainObjBeginJobInternal(obj, job,
VIR_AGENT_JOB_NONE,
VIR_ASYNC_JOB_NONE, false) < 0)
return -1;
* To end job call qemuDomainObjEndAgentJob.
*/
int
-qemuDomainObjBeginAgentJob(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjBeginAgentJob(virDomainObj *obj,
virDomainAgentJob agentJob)
{
- return qemuDomainObjBeginJobInternal(driver, obj, VIR_JOB_NONE,
+ return qemuDomainObjBeginJobInternal(obj, VIR_JOB_NONE,
agentJob,
VIR_ASYNC_JOB_NONE, false);
}
-int qemuDomainObjBeginAsyncJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginAsyncJob(virDomainObj *obj,
virDomainAsyncJob asyncJob,
virDomainJobOperation operation,
unsigned long apiFlags)
{
qemuDomainObjPrivate *priv;
- if (qemuDomainObjBeginJobInternal(driver, obj, VIR_JOB_ASYNC,
+ if (qemuDomainObjBeginJobInternal(obj, VIR_JOB_ASYNC,
VIR_AGENT_JOB_NONE,
asyncJob, false) < 0)
return -1;
}
int
-qemuDomainObjBeginNestedJob(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjBeginNestedJob(virDomainObj *obj,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = obj->privateData;
priv->job.asyncOwner);
}
- return qemuDomainObjBeginJobInternal(driver, obj,
+ return qemuDomainObjBeginJobInternal(obj,
VIR_JOB_ASYNC_NESTED,
VIR_AGENT_JOB_NONE,
VIR_ASYNC_JOB_NONE,
/**
* qemuDomainObjBeginJobNowait:
*
- * @driver: qemu driver
* @obj: domain object
* @job: virDomainJob to start
*
* Returns: see qemuDomainObjBeginJobInternal
*/
int
-qemuDomainObjBeginJobNowait(virQEMUDriver *driver,
- virDomainObj *obj,
+qemuDomainObjBeginJobNowait(virDomainObj *obj,
virDomainJob job)
{
- return qemuDomainObjBeginJobInternal(driver, obj, job,
+ return qemuDomainObjBeginJobInternal(obj, job,
VIR_AGENT_JOB_NONE,
VIR_ASYNC_JOB_NONE, true);
}
void qemuDomainEventEmitJobCompleted(virQEMUDriver *driver,
virDomainObj *vm);
-int qemuDomainObjBeginJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginJob(virDomainObj *obj,
virDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginAgentJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginAgentJob(virDomainObj *obj,
virDomainAgentJob agentJob)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginAsyncJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginAsyncJob(virDomainObj *obj,
virDomainAsyncJob asyncJob,
virDomainJobOperation operation,
unsigned long apiFlags)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginNestedJob(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginNestedJob(virDomainObj *obj,
virDomainAsyncJob asyncJob)
G_GNUC_WARN_UNUSED_RESULT;
-int qemuDomainObjBeginJobNowait(virQEMUDriver *driver,
- virDomainObj *obj,
+int qemuDomainObjBeginJobNowait(virDomainObj *obj,
virDomainJob job)
G_GNUC_WARN_UNUSED_RESULT;
virResetLastError();
if (vm->autostart &&
!virDomainObjIsActive(vm)) {
- if (qemuProcessBeginJob(driver, vm,
+ if (qemuProcessBeginJob(vm,
VIR_DOMAIN_JOB_OPERATION_START, flags) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Failed to start job on VM '%s': %s"),
NULL)))
goto cleanup;
- if (qemuProcessBeginJob(driver, vm, VIR_DOMAIN_JOB_OPERATION_START,
+ if (qemuProcessBeginJob(vm, VIR_DOMAIN_JOB_OPERATION_START,
flags) < 0) {
qemuDomainRemoveInactive(driver, vm);
goto cleanup;
priv = vm->privateData;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_SUSPEND) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_SUSPEND) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
if (virDomainResumeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
static int
-qemuDomainShutdownFlagsAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainShutdownFlagsAgent(virDomainObj *vm,
bool isReboot,
bool reportError)
{
int agentFlag = isReboot ? QEMU_AGENT_SHUTDOWN_REBOOT :
QEMU_AGENT_SHUTDOWN_POWERDOWN;
- if (qemuDomainObjBeginAgentJob(driver, vm,
+ if (qemuDomainObjBeginAgentJob(vm,
VIR_AGENT_JOB_MODIFY) < 0)
return -1;
static int
-qemuDomainShutdownFlagsMonitor(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainShutdownFlagsMonitor(virDomainObj *vm,
bool isReboot)
{
int ret = -1;
priv = vm->privateData;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_RUNNING) {
}
qemuDomainSetFakeReboot(vm, isReboot);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSystemPowerdown(priv->mon);
qemuDomainObjExitMonitor(vm);
static int qemuDomainShutdownFlags(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
qemuDomainObjPrivate *priv;
agentForced = agentRequested && !acpiRequested;
if (useAgent) {
- ret = qemuDomainShutdownFlagsAgent(driver, vm, isReboot, agentForced);
+ ret = qemuDomainShutdownFlagsAgent(vm, isReboot, agentForced);
if (ret < 0 && agentForced)
goto cleanup;
}
goto cleanup;
}
- ret = qemuDomainShutdownFlagsMonitor(driver, vm, isReboot);
+ ret = qemuDomainShutdownFlagsMonitor(vm, isReboot);
}
cleanup:
static int
-qemuDomainRebootAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRebootAgent(virDomainObj *vm,
bool isReboot,
bool agentForced)
{
if (!isReboot)
agentFlag = QEMU_AGENT_SHUTDOWN_POWERDOWN;
- if (qemuDomainObjBeginAgentJob(driver, vm,
+ if (qemuDomainObjBeginAgentJob(vm,
VIR_AGENT_JOB_MODIFY) < 0)
return -1;
static int
-qemuDomainRebootMonitor(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRebootMonitor(virDomainObj *vm,
bool isReboot)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
- if (qemuDomainObjBeginJob(driver, vm,
+ if (qemuDomainObjBeginJob(vm,
VIR_JOB_MODIFY) < 0)
return -1;
goto endjob;
qemuDomainSetFakeReboot(vm, isReboot);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSystemPowerdown(priv->mon);
qemuDomainObjExitMonitor(vm);
static int
qemuDomainReboot(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
qemuDomainObjPrivate *priv;
agentForced = agentRequested && !acpiRequested;
if (useAgent)
- ret = qemuDomainRebootAgent(driver, vm, isReboot, agentForced);
+ ret = qemuDomainRebootAgent(vm, isReboot, agentForced);
if (ret < 0 && agentForced)
goto cleanup;
*/
if ((!useAgent) ||
(ret < 0 && (acpiRequested || !flags))) {
- ret = qemuDomainRebootMonitor(driver, vm, isReboot);
+ ret = qemuDomainRebootMonitor(vm, isReboot);
}
cleanup:
static int
qemuDomainReset(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
qemuDomainObjPrivate *priv;
if (virDomainResetEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
priv = vm->privateData;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSystemReset(priv->mon);
qemuDomainObjExitMonitor(vm);
reason == VIR_DOMAIN_PAUSED_STARTING_UP &&
!priv->beingDestroyed);
- if (qemuProcessBeginStopJob(driver, vm, VIR_JOB_DESTROY,
+ if (qemuProcessBeginStopJob(vm, VIR_JOB_DESTROY,
!(flags & VIR_DOMAIN_DESTROY_GRACEFUL)) < 0)
goto cleanup;
if (virDomainSetMemoryFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
if (def) {
priv = vm->privateData;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
r = qemuMonitorSetBalloon(priv->mon, newmem);
qemuDomainObjExitMonitor(vm);
if (r < 0)
if (virDomainSetMemoryStatsPeriodEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
r = qemuMonitorSetMemoryStatsPeriod(priv->mon, def->memballoon, period);
qemuDomainObjExitMonitor(vm);
if (r < 0) {
static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
{
- virQEMUDriver *driver = domain->conn->privateData;
virDomainObj *vm = NULL;
int ret = -1;
qemuDomainObjPrivate *priv;
priv = vm->privateData;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorInjectNMI(priv->mon);
qemuDomainObjExitMonitor(vm);
int nkeycodes,
unsigned int flags)
{
- virQEMUDriver *driver = domain->conn->privateData;
virDomainObj *vm = NULL;
int ret = -1;
qemuDomainObjPrivate *priv;
if (virDomainSendKeyEnsureACL(domain->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSendKey(priv->mon, holdtime, keycodes, nkeycodes);
qemuDomainObjExitMonitor(vm);
virQEMUSaveData *data = NULL;
g_autoptr(qemuDomainSaveCookie) cookie = NULL;
- if (qemuDomainObjBeginAsyncJob(driver, vm, VIR_ASYNC_JOB_SAVE,
+ if (qemuDomainObjBeginAsyncJob(vm, VIR_ASYNC_JOB_SAVE,
VIR_DOMAIN_JOB_OPERATION_SAVE, flags) < 0)
goto cleanup;
g_clear_pointer(&priv->job.current, virDomainJobDataFree);
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
if (dumpformat) {
if (virDomainCoreDumpWithFormatEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAsyncJob(driver, vm,
+ if (qemuDomainObjBeginAsyncJob(vm,
VIR_ASYNC_JOB_DUMP,
VIR_DOMAIN_JOB_OPERATION_DUMP,
flags) < 0)
} else if (((resume && paused) || (flags & VIR_DUMP_RESET)) &&
virDomainObjIsActive(vm)) {
if ((ret == 0) && (flags & VIR_DUMP_RESET)) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSystemReset(priv->mon);
qemuDomainObjExitMonitor(vm);
}
if (virDomainScreenshotEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
qemuSecurityDomainSetPathLabel(driver, vm, tmp, false);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorScreendump(priv->mon, videoAlias, screen, tmp) < 0) {
qemuDomainObjExitMonitor(vm);
goto endjob;
switch (action) {
case VIR_DOMAIN_WATCHDOG_ACTION_DUMP:
- if (qemuDomainObjBeginAsyncJob(driver, vm,
+ if (qemuDomainObjBeginAsyncJob(vm,
VIR_ASYNC_JOB_DUMP,
VIR_DOMAIN_JOB_OPERATION_DUMP,
flags) < 0) {
bool removeInactive = false;
unsigned long flags = VIR_DUMP_MEMORY_ONLY;
- if (qemuDomainObjBeginAsyncJob(driver, vm, VIR_ASYNC_JOB_DUMP,
+ if (qemuDomainObjBeginAsyncJob(vm, VIR_ASYNC_JOB_DUMP,
VIR_DOMAIN_JOB_OPERATION_DUMP, flags) < 0)
return;
VIR_DEBUG("Removing device %s from domain %p %s",
devAlias, vm, vm->def->name);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return;
if (!virDomainObjIsActive(vm)) {
}
if (STRPREFIX(devAlias, "vcpu")) {
- qemuDomainRemoveVcpuAlias(driver, vm, devAlias);
+ qemuDomainRemoveVcpuAlias(vm, devAlias);
} else {
if (virDomainDefFindDevice(vm->def, devAlias, &dev, true) < 0)
goto endjob;
}
static void
-processNicRxFilterChangedEvent(virQEMUDriver *driver,
- virDomainObj *vm,
+processNicRxFilterChangedEvent(virDomainObj *vm,
const char *devAlias)
{
qemuDomainObjPrivate *priv = vm->privateData;
"from domain %p %s",
devAlias, vm, vm->def->name);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
VIR_DEBUG("process NIC_RX_FILTER_CHANGED event for network "
"device %s in domain %s", def->info.alias, vm->def->name);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorQueryRxFilter(priv->mon, devAlias, &guestFilter);
qemuDomainObjExitMonitor(vm);
if (ret < 0)
memset(&dev, 0, sizeof(dev));
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY_MIGRATION_SAFE) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY_MIGRATION_SAFE) < 0)
return;
if (!virDomainObjIsActive(vm)) {
static void
-processBlockJobEvent(virQEMUDriver *driver,
- virDomainObj *vm,
+processBlockJobEvent(virDomainObj *vm,
const char *diskAlias,
int type,
int status)
virDomainDiskDef *disk;
g_autoptr(qemuBlockJobData) job = NULL;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return;
if (!virDomainObjIsActive(vm)) {
static void
-processJobStatusChangeEvent(virQEMUDriver *driver,
- virDomainObj *vm,
+processJobStatusChangeEvent(virDomainObj *vm,
qemuBlockJobData *job)
{
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return;
if (!virDomainObjIsActive(vm)) {
unsigned int stopFlags = 0;
virObjectEvent *event = NULL;
- if (qemuProcessBeginStopJob(driver, vm, VIR_JOB_DESTROY, true) < 0)
+ if (qemuProcessBeginStopJob(vm, VIR_JOB_DESTROY, true) < 0)
return;
if (!virDomainObjIsActive(vm)) {
virObjectEvent *event = NULL;
unsigned long long balloon;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return;
if (!virDomainObjIsActive(vm)) {
processDeviceDeletedEvent(driver, vm, processEvent->data);
break;
case QEMU_PROCESS_EVENT_NIC_RX_FILTER_CHANGED:
- processNicRxFilterChangedEvent(driver, vm, processEvent->data);
+ processNicRxFilterChangedEvent(vm, processEvent->data);
break;
case QEMU_PROCESS_EVENT_SERIAL_CHANGED:
processSerialChangedEvent(driver, vm, processEvent->data,
processEvent->action);
break;
case QEMU_PROCESS_EVENT_BLOCK_JOB:
- processBlockJobEvent(driver, vm,
+ processBlockJobEvent(vm,
processEvent->data,
processEvent->action,
processEvent->status);
break;
case QEMU_PROCESS_EVENT_JOB_STATUS_CHANGE:
- processJobStatusChangeEvent(driver, vm, processEvent->data);
+ processJobStatusChangeEvent(vm, processEvent->data);
break;
case QEMU_PROCESS_EVENT_MONITOR_EOF:
processMonitorEOFEvent(driver, vm);
if (useAgent) {
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
} else {
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
}
if (virDomainPinVcpuFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
if (virDomainPinEmulatorEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
static int
qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
virDomainDef *def;
int ret = -1;
goto cleanup;
if (flags & VIR_DOMAIN_VCPU_GUEST) {
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
static int
-qemuDomainGetIOThreadsMon(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetIOThreadsMon(virDomainObj *vm,
qemuMonitorIOThreadInfo ***iothreads,
int *niothreads)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorGetIOThreads(priv->mon, iothreads, niothreads);
qemuDomainObjExitMonitor(vm);
static int
-qemuDomainGetIOThreadsLive(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetIOThreadsLive(virDomainObj *vm,
virDomainIOThreadInfoPtr **info)
{
qemuDomainObjPrivate *priv;
size_t i;
int ret = -1;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
goto endjob;
}
- if ((ret = qemuDomainGetIOThreadsMon(driver, vm, &iothreads, &niothreads)) < 0)
+ if ((ret = qemuDomainGetIOThreadsMon(vm, &iothreads, &niothreads)) < 0)
goto endjob;
/* Nothing to do */
virDomainIOThreadInfoPtr **info,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
virDomainDef *targetDef = NULL;
int ret = -1;
goto cleanup;
if (!targetDef)
- ret = qemuDomainGetIOThreadsLive(driver, vm, info);
+ ret = qemuDomainGetIOThreadsLive(vm, info);
else
ret = virDomainDriverGetIOThreadsConfig(targetDef, info, 0);
if (virDomainPinIOThreadEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
}
static int
-qemuDomainHotplugAddIOThread(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainHotplugAddIOThread(virDomainObj *vm,
unsigned int iothread_id)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (qemuMonitorCreateObjectProps(&props, "iothread", alias, NULL) < 0)
goto cleanup;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorAddObject(priv->mon, &props, NULL) < 0)
goto exit_monitor;
virDomainIOThreadIDDel(vm->def, iothread_id);
if (objectAdded) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorDelObject(priv->mon, alias, true) < 0)
VIR_WARN("deletion of iothread object %d of domain %s failed when cleanup",
iothread_id, vm->def->name);
static int
-qemuDomainHotplugModIOThread(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainHotplugModIOThread(virDomainObj *vm,
qemuMonitorIOThreadInfo iothread)
{
qemuDomainObjPrivate *priv = vm->privateData;
return -1;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSetIOThread(priv->mon, &iothread);
static int
-qemuDomainHotplugDelIOThread(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainHotplugDelIOThread(virDomainObj *vm,
unsigned int iothread_id)
{
qemuDomainObjPrivate *priv = vm->privateData;
alias = g_strdup_printf("iothread%u", iothread_id);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorDelObject(priv->mon, alias, true);
exp_niothreads--;
priv = vm->privateData;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
if (virDomainDriverAddIOThreadCheck(def, iothread.iothread_id) < 0)
goto endjob;
- if (qemuDomainHotplugAddIOThread(driver, vm, iothread.iothread_id) < 0)
+ if (qemuDomainHotplugAddIOThread(vm, iothread.iothread_id) < 0)
goto endjob;
break;
if (virDomainDriverDelIOThreadCheck(def, iothread.iothread_id) < 0)
goto endjob;
- if (qemuDomainHotplugDelIOThread(driver, vm, iothread.iothread_id) < 0)
+ if (qemuDomainHotplugDelIOThread(vm, iothread.iothread_id) < 0)
goto endjob;
break;
if (qemuDomainIOThreadValidate(iothreaddef, iothread, true) < 0)
goto endjob;
- if (qemuDomainHotplugModIOThread(driver, vm, iothread) < 0)
+ if (qemuDomainHotplugModIOThread(vm, iothread) < 0)
goto endjob;
qemuDomainHotplugModIOThreadIDDef(iothreaddef, iothread);
priv->hookRun = true;
}
- if (qemuProcessBeginJob(driver, vm, VIR_DOMAIN_JOB_OPERATION_RESTORE,
+ if (qemuProcessBeginJob(vm, VIR_DOMAIN_JOB_OPERATION_RESTORE,
flags) < 0)
goto cleanup;
if (virDomainCreateWithFlagsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuProcessBeginJob(driver, vm, VIR_DOMAIN_JOB_OPERATION_START,
+ if (qemuProcessBeginJob(vm, VIR_DOMAIN_JOB_OPERATION_START,
flags) < 0)
goto cleanup;
if (virDomainUndefineFlagsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (!vm->persistent) {
break;
case VIR_DOMAIN_DEVICE_CONTROLLER:
- ret = qemuDomainAttachControllerDevice(driver, vm, dev->data.controller);
+ ret = qemuDomainAttachControllerDevice(vm, dev->data.controller);
if (!ret) {
alias = dev->data.controller->info.alias;
dev->data.controller = NULL;
break;
case VIR_DOMAIN_DEVICE_SHMEM:
- ret = qemuDomainAttachShmemDevice(driver, vm,
+ ret = qemuDomainAttachShmemDevice(vm,
dev->data.shmem);
if (!ret) {
alias = dev->data.shmem->info.alias;
break;
case VIR_DOMAIN_DEVICE_WATCHDOG:
- ret = qemuDomainAttachWatchdog(driver, vm,
+ ret = qemuDomainAttachWatchdog(vm,
dev->data.watchdog);
if (!ret) {
alias = dev->data.watchdog->info.alias;
break;
case VIR_DOMAIN_DEVICE_INPUT:
- ret = qemuDomainAttachInputDevice(driver, vm, dev->data.input);
+ ret = qemuDomainAttachInputDevice(vm, dev->data.input);
if (ret == 0) {
alias = dev->data.input->info.alias;
dev->data.input = NULL;
break;
case VIR_DOMAIN_DEVICE_VSOCK:
- ret = qemuDomainAttachVsockDevice(driver, vm, dev->data.vsock);
+ ret = qemuDomainAttachVsockDevice(vm, dev->data.vsock);
if (ret == 0) {
alias = dev->data.vsock->info.alias;
dev->data.vsock = NULL;
}
if (ret == 0)
- ret = qemuDomainUpdateDeviceList(driver, vm, VIR_ASYNC_JOB_NONE);
+ ret = qemuDomainUpdateDeviceList(vm, VIR_ASYNC_JOB_NONE);
return ret;
}
if (!qemuDomainChangeMemoryLiveValidateChange(oldDef, newDef))
return -1;
- if (qemuDomainChangeMemoryRequestedSize(driver, vm,
+ if (qemuDomainChangeMemoryRequestedSize(vm,
newDef->info.alias,
newDef->requestedsize) < 0)
return -1;
if (virDomainAttachDeviceFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjUpdateModificationImpact(vm, &flags) < 0)
if (virDomainUpdateDeviceFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjUpdateModificationImpact(vm, &flags) < 0)
if ((rc = qemuDomainDetachDeviceLive(vm, dev, driver, false)) < 0)
goto cleanup;
- if (rc == 0 && qemuDomainUpdateDeviceList(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (rc == 0 && qemuDomainUpdateDeviceList(vm, VIR_ASYNC_JOB_NONE) < 0)
goto cleanup;
qemuDomainSaveStatus(vm);
if ((rc = qemuDomainDetachDeviceLive(vm, &dev, driver, true)) < 0)
return -1;
- if (rc == 0 && qemuDomainUpdateDeviceList(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (rc == 0 && qemuDomainUpdateDeviceList(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
}
if (virDomainDetachDeviceFlagsEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjUpdateModificationImpact(vm, &flags) < 0)
if (virDomainDetachDeviceAliasEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjUpdateModificationImpact(vm, &flags) < 0)
autostart = (autostart != 0);
if (vm->autostart != autostart) {
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (!(configFile = virDomainConfigFile(cfg->configDir, vm->def->name)))
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
/* QEMU and LXC implementation are identical */
}
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
if (virDomainSetPerfEventsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuDomainObjPrivate *priv;
virDomainDef *def;
if (virDomainGetPerfEventsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (!(def = virDomainObjGetOneDefState(vm, flags, &live)))
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
unsigned long long size,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuDomainObjPrivate *priv;
int ret = -1;
if (virDomainBlockResizeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorBlockResize(priv->mon, device, nodename, size) < 0) {
qemuDomainObjExitMonitor(vm);
goto endjob;
* Returns -1 on error; number of filled block statistics on success.
*/
static int
-qemuDomainBlocksStatsGather(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainBlocksStatsGather(virDomainObj *vm,
const char *path,
bool capacity,
qemuBlockStats **retstats)
}
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
nstats = qemuMonitorGetAllBlockStatsInfo(priv->mon, &blockstats);
if (capacity && nstats >= 0) {
const char *path,
virDomainBlockStatsPtr stats)
{
- virQEMUDriver *driver = dom->conn->privateData;
qemuBlockStats *blockstats = NULL;
int ret = -1;
virDomainObj *vm;
if (virDomainBlockStatsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- if (qemuDomainBlocksStatsGather(driver, vm, path, false, &blockstats) < 0)
+ if (qemuDomainBlocksStatsGather(vm, path, false, &blockstats) < 0)
goto endjob;
if (VIR_ASSIGN_IS_OVERFLOW(stats->rd_req, blockstats->rd_req) ||
int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuBlockStats *blockstats = NULL;
int nstats;
if (virDomainBlockStatsFlagsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- if ((nstats = qemuDomainBlocksStatsGather(driver, vm, path, false,
+ if ((nstats = qemuDomainBlocksStatsGather(vm, path, false,
&blockstats)) < 0)
goto endjob;
if (virDomainSetInterfaceParametersEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
/* This functions assumes that job VIR_JOB_QUERY is started by a caller */
static int
-qemuDomainMemoryStatsInternal(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainMemoryStatsInternal(virDomainObj *vm,
virDomainMemoryStatPtr stats,
unsigned int nr_stats)
return -1;
if (virDomainDefHasMemballoon(vm->def)) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorGetMemoryStats(qemuDomainGetMonitor(vm),
vm->def->memballoon, stats, nr_stats);
qemuDomainObjExitMonitor(vm);
unsigned int nr_stats,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
if (virDomainMemoryStatsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
- ret = qemuDomainMemoryStatsInternal(driver, vm, stats, nr_stats);
+ ret = qemuDomainMemoryStatsInternal(vm, stats, nr_stats);
qemuDomainObjEndJob(vm);
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
qemuSecurityDomainSetPathLabel(driver, vm, tmp, false);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (flags == VIR_MEMORY_VIRTUAL) {
if (qemuMonitorSaveVirtualMemory(priv->mon, offset, size, tmp) < 0) {
qemuDomainObjExitMonitor(vm);
if (virDomainGetBlockInfoEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (!(disk = virDomainDiskByName(vm->def, path, false))) {
goto endjob;
}
- if (qemuDomainBlocksStatsGather(driver, vm, path, true, &entry) < 0)
+ if (qemuDomainBlocksStatsGather(vm, path, true, &entry) < 0)
goto endjob;
if (!entry->wr_highest_offset_valid) {
static int
-qemuDomainGetJobInfoMigrationStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetJobInfoMigrationStats(virDomainObj *vm,
virDomainJobData *jobData)
{
qemuDomainJobDataPrivate *privStats = jobData->privateData;
switch (jobData->status) {
case VIR_DOMAIN_JOB_STATUS_ACTIVE:
if (privStats->statsType == QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION &&
- qemuMigrationSrcFetchMirrorStats(driver, vm, VIR_ASYNC_JOB_NONE,
+ qemuMigrationSrcFetchMirrorStats(vm, VIR_ASYNC_JOB_NONE,
jobData) < 0)
return -1;
break;
case VIR_DOMAIN_JOB_STATUS_POSTCOPY:
case VIR_DOMAIN_JOB_STATUS_PAUSED:
case VIR_DOMAIN_JOB_STATUS_POSTCOPY_PAUSED:
- if (qemuMigrationAnyFetchStats(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationAnyFetchStats(vm, VIR_ASYNC_JOB_NONE,
jobData, NULL) < 0)
return -1;
break;
static int
-qemuDomainGetJobInfoDumpStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetJobInfoDumpStats(virDomainObj *vm,
virDomainJobData *jobData)
{
qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorDumpStats stats = { 0 };
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
rc = qemuMonitorQueryDump(priv->mon, &stats);
static int
-qemuDomainGetJobStatsInternal(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetJobStatsInternal(virDomainObj *vm,
bool completed,
virDomainJobData **jobData)
{
return -1;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
switch (privStats->statsType) {
case QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION:
case QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP:
- if (qemuDomainGetJobInfoMigrationStats(driver, vm, *jobData) < 0)
+ if (qemuDomainGetJobInfoMigrationStats(vm, *jobData) < 0)
goto cleanup;
break;
case QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP:
- if (qemuDomainGetJobInfoDumpStats(driver, vm, *jobData) < 0)
+ if (qemuDomainGetJobInfoDumpStats(vm, *jobData) < 0)
goto cleanup;
break;
case QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP:
- if (qemuBackupGetJobInfoStats(driver, vm, *jobData) < 0)
+ if (qemuBackupGetJobInfoStats(vm, *jobData) < 0)
goto cleanup;
break;
qemuDomainGetJobInfo(virDomainPtr dom,
virDomainJobInfoPtr info)
{
- virQEMUDriver *driver = dom->conn->privateData;
g_autoptr(virDomainJobData) jobData = NULL;
virDomainObj *vm;
int ret = -1;
if (virDomainGetJobInfoEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainGetJobStatsInternal(driver, vm, false, &jobData) < 0)
+ if (qemuDomainGetJobStatsInternal(vm, false, &jobData) < 0)
goto cleanup;
if (!jobData ||
int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuDomainObjPrivate *priv;
g_autoptr(virDomainJobData) jobData = NULL;
goto cleanup;
priv = vm->privateData;
- if (qemuDomainGetJobStatsInternal(driver, vm, completed, &jobData) < 0)
+ if (qemuDomainGetJobStatsInternal(vm, completed, &jobData) < 0)
goto cleanup;
if (!jobData ||
VIR_DEBUG("Cancelling migration job at client request");
qemuDomainObjAbortAsyncJob(vm);
- qemuDomainObjEnterMonitor(priv->driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorMigrateCancel(priv->mon);
qemuDomainObjExitMonitor(vm);
VIR_DEBUG("Suspending post-copy migration at client request");
qemuDomainObjAbortAsyncJob(vm);
- qemuDomainObjEnterMonitor(priv->driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorMigratePause(priv->mon);
qemuDomainObjExitMonitor(vm);
qemuDomainAbortJobFlags(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
qemuDomainObjPrivate *priv;
if (virDomainAbortJobFlagsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_ABORT) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_ABORT) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
unsigned long long downtime,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
if (virDomainMigrateSetMaxDowntimeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MIGRATION_OP) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MIGRATION_OP) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
downtime) < 0)
goto endjob;
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_NONE,
migParams, 0) < 0)
goto endjob;
unsigned long long *downtime,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
if (virDomainMigrateGetMaxDowntimeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
- if (qemuMigrationParamsFetch(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsFetch(vm, VIR_ASYNC_JOB_NONE,
&migParams) < 0)
goto endjob;
unsigned long long *cacheSize,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
if (virDomainMigrateGetCompressionCacheEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- if (qemuMigrationParamsFetch(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsFetch(vm, VIR_ASYNC_JOB_NONE,
&migParams) < 0)
goto endjob;
unsigned long long cacheSize,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
g_autoptr(qemuMigrationParams) migParams = NULL;
int ret = -1;
if (virDomainMigrateSetCompressionCacheEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MIGRATION_OP) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MIGRATION_OP) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
cacheSize) < 0)
goto endjob;
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_NONE,
migParams, 0) < 0)
goto endjob;
unsigned long bandwidth,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuDomainObjPrivate *priv;
bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MIGRATION_OP) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MIGRATION_OP) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
bandwidth * 1024 * 1024) < 0)
goto endjob;
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_NONE,
migParams, 0) < 0)
goto endjob;
static int
-qemuDomainMigrationGetPostcopyBandwidth(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainMigrationGetPostcopyBandwidth(virDomainObj *vm,
unsigned long *bandwidth)
{
g_autoptr(qemuMigrationParams) migParams = NULL;
int rc;
int ret = -1;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
goto cleanup;
- if (qemuMigrationParamsFetch(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuMigrationParamsFetch(vm, VIR_ASYNC_JOB_NONE,
&migParams) < 0)
goto cleanup;
unsigned long *bandwidth,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuDomainObjPrivate *priv;
bool postcopy = !!(flags & VIR_DOMAIN_MIGRATE_MAX_SPEED_POSTCOPY);
goto cleanup;
if (postcopy) {
- if (qemuDomainMigrationGetPostcopyBandwidth(driver, vm, bandwidth) < 0)
+ if (qemuDomainMigrationGetPostcopyBandwidth(vm, bandwidth) < 0)
goto cleanup;
} else {
*bandwidth = priv->migMaxBandwidth;
qemuDomainMigrateStartPostCopy(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuDomainObjPrivate *priv;
int ret = -1;
if (virDomainMigrateStartPostCopyEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MIGRATION_OP) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MIGRATION_OP) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
}
VIR_DEBUG("Starting post-copy");
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorMigrateStartPostCopy(priv->mon);
qemuDomainObjExitMonitor(vm);
if (virDomainQemuMonitorCommandWithFilesEnsureACL(domain->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
hmp = !!(flags & VIR_DOMAIN_QEMU_MONITOR_COMMAND_HMP);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorArbitraryCommand(priv->mon, cmd, fd, result, hmp);
qemuDomainObjExitMonitor(vm);
* abort with pivot; this updates the VM definition as appropriate, on
* either success or failure. */
static int
-qemuDomainBlockPivot(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainBlockPivot(virDomainObj *vm,
qemuBlockJobData *job,
virDomainDiskDef *disk)
{
break;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (blockdev) {
int rc = 0;
unsigned int flags)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
const char *device = NULL;
const char *jobname = NULL;
virDomainDiskDef *disk;
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
device = job->name;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (!blockdev && baseSource)
basePath = qemuMonitorDiskNameLookup(priv->mon, device, disk->src,
baseSource);
const char *path,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainDiskDef *disk = NULL;
bool pivot = !!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_PIVOT);
bool async = !!(flags & VIR_DOMAIN_BLOCK_JOB_ABORT_ASYNC);
if (virDomainBlockJobAbortEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
qemuBlockJobSyncBegin(job);
if (pivot) {
- if ((ret = qemuDomainBlockPivot(driver, vm, job, disk)) < 0)
+ if ((ret = qemuDomainBlockPivot(vm, job, disk)) < 0)
goto endjob;
} else {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorBlockJobCancel(priv->mon, job->name, false);
qemuDomainObjExitMonitor(vm);
virDomainBlockJobInfoPtr info,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
virDomainDiskDef *disk;
int ret = -1;
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
blockjobstats = qemuMonitorGetAllBlockJobInfo(qemuDomainGetMonitor(vm), true);
qemuDomainObjExitMonitor(vm);
unsigned long bandwidth,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainDiskDef *disk;
int ret = -1;
virDomainObj *vm;
if (virDomainBlockJobSetSpeedEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorBlockJobSetSpeed(qemuDomainGetMonitor(vm),
job->name,
speed);
return -1;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
}
if (data) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuBlockStorageSourceChainAttach(priv->mon, data);
qemuDomainObjExitMonitor(vm);
disk->mirrorState = VIR_DOMAIN_DISK_MIRROR_STATE_NONE;
/* Actually start the mirroring */
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (blockdev) {
ret = qemuMonitorBlockdevMirror(priv->mon, job->name, true,
if (ret < 0 &&
virDomainObjIsActive(vm)) {
if (data || crdata) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (data)
qemuBlockStorageSourceChainDetach(priv->mon, data);
if (crdata)
if (virDomainBlockCommitEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
device = job->name;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (!blockdev) {
basePath = qemuMonitorDiskNameLookup(priv->mon, device, disk->src,
if (virDomainOpenGraphicsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
if (qemuSecuritySetImageFDLabel(driver->securityManager, vm->def, fd) < 0)
goto endjob;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorOpenGraphics(priv->mon, protocol, fd, "graphicsfd",
(flags & VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH) != 0);
qemuDomainObjExitMonitor(vm);
if (qemuSecurityClearSocketLabel(driver->securityManager, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorOpenGraphics(priv->mon, protocol, pair[1], "graphicsfd",
(flags & VIR_DOMAIN_OPEN_GRAPHICS_SKIPAUTH));
qemuDomainObjExitMonitor(vm);
cfg = virQEMUDriverGetConfig(driver);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
priv = vm->privateData;
!virStorageSourceIsEmpty(disk->src)) {
int rc = 0;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSetBlockIoThrottle(priv->mon, drivealias, qdevid, &info);
qemuDomainObjExitMonitor(vm);
unsigned int flags)
{
virDomainDiskDef *disk;
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuDomainObjPrivate *priv = NULL;
virDomainDef *def = NULL;
if (virDomainGetBlockIoTuneEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
/* the API check guarantees that only one of the definitions will be set */
if (!(drivealias = qemuAliasDiskDriveFromDisk(disk)))
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorGetBlockIoThrottle(priv->mon, drivealias, qdevid, &reply);
qemuDomainObjExitMonitor(vm);
unsigned int nerrors,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuDomainObjPrivate *priv;
g_autoptr(GHashTable) table = NULL;
if (virDomainGetDiskErrorsEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
table = qemuMonitorGetBlockInfo(priv->mon);
qemuDomainObjExitMonitor(vm);
if (!table)
if (virDomainSetMetadataEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
ret = virDomainObjSetMetadata(vm, type, metadata, key, uri,
static int
-qemuDomainProbeQMPCurrentMachine(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainProbeQMPCurrentMachine(virDomainObj *vm,
bool *wakeupSupported)
{
qemuDomainObjPrivate *priv = vm->privateData;
qemuMonitorCurrentMachineInfo info = { 0 };
int rv;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rv = qemuMonitorGetCurrentMachineInfo(priv->mon, &info);
qemuDomainObjExitMonitor(vm);
if (rv < 0)
/* returns -1 on error, or if query is not supported, 0 if query was successful */
static int
-qemuDomainQueryWakeupSuspendSupport(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainQueryWakeupSuspendSupport(virDomainObj *vm,
bool *wakeupSupported)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_CURRENT_MACHINE))
return -1;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if ((ret = virDomainObjCheckActive(vm)) < 0)
goto endjob;
- ret = qemuDomainProbeQMPCurrentMachine(driver, vm, wakeupSupported);
+ ret = qemuDomainProbeQMPCurrentMachine(vm, wakeupSupported);
endjob:
qemuDomainObjEndJob(vm);
static int
-qemuDomainPMSuspendAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainPMSuspendAgent(virDomainObj *vm,
unsigned int target)
{
qemuAgent *agent;
int ret = -1;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
unsigned long long duration,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
bool wakeupSupported;
* that don't know about this cap, will keep their old behavior of
* suspending 'in the dark'.
*/
- if (qemuDomainQueryWakeupSuspendSupport(driver, vm, &wakeupSupported) == 0) {
+ if (qemuDomainQueryWakeupSuspendSupport(vm, &wakeupSupported) == 0) {
if (!wakeupSupported) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("Domain does not have suspend support"));
}
}
- ret = qemuDomainPMSuspendAgent(driver, vm, target);
+ ret = qemuDomainPMSuspendAgent(vm, target);
cleanup:
virDomainObjEndAPI(&vm);
qemuDomainPMWakeup(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
qemuDomainObjPrivate *priv;
if (virDomainPMWakeupEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
priv = vm->privateData;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSystemWakeup(priv->mon);
qemuDomainObjExitMonitor(vm);
if (virDomainQemuAgentCommandEnsureACL(domain->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
unsigned long long minimum,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuAgent *agent;
int ret = -1;
if (virDomainFSTrimEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
static int
-qemuDomainGetHostnameAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetHostnameAgent(virDomainObj *vm,
char **hostname)
{
qemuAgent *agent;
int ret = -1;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
static int
-qemuDomainGetHostnameLease(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetHostnameLease(virDomainObj *vm,
char **hostname)
{
char macaddr[VIR_MAC_STRING_BUFLEN];
size_t i, j;
int ret = -1;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
qemuDomainGetHostname(virDomainPtr dom,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
char *hostname = NULL;
goto cleanup;
if (flags & VIR_DOMAIN_GET_HOSTNAME_AGENT) {
- if (qemuDomainGetHostnameAgent(driver, vm, &hostname) < 0)
+ if (qemuDomainGetHostnameAgent(vm, &hostname) < 0)
goto cleanup;
} else if (flags & VIR_DOMAIN_GET_HOSTNAME_LEASE) {
- if (qemuDomainGetHostnameLease(driver, vm, &hostname) < 0)
+ if (qemuDomainGetHostnameLease(vm, &hostname) < 0)
goto cleanup;
}
unsigned int *nseconds,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
int ret = -1;
if (virDomainGetTimeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
static int
-qemuDomainSetTimeAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainSetTimeAgent(virDomainObj *vm,
long long seconds,
unsigned int nseconds,
bool rtcSync)
qemuAgent *agent;
int ret = -1;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0)
unsigned int nseconds,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
qemuDomainObjPrivate *priv;
virDomainObj *vm;
bool rtcSync = flags & VIR_DOMAIN_TIME_SYNC;
goto cleanup;
}
- if (qemuDomainSetTimeAgent(driver, vm, seconds, nseconds, rtcSync) < 0)
+ if (qemuDomainSetTimeAgent(vm, seconds, nseconds, rtcSync) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
/* Don't try to call rtc-reset-reinjection if it's not available */
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_RTC_RESET_REINJECTION)) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rv = qemuMonitorRTCResetReinjection(priv->mon);
qemuDomainObjExitMonitor(vm);
unsigned int nmountpoints,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
if (virDomainFSFreezeEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
unsigned int nmountpoints,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
int ret = -1;
if (virDomainFSThawEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
static int
-qemuDomainGetStatsBalloon(virQEMUDriver *driver,
+qemuDomainGetStatsBalloon(virQEMUDriver *driver G_GNUC_UNUSED,
virDomainObj *dom,
virTypedParamList *params,
unsigned int privflags)
if (!HAVE_JOB(privflags) || !virDomainObjIsActive(dom))
return 0;
- nr_stats = qemuDomainMemoryStatsInternal(driver, dom, stats,
+ nr_stats = qemuDomainMemoryStatsInternal(dom, stats,
VIR_DOMAIN_MEMORY_STAT_NR);
if (nr_stats < 0)
return 0;
static int
-qemuDomainGetStatsVcpu(virQEMUDriver *driver,
+qemuDomainGetStatsVcpu(virQEMUDriver *driver G_GNUC_UNUSED,
virDomainObj *dom,
virTypedParamList *params,
unsigned int privflags)
cpudelay = g_new0(unsigned long long, virDomainDefGetVcpus(dom->def));
if (HAVE_JOB(privflags) && virDomainObjIsActive(dom) &&
- qemuDomainRefreshVcpuHalted(driver, dom, VIR_ASYNC_JOB_NONE) < 0) {
+ qemuDomainRefreshVcpuHalted(dom, VIR_ASYNC_JOB_NONE) < 0) {
/* it's ok to be silent and go ahead, because halted vcpu info
* wasn't here from the beginning */
virResetLastError();
bool visitBacking = !!(privflags & QEMU_DOMAIN_STATS_BACKING);
if (HAVE_JOB(privflags) && virDomainObjIsActive(dom)) {
- qemuDomainObjEnterMonitor(driver, dom);
+ qemuDomainObjEnterMonitor(dom);
rc = qemuMonitorGetAllBlockStatsInfo(priv->mon, &stats);
static int
-qemuDomainGetStatsIOThread(virQEMUDriver *driver,
+qemuDomainGetStatsIOThread(virQEMUDriver *driver G_GNUC_UNUSED,
virDomainObj *dom,
virTypedParamList *params,
unsigned int privflags)
if (!HAVE_JOB(privflags) || !virDomainObjIsActive(dom))
return 0;
- if (qemuDomainGetIOThreadsMon(driver, dom, &iothreads, &niothreads) < 0)
+ if (qemuDomainGetIOThreadsMon(dom, &iothreads, &niothreads) < 0)
return -1;
/* qemuDomainGetIOThreadsMon returns a NULL-terminated list, so we must free
}
static int
-qemuDomainGetStatsDirtyRateMon(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetStatsDirtyRateMon(virDomainObj *vm,
qemuMonitorDirtyRateInfo *info)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorQueryDirtyRate(priv->mon, info);
qemuDomainObjExitMonitor(vm);
}
static int
-qemuDomainGetStatsDirtyRate(virQEMUDriver *driver,
+qemuDomainGetStatsDirtyRate(virQEMUDriver *driver G_GNUC_UNUSED,
virDomainObj *dom,
virTypedParamList *params,
unsigned int privflags)
if (!HAVE_JOB(privflags) || !virDomainObjIsActive(dom))
return 0;
- if (qemuDomainGetStatsDirtyRateMon(driver, dom, &info) < 0)
+ if (qemuDomainGetStatsDirtyRateMon(dom, &info) < 0)
return -1;
if (virTypedParamListAddInt(params, info.status,
int rv;
if (flags & VIR_CONNECT_GET_ALL_DOMAINS_STATS_NOWAIT)
- rv = qemuDomainObjBeginJobNowait(driver, vm, VIR_JOB_QUERY);
+ rv = qemuDomainObjBeginJobNowait(vm, VIR_JOB_QUERY);
else
- rv = qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY);
+ rv = qemuDomainObjBeginJob(vm, VIR_JOB_QUERY);
if (rv == 0)
domflags |= QEMU_DOMAIN_STATS_HAVE_JOB;
}
static int
-qemuDomainGetFSInfoAgent(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetFSInfoAgent(virDomainObj *vm,
qemuAgentFSInfo ***info)
{
int ret = -1;
qemuAgent *agent;
- if (qemuDomainObjBeginAgentJob(driver, vm,
+ if (qemuDomainObjBeginAgentJob(vm,
VIR_AGENT_JOB_QUERY) < 0)
return ret;
virDomainFSInfoPtr **info,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuAgentFSInfo **agentinfo = NULL;
int ret = -1;
if (virDomainGetFSInfoEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if ((nfs = qemuDomainGetFSInfoAgent(driver, vm, &agentinfo)) < 0)
+ if ((nfs = qemuDomainGetFSInfoAgent(vm, &agentinfo)) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
unsigned int source,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
int ret = -1;
break;
case VIR_DOMAIN_INTERFACE_ADDRESSES_SRC_AGENT:
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
const char *password,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm;
qemuAgent *agent;
int ret = -1;
if (virDomainSetUserPasswordEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
if (virDomainRenameEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjIsActive(vm)) {
unsigned int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
qemuAgentCPUInfo *info = NULL;
if (virDomainGetGuestVcpusEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
int state,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
g_autoptr(virBitmap) map = NULL;
qemuAgentCPUInfo *info = NULL;
if (virDomainSetGuestVcpusEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
if (virDomainSetVcpuEnsureACL(dom->conn, vm->def, flags) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
unsigned long long threshold,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
qemuDomainObjPrivate *priv;
virDomainObj *vm = NULL;
virStorageSource *src;
if (virDomainSetBlockThresholdEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
!src->nodestorage &&
- qemuBlockNodeNamesDetect(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ qemuBlockNodeNamesDetect(vm, VIR_ASYNC_JOB_NONE) < 0)
goto endjob;
if (!src->nodestorage) {
nodename = g_strdup(src->nodestorage);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSetBlockThreshold(priv->mon, nodename, threshold);
qemuDomainObjExitMonitor(vm);
if (rc < 0)
{
qemuMonitorActionReboot monReboot = QEMU_MONITOR_ACTION_REBOOT_KEEP;
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
int rc;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_SET_ACTION))
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSetAction(priv->mon,
QEMU_MONITOR_ACTION_SHUTDOWN_KEEP,
if (virDomainSetLifecycleActionEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjGetDefs(vm, flags, &def, &persistentDef) < 0)
static int
-qemuDomainGetSEVInfo(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetSEVInfo(virDomainObj *vm,
virTypedParameterPtr *params,
int *nparams,
unsigned int flags)
virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
return -1;
if (virDomainObjCheckActive(vm) < 0) {
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
tmp = qemuMonitorGetSEVMeasurement(QEMU_DOMAIN_PRIVATE(vm)->mon);
int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = domain->conn->privateData;
virDomainObj *vm;
int ret = -1;
if (vm->def->sec &&
vm->def->sec->sectype == VIR_DOMAIN_LAUNCH_SECURITY_SEV) {
- if (qemuDomainGetSEVInfo(driver, vm, params, nparams, flags) < 0)
+ if (qemuDomainGetSEVInfo(vm, params, nparams, flags) < 0)
goto cleanup;
}
int nparams,
unsigned int flags)
{
- virQEMUDriver *driver = domain->conn->privateData;
virDomainObj *vm;
int ret = -1;
int rc;
else if (rc == 1)
hasSetaddr = true;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSetLaunchSecurityState(QEMU_DOMAIN_PRIVATE(vm)->mon,
secrethdr, secret, setaddr, hasSetaddr);
qemuDomainObjExitMonitor(vm);
int *nparams,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
int ret = -1;
if (virDomainGetGuestInfoEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm,
+ if (qemuDomainObjBeginAgentJob(vm,
VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
qemuDomainObjEndAgentJob(vm);
if (nfs > 0 || ndisks > 0) {
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_QUERY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0)
char ***keys,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
int rv = -1;
if (virDomainAuthorizedSshKeysGetEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
unsigned int nkeys,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuAgent *agent;
const bool append = flags & VIR_DOMAIN_AUTHORIZED_SSH_KEYS_SET_APPEND;
if (virDomainAuthorizedSshKeysSetEnsureACL(dom->conn, vm->def) < 0)
goto cleanup;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_QUERY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_QUERY) < 0)
goto cleanup;
if (!qemuDomainAgentAvailable(vm, true))
int seconds,
unsigned int flags)
{
- virQEMUDriver *driver = dom->conn->privateData;
virDomainObj *vm = NULL;
qemuDomainObjPrivate *priv;
qemuMonitorDirtyRateCalcMode mode = QEMU_MONITOR_DIRTYRATE_CALC_MODE_PAGE_SAMPLING;
goto cleanup;
}
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0) {
VIR_DEBUG("Calculate dirty rate in next %d seconds", seconds);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorStartDirtyRateCalc(priv->mon, seconds, mode);
qemuDomainObjExitMonitor(vm);
const char *alias)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
int rc;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorDelDevice(priv->mon, alias);
* Returns 0 on success, -1 on error and reports libvirt error
*/
static int
-qemuDomainChangeMediaLegacy(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainChangeMediaLegacy(virDomainObj *vm,
virDomainDiskDef *disk,
virStorageSource *newsrc,
bool force)
if (!(driveAlias = qemuAliasDiskDriveFromDisk(disk)))
return -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorEjectMedia(priv->mon, driveAlias, force);
qemuDomainObjExitMonitor(vm);
return -1;
/* re-issue ejection command to pop out the media */
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorEjectMedia(priv->mon, driveAlias, false);
qemuDomainObjExitMonitor(vm);
if (rc < 0)
if (virStorageSourceGetActualType(newsrc) != VIR_STORAGE_TYPE_DIR)
format = virStorageFileFormatTypeToString(newsrc->format);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorChangeMedia(priv->mon,
driveAlias,
sourcestr,
if (!(props = qemuBuildDBusVMStateInfoProps(driver, vm)))
return -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorAddObject(priv->mon, &props, NULL);
* Returns: 0 on success, -1 on error.
*/
int
-qemuHotplugRemoveDBusVMState(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuHotplugRemoveDBusVMState(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (!priv->dbusVMState)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorDelObject(priv->mon, qemuDomainGetDBusVMStateAlias(), true);
* Returns: 0 on success, -1 on error.
*/
static int
-qemuHotplugAttachManagedPR(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuHotplugAttachManagedPR(virDomainObj *vm,
virStorageSource *src,
virDomainAsyncJob asyncJob)
{
daemonStarted = true;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuMonitorAddObject(priv->mon, &props, NULL);
* it any more.
*/
static int
-qemuHotplugRemoveManagedPR(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuHotplugRemoveManagedPR(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
virErrorPreserveLast(&orig_err);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
ignore_value(qemuMonitorDelObject(priv->mon, qemuDomainGetManagedPRAlias(),
false));
* Returns 0 on success, -1 on error and reports libvirt error
*/
static int
-qemuDomainChangeMediaBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainChangeMediaBlockdev(virDomainObj *vm,
virDomainDiskDef *disk,
virStorageSource *oldsrc,
virStorageSource *newsrc,
}
if (diskPriv->tray && disk->tray_status != VIR_DOMAIN_DISK_TRAY_OPEN) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorBlockdevTrayOpen(priv->mon, diskPriv->qomName, force);
qemuDomainObjExitMonitor(vm);
if (rc < 0)
return -1;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorBlockdevMediumRemove(priv->mon, diskPriv->qomName);
if (qemuDomainStorageSourceChainAccessAllow(driver, vm, newsrc) < 0)
goto cleanup;
- if (qemuHotplugAttachManagedPR(driver, vm, newsrc, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuHotplugAttachManagedPR(vm, newsrc, VIR_ASYNC_JOB_NONE) < 0)
goto cleanup;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV))
- rc = qemuDomainChangeMediaBlockdev(driver, vm, disk, oldsrc, newsrc, force);
+ rc = qemuDomainChangeMediaBlockdev(vm, disk, oldsrc, newsrc, force);
else
- rc = qemuDomainChangeMediaLegacy(driver, vm, disk, newsrc, force);
+ rc = qemuDomainChangeMediaLegacy(vm, disk, newsrc, force);
virDomainAuditDisk(vm, oldsrc, newsrc, "update", rc >= 0);
/* remove PR manager object if unneeded */
if (managedpr)
- ignore_value(qemuHotplugRemoveManagedPR(driver, vm, VIR_ASYNC_JOB_NONE));
+ ignore_value(qemuHotplugRemoveManagedPR(vm, VIR_ASYNC_JOB_NONE));
/* revert old image do the disk definition */
if (oldsrc)
* Attaches disk to a VM. This function aggregates common code for all bus types.
* In cases when the VM crashed while adding the disk, -2 is returned. */
int
-qemuDomainAttachDiskGeneric(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAttachDiskGeneric(virDomainObj *vm,
virDomainDiskDef *disk,
virDomainAsyncJob asyncJob)
{
disk->src->readonly = origReadonly;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuBlockStorageSourceChainAttach(priv->mon, data);
if (!(devprops = qemuBuildDiskDeviceProps(vm->def, disk, priv->qemuCaps)))
goto rollback;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto rollback;
if ((rc = qemuDomainAttachExtensionDevice(priv->mon, &disk->info)) == 0)
return 0;
rollback:
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
if (extensionDeviceAttached)
}
-int qemuDomainAttachControllerDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachControllerDevice(virDomainObj *vm,
virDomainControllerDef *controller)
{
int ret = -1;
VIR_REALLOC_N(vm->def->controllers, vm->def->ncontrollers+1);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if ((ret = qemuDomainAttachExtensionDevice(priv->mon,
&controller->info)) < 0) {
}
static virDomainControllerDef *
-qemuDomainFindOrCreateSCSIDiskController(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainFindOrCreateSCSIDiskController(virDomainObj *vm,
int controller)
{
size_t i;
VIR_INFO("No SCSI controller present, hotplugging one model=%s",
virDomainControllerModelSCSITypeToString(cont->model));
- if (qemuDomainAttachControllerDevice(driver, vm, cont) < 0) {
+ if (qemuDomainAttachControllerDevice(vm, cont) < 0) {
VIR_FREE(cont);
return NULL;
}
* exist; there must not be any missing index in between.
*/
for (i = 0; i <= disk->info.addr.drive.controller; i++) {
- if (!qemuDomainFindOrCreateSCSIDiskController(driver, vm, i))
+ if (!qemuDomainFindOrCreateSCSIDiskController(vm, i))
goto cleanup;
}
break;
if (qemuDomainPrepareDiskSource(disk, priv, cfg) < 0)
goto cleanup;
- if (qemuHotplugAttachManagedPR(driver, vm, disk->src, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuHotplugAttachManagedPR(vm, disk->src, VIR_ASYNC_JOB_NONE) < 0)
goto cleanup;
- ret = qemuDomainAttachDiskGeneric(driver, vm, disk, VIR_ASYNC_JOB_NONE);
+ ret = qemuDomainAttachDiskGeneric(vm, disk, VIR_ASYNC_JOB_NONE);
virDomainAuditDisk(vm, NULL, disk->src, "attach", ret == 0);
ignore_value(qemuDomainStorageSourceChainAccessRevoke(driver, vm, disk->src));
if (virStorageSourceChainHasManagedPR(disk->src))
- ignore_value(qemuHotplugRemoveManagedPR(driver, vm, VIR_ASYNC_JOB_NONE));
+ ignore_value(qemuHotplugRemoveManagedPR(vm, VIR_ASYNC_JOB_NONE));
}
qemuDomainSecretDiskDestroy(disk);
if (!(netprops = qemuBuildHostNetProps(net)))
goto cleanup;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
for (n = netpriv->tapfds; n; n = n->next) {
if (qemuFDPassDirectTransferMonitor(n->data, priv->mon) < 0) {
if (!(nicprops = qemuBuildNicDevProps(vm->def, net, priv->qemuCaps)))
goto try_remove;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuDomainAttachExtensionDevice(priv->mon, &net->info) < 0) {
qemuDomainObjExitMonitor(vm);
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("device alias not found: cannot set link state to down"));
} else {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
qemuDomainObjExitMonitor(vm);
netdev_name = g_strdup_printf("host%s", net->info.alias);
if (QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp)
qemuSlirpStop(QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp, vm, driver, net);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (charDevPlugged &&
qemuMonitorDetachCharDev(priv->mon, charDevAlias) < 0)
VIR_WARN("Failed to remove associated chardev %s", charDevAlias);
if (!(devprops = qemuBuildPCIHostdevDevProps(vm->def, hostdev)))
goto error;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if ((ret = qemuDomainAttachExtensionDevice(priv->mon, hostdev->info)) < 0)
goto exit_monitor;
void
-qemuDomainDelTLSObjects(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainDelTLSObjects(virDomainObj *vm,
virDomainAsyncJob asyncJob,
const char *secAlias,
const char *tlsAlias)
virErrorPreserveLast(&orig_err);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
if (tlsAlias)
int
-qemuDomainAddTLSObjects(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAddTLSObjects(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virJSONValue **secProps,
virJSONValue **tlsProps)
if (!tlsProps && !secProps)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
if (secProps && *secProps &&
virErrorPreserveLast(&orig_err);
qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
- qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, NULL);
+ qemuDomainDelTLSObjects(vm, asyncJob, secAlias, NULL);
return -1;
}
dev->data.tcp.tlscreds = true;
- if (qemuDomainAddTLSObjects(driver, vm, VIR_ASYNC_JOB_NONE,
+ if (qemuDomainAddTLSObjects(vm, VIR_ASYNC_JOB_NONE,
&secProps, &tlsProps) < 0)
return -1;
!(secAlias = qemuAliasForSecret(inAlias, NULL)))
return -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ignore_value(qemuMonitorDelObject(priv->mon, tlsAlias, false));
if (secAlias)
&tlsAlias, &secAlias) < 0)
goto audit;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuHotplugChardevAttach(priv->mon, charAlias, redirdev->source) < 0)
goto exit_monitor;
ignore_value(qemuMonitorDetachCharDev(priv->mon, charAlias));
qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
- qemuDomainDelTLSObjects(driver, vm, VIR_ASYNC_JOB_NONE,
+ qemuDomainDelTLSObjects(vm, VIR_ASYNC_JOB_NONE,
secAlias, tlsAlias);
goto audit;
}
&tlsAlias, &secAlias) < 0)
goto audit;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuFDPassTransferMonitor(charpriv->sourcefd, priv->mon) < 0 ||
qemuFDPassTransferMonitor(charpriv->logfd, priv->mon) < 0 ||
qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
- qemuDomainDelTLSObjects(driver, vm, VIR_ASYNC_JOB_NONE,
+ qemuDomainDelTLSObjects(vm, VIR_ASYNC_JOB_NONE,
secAlias, tlsAlias);
goto audit;
}
goto audit;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (rng->backend == VIR_DOMAIN_RNG_BACKEND_EGD &&
qemuHotplugChardevAttach(priv->mon, charAlias, rng->source.chardev) < 0)
qemuDomainObjExitMonitor(vm);
virErrorRestore(&orig_err);
- qemuDomainDelTLSObjects(driver, vm, VIR_ASYNC_JOB_NONE,
+ qemuDomainDelTLSObjects(vm, VIR_ASYNC_JOB_NONE,
secAlias, tlsAlias);
goto audit;
}
if (qemuDomainAdjustMaxMemLock(vm, false) < 0)
goto removedef;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorAddObject(priv->mon, &props, NULL) < 0)
goto exit_monitor;
objAdded = true;
virObjectEventStateQueue(driver->domainEventState, event);
/* fix the balloon size */
- ignore_value(qemuProcessRefreshBalloonState(driver, vm, VIR_ASYNC_JOB_NONE));
+ ignore_value(qemuProcessRefreshBalloonState(vm, VIR_ASYNC_JOB_NONE));
/* mem is consumed by vm->def */
mem = NULL;
/* this step is best effort, removing the device would be so much trouble */
- ignore_value(qemuDomainUpdateMemoryDeviceInfo(driver, vm,
+ ignore_value(qemuDomainUpdateMemoryDeviceInfo(vm,
VIR_ASYNC_JOB_NONE));
ret = 0;
VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorAddDeviceProps(priv->mon, &devprops);
qemuDomainObjExitMonitor(vm);
virDomainAuditHostdev(vm, hostdev, "attach", ret == 0);
* exist; there must not be any missing index in between.
*/
for (i = 0; i <= hostdev->info->addr.drive.controller; i++) {
- if (!qemuDomainFindOrCreateSCSIDiskController(driver, vm, i))
+ if (!qemuDomainFindOrCreateSCSIDiskController(vm, i))
return -1;
}
VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs + 1);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuBlockStorageSourceAttachApply(priv->mon, data) < 0)
goto exit_monitor;
VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs + 1);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if ((ret = qemuDomainAttachExtensionDevice(priv->mon, hostdev->info)) < 0)
goto exit_monitor;
goto cleanup;
teardownmemlock = true;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorAddDeviceProps(priv->mon, &devprops);
qemuDomainObjExitMonitor(vm);
int
-qemuDomainAttachShmemDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAttachShmemDevice(virDomainObj *vm,
virDomainShmemDef *shmem)
{
int ret = -1;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (shmem->server.enabled) {
if (qemuHotplugChardevAttach(priv->mon, charAlias, shmem->server.chr) < 0)
int
-qemuDomainAttachWatchdog(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAttachWatchdog(virDomainObj *vm,
virDomainWatchdogDef *watchdog)
{
int ret = -1;
if (!(props = qemuBuildWatchdogDevProps(vm->def, watchdog)))
goto cleanup;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
/* QEMU doesn't have a 'dump' action; we tell qemu to 'pause', then
libvirt listens for the watchdog event, and we perform the dump
int
-qemuDomainAttachInputDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAttachInputDevice(virDomainObj *vm,
virDomainInputDef *input)
{
int ret = -1;
VIR_REALLOC_N(vm->def->inputs, vm->def->ninputs + 1);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuDomainAttachExtensionDevice(priv->mon, &input->info) < 0)
goto exit_monitor;
int
-qemuDomainAttachVsockDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainAttachVsockDevice(virDomainObj *vm,
virDomainVsockDef *vsock)
{
qemuDomainVsockPrivate *vsockPriv = (qemuDomainVsockPrivate *)vsock->privateData;
if (!(devprops = qemuBuildVsockDevProps(vm->def, vsock, priv->qemuCaps, fdprefix)))
goto cleanup;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuDomainAttachExtensionDevice(priv->mon, &vsock->info) < 0)
goto exit_monitor;
goto cleanup;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuHotplugChardevAttach(priv->mon, charAlias, chardev) < 0)
goto exit_monitor;
return 0;
}
-int qemuDomainChangeNetLinkState(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainChangeNetLinkState(virDomainObj *vm,
virDomainNetDef *dev,
int linkstate)
{
VIR_DEBUG("dev: %s, state: %d", dev->info.alias, linkstate);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorSetLink(priv->mon, dev->info.alias, linkstate);
if (ret < 0)
}
if (needLinkStateChange &&
- qemuDomainChangeNetLinkState(driver, vm, olddev, newdev->linkstate) < 0) {
+ qemuDomainChangeNetLinkState(vm, olddev, newdev->linkstate) < 0) {
goto cleanup;
}
int
-qemuDomainChangeGraphicsPasswords(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainChangeGraphicsPasswords(virDomainObj *vm,
int type,
virDomainGraphicsAuthDef *auth,
const char *defaultPasswd,
if (auth->connected)
connected = virDomainGraphicsAuthConnectedTypeToString(auth->connected);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return ret;
ret = qemuMonitorSetPassword(priv->mon, type, password, connected);
dev->data.vnc.auth.passwd)) {
VIR_DEBUG("Updating password on VNC server %p %p",
dev->data.vnc.auth.passwd, cfg->vncPassword);
- if (qemuDomainChangeGraphicsPasswords(driver, vm,
+ if (qemuDomainChangeGraphicsPasswords(vm,
VIR_DOMAIN_GRAPHICS_TYPE_VNC,
&dev->data.vnc.auth,
cfg->vncPassword,
dev->data.spice.auth.passwd)) {
VIR_DEBUG("Updating password on SPICE server %p %p",
dev->data.spice.auth.passwd, cfg->spicePassword);
- if (qemuDomainChangeGraphicsPasswords(driver, vm,
+ if (qemuDomainChangeGraphicsPasswords(vm,
VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
&dev->data.spice.auth,
cfg->spicePassword,
}
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (diskBackend)
qemuBlockStorageSourceChainDetach(priv->mon, diskBackend);
qemuDomainStorageSourceChainAccessRevoke(driver, vm, disk->src);
if (virStorageSourceChainHasManagedPR(disk->src) &&
- qemuHotplugRemoveManagedPR(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ qemuHotplugRemoveManagedPR(vm, VIR_ASYNC_JOB_NONE) < 0)
goto cleanup;
if (disk->transient) {
backendAlias = g_strdup_printf("mem%s", mem->info.alias);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorDelObject(priv->mon, backendAlias, true);
qemuDomainObjExitMonitor(vm);
virDomainMemoryDefFree(mem);
/* fix the balloon size */
- ignore_value(qemuProcessRefreshBalloonState(driver, vm, VIR_ASYNC_JOB_NONE));
+ ignore_value(qemuProcessRefreshBalloonState(vm, VIR_ASYNC_JOB_NONE));
/* decrease the mlock limit after memory unplug if necessary */
ignore_value(qemuDomainAdjustMaxMemLock(vm, false));
detachscsi = qemuBuildHostdevSCSIDetachPrepare(hostdev, priv->qemuCaps);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
qemuBlockStorageSourceAttachRollback(priv->mon, detachscsi);
qemuDomainObjExitMonitor(vm);
}
*/
ignore_value(qemuInterfaceStopDevice(net));
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitor(vm);
virDomainAuditNet(vm, net, NULL, "detach", false);
return -1;
if (monitor) {
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorDetachCharDev(priv->mon, charAlias);
qemuHotplugRemoveFDSet(priv->mon, chr->info.alias, NULL);
qemuDomainObjExitMonitor(vm);
if (!(charAlias = qemuAliasChardevFromDevAlias(rng->info.alias)))
return -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorDelObject(priv->mon, objAlias, true) < 0)
rc = -1;
static int
-qemuDomainRemoveShmemDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRemoveShmemDevice(virDomainObj *vm,
virDomainShmemDef *shmem)
{
int rc;
memAlias = g_strdup_printf("shmmem-%s", shmem->info.alias);
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (shmem->server.enabled)
rc = qemuMonitorDetachCharDev(priv->mon, charAlias);
if (!(charAlias = qemuAliasChardevFromDevAlias(dev->info.alias)))
return -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
/* DeviceDel from Detach may remove chardev,
* so we cannot rely on return status to delete TLS chardevs.
*/
if (fs->fsdriver == VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS) {
charAlias = qemuDomainGetVhostUserChrAlias(fs->info.alias);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
if (qemuMonitorDetachCharDev(priv->mon, charAlias) < 0)
rc = -1;
return -1;
break;
case VIR_DOMAIN_DEVICE_SHMEM:
- if (qemuDomainRemoveShmemDevice(driver, vm, dev->data.shmem) < 0)
+ if (qemuDomainRemoveShmemDevice(vm, dev->data.shmem) < 0)
return -1;
break;
case VIR_DOMAIN_DEVICE_INPUT:
if (guestfwd) {
int rc;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorRemoveNetdev(priv->mon, tmpChr->info.alias);
qemuDomainObjExitMonitor(vm);
static int
-qemuDomainRemoveVcpu(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRemoveVcpu(virDomainObj *vm,
unsigned int vcpu)
{
qemuDomainObjPrivate *priv = vm->privateData;
virErrorPtr save_error = NULL;
size_t i;
- if (qemuDomainRefreshVcpuInfo(driver, vm, VIR_ASYNC_JOB_NONE, false) < 0)
+ if (qemuDomainRefreshVcpuInfo(vm, VIR_ASYNC_JOB_NONE, false) < 0)
return -1;
/* validation requires us to set the expected state prior to calling it */
void
-qemuDomainRemoveVcpuAlias(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainRemoveVcpuAlias(virDomainObj *vm,
const char *alias)
{
virDomainVcpuDef *vcpu;
vcpupriv = QEMU_DOMAIN_VCPU_PRIVATE(vcpu);
if (STREQ_NULLABLE(alias, vcpupriv->alias)) {
- qemuDomainRemoveVcpu(driver, vm, i);
+ qemuDomainRemoveVcpu(vm, i);
return;
}
}
goto cleanup;
}
- if (qemuDomainRemoveVcpu(driver, vm, vcpu) < 0)
+ if (qemuDomainRemoveVcpu(vm, vcpu) < 0)
goto cleanup;
qemuDomainVcpuPersistOrder(vm->def);
if (!(vcpuprops = qemuBuildHotpluggableCPUProps(vcpuinfo)))
return -1;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorAddDeviceProps(qemuDomainGetMonitor(vm), &vcpuprops);
/* start outputting of the new XML element to allow keeping unpluggability */
vm->def->individualvcpus = true;
- if (qemuDomainRefreshVcpuInfo(driver, vm, VIR_ASYNC_JOB_NONE, false) < 0)
+ if (qemuDomainRefreshVcpuInfo(vm, VIR_ASYNC_JOB_NONE, false) < 0)
return -1;
/* validation requires us to set the expected state prior to calling it */
int
-qemuDomainChangeMemoryRequestedSize(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainChangeMemoryRequestedSize(virDomainObj *vm,
const char *alias,
unsigned long long requestedsize)
{
qemuDomainObjPrivate *priv = vm->privateData;
int rc;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorChangeMemoryRequestedSize(priv->mon, alias, requestedsize);
qemuDomainObjExitMonitor(vm);
virStorageSource *newsrc,
bool force);
-void qemuDomainDelTLSObjects(virQEMUDriver *driver,
- virDomainObj *vm,
+void qemuDomainDelTLSObjects(virDomainObj *vm,
virDomainAsyncJob asyncJob,
const char *secAlias,
const char *tlsAlias);
-int qemuDomainAddTLSObjects(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAddTLSObjects(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virJSONValue **secProps,
virJSONValue **tlsProps);
virJSONValue **tlsProps,
virJSONValue **secProps);
-int qemuDomainAttachControllerDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachControllerDevice(virDomainObj *vm,
virDomainControllerDef *controller);
int qemuDomainAttachDeviceDiskLive(virQEMUDriver *driver,
virDomainObj *vm,
virDomainDeviceDef *dev);
-int qemuDomainAttachDiskGeneric(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachDiskGeneric(virDomainObj *vm,
virDomainDiskDef *disk,
virDomainAsyncJob asyncJob);
int qemuDomainAttachHostDevice(virQEMUDriver *driver,
virDomainObj *vm,
virDomainHostdevDef *hostdev);
-int qemuDomainAttachShmemDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachShmemDevice(virDomainObj *vm,
virDomainShmemDef *shmem);
-int qemuDomainAttachWatchdog(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachWatchdog(virDomainObj *vm,
virDomainWatchdogDef *watchdog);
int qemuDomainFindGraphicsIndex(virDomainDef *def,
virDomainGraphicsDef *dev);
int qemuDomainChangeGraphics(virQEMUDriver *driver,
virDomainObj *vm,
virDomainGraphicsDef *dev);
-int qemuDomainChangeGraphicsPasswords(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainChangeGraphicsPasswords(virDomainObj *vm,
int type,
virDomainGraphicsAuthDef *auth,
const char *defaultPasswd,
int qemuDomainChangeNet(virQEMUDriver *driver,
virDomainObj *vm,
virDomainDeviceDef *dev);
-int qemuDomainChangeNetLinkState(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainChangeNetLinkState(virDomainObj *vm,
virDomainNetDef *dev,
int linkstate);
-int qemuDomainAttachInputDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachInputDevice(virDomainObj *vm,
virDomainInputDef *input);
-int qemuDomainAttachVsockDevice(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainAttachVsockDevice(virDomainObj *vm,
virDomainVsockDef *vsock);
int
qemuDomainAttachFSDevice(virQEMUDriver *driver,
virQEMUDriver *driver,
bool async);
-void qemuDomainRemoveVcpuAlias(virQEMUDriver *driver,
- virDomainObj *vm,
+void qemuDomainRemoveVcpuAlias(virDomainObj *vm,
const char *alias);
int
virDomainObj *vm,
virDomainAsyncJob asyncJob);
-int qemuHotplugRemoveDBusVMState(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuHotplugRemoveDBusVMState(virDomainObj *vm,
virDomainAsyncJob asyncJob);
-int qemuDomainChangeMemoryRequestedSize(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuDomainChangeMemoryRequestedSize(virDomainObj *vm,
const char *alias,
unsigned long long requestedsize);
static int ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT
-qemuMigrationJobStart(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobStart(virDomainObj *vm,
virDomainAsyncJob job,
unsigned long apiFlags)
{
}
mask |= JOB_MASK(VIR_JOB_MODIFY_MIGRATION_SAFE);
- if (qemuDomainObjBeginAsyncJob(driver, vm, job, op, apiFlags) < 0)
+ if (qemuDomainObjBeginAsyncJob(vm, job, op, apiFlags) < 0)
return -1;
qemuDomainJobSetStatsType(priv->job.current,
}
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_IN) < 0)
goto cleanup;
static int
-qemuMigrationDstStopNBDServer(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationDstStopNBDServer(virDomainObj *vm,
qemuMigrationCookie *mig)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (!mig->nbd)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_IN) < 0)
return -1;
* -1 on error or when job failed and failNoJob is true.
*/
static int
-qemuMigrationSrcNBDCopyCancelOne(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcNBDCopyCancelOne(virDomainObj *vm,
virDomainDiskDef *disk,
qemuBlockJobData *job,
bool abortMigration,
return 1;
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
/* when we are aborting the migration we don't care about the data
* Returns 0 on success, -1 otherwise.
*/
static int
-qemuMigrationSrcNBDCopyCancel(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcNBDCopyCancel(virDomainObj *vm,
bool abortMigration,
virDomainAsyncJob asyncJob,
virConnectPtr dconn)
continue;
}
- rv = qemuMigrationSrcNBDCopyCancelOne(driver, vm, disk, job,
+ rv = qemuMigrationSrcNBDCopyCancelOne(vm, disk, job,
abortMigration, asyncJob);
if (rv != 0) {
if (rv < 0) {
if (!diskPriv->migrSource)
continue;
- qemuBlockStorageSourceDetachOneBlockdev(driver, vm, asyncJob,
+ qemuBlockStorageSourceDetachOneBlockdev(vm, asyncJob,
diskPriv->migrSource);
g_clear_pointer(&diskPriv->migrSource, virObjectUnref);
}
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
qemuDomainJobPrivate *jobPriv = priv->job.privateData;
GSList *next;
for (next = jobPriv->migTempBitmaps; next; next = next->next) {
qemuDomainJobPrivateMigrateTempBitmap *t = next->data;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
qemuMonitorBitmapRemove(priv->mon, t->nodename, t->bitmapname);
qemuDomainObjExitMonitor(vm);
static int
-qemuMigrationSrcNBDStorageCopyBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcNBDStorageCopyBlockdev(virDomainObj *vm,
virDomainDiskDef *disk,
const char *jobname,
const char *sourcename,
false)))
return -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
return -1;
static int
-qemuMigrationSrcNBDStorageCopyDriveMirror(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcNBDStorageCopyDriveMirror(virDomainObj *vm,
const char *diskAlias,
const char *host,
int port,
diskAlias);
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
return -1;
static int
-qemuMigrationSrcNBDStorageCopyOne(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcNBDStorageCopyOne(virDomainObj *vm,
virDomainDiskDef *disk,
const char *host,
int port,
if (flags & VIR_MIGRATE_TLS ||
virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV)) {
- rc = qemuMigrationSrcNBDStorageCopyBlockdev(driver, vm,
+ rc = qemuMigrationSrcNBDStorageCopyBlockdev(vm,
disk, jobname,
sourcename, persistjob,
host, port, socket,
tlsHostname,
syncWrites);
} else {
- rc = qemuMigrationSrcNBDStorageCopyDriveMirror(driver, vm, diskAlias,
+ rc = qemuMigrationSrcNBDStorageCopyDriveMirror(vm, diskAlias,
host, port, socket,
mirror_speed,
mirror_shallow);
if (!qemuMigrationAnyCopyDisk(disk, nmigrate_disks, migrate_disks))
continue;
- if (qemuMigrationSrcNBDStorageCopyOne(driver, vm, disk, host, port,
+ if (qemuMigrationSrcNBDStorageCopyOne(vm, disk, host, port,
socket,
mirror_speed, mirror_shallow,
tlsAlias, tlsHostname, flags) < 0)
return -1;
}
- qemuMigrationSrcFetchMirrorStats(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ qemuMigrationSrcFetchMirrorStats(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
priv->job.current);
return 0;
}
static int
-qemuDomainGetMigrationBlockers(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuDomainGetMigrationBlockers(virDomainObj *vm,
int asyncJob,
char ***blockers)
{
qemuDomainObjPrivate *priv = vm->privateData;
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetMigrationBlockers(priv->mon, blockers);
if (blockedReasonsCap) {
g_auto(GStrv) blockers = NULL;
- if (qemuDomainGetMigrationBlockers(driver, vm,
+ if (qemuDomainGetMigrationBlockers(vm,
asyncJob,
&blockers) < 0) {
return false;
int
-qemuMigrationAnyFetchStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationAnyFetchStats(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobData *jobData,
char **error)
qemuDomainJobDataPrivate *privJob = jobData->privateData;
int rv;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rv = qemuMonitorGetMigrationStats(priv->mon, &stats, error);
static int
-qemuMigrationJobCheckStatus(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationJobCheckStatus(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
g_autofree char *error = NULL;
if (privJob->stats.mig.status == QEMU_MONITOR_MIGRATION_STATUS_ERROR) {
- if (qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobData, &error) < 0)
+ if (qemuMigrationAnyFetchStats(vm, asyncJob, jobData, &error) < 0)
return -1;
}
* -2 something else failed, we need to cancel migration.
*/
static int
-qemuMigrationAnyCompleted(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationAnyCompleted(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virConnectPtr dconn,
unsigned int flags)
virDomainJobData *jobData = priv->job.current;
int pauseReason;
- if (qemuMigrationJobCheckStatus(driver, vm, asyncJob) < 0)
+ if (qemuMigrationJobCheckStatus(vm, asyncJob) < 0)
goto error;
/* This flag should only be set when run on src host */
* QEMU reports failed migration.
*/
static int
-qemuMigrationSrcWaitForCompletion(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcWaitForCompletion(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virConnectPtr dconn,
unsigned int flags)
jobData->status = VIR_DOMAIN_JOB_STATUS_MIGRATING;
- while ((rv = qemuMigrationAnyCompleted(driver, vm, asyncJob,
+ while ((rv = qemuMigrationAnyCompleted(vm, asyncJob,
dconn, flags)) != 1) {
if (rv < 0)
return rv;
}
}
- ignore_value(qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobData, NULL));
+ ignore_value(qemuMigrationAnyFetchStats(vm, asyncJob, jobData, NULL));
qemuDomainJobDataUpdateTime(jobData);
qemuDomainJobDataUpdateDowntime(jobData);
static int
-qemuMigrationDstWaitForCompletion(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationDstWaitForCompletion(virDomainObj *vm,
virDomainAsyncJob asyncJob,
bool postcopy)
{
if (postcopy)
flags = QEMU_MIGRATION_COMPLETED_POSTCOPY;
- while ((rv = qemuMigrationAnyCompleted(driver, vm, asyncJob,
+ while ((rv = qemuMigrationAnyCompleted(vm, asyncJob,
NULL, flags)) != 1) {
if (rv < 0 || virDomainObjWait(vm) < 0)
return -1;
static int
-qemuMigrationSrcGraphicsRelocate(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcGraphicsRelocate(virDomainObj *vm,
qemuMigrationCookie *cookie,
const char *graphicsuri)
{
if (port <= 0 && tlsPort <= 0)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) == 0) {
qemuDomainJobPrivate *jobPriv = priv->job.privateData;
int
-qemuMigrationDstRun(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationDstRun(virDomainObj *vm,
const char *uri,
virDomainAsyncJob asyncJob)
{
VIR_DEBUG("Setting up incoming migration with URI %s", uri);
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rv = qemuMonitorSetDBusVMStateIdList(priv->mon, priv->dbusVMStateIds);
return 0;
}
- if (qemuMigrationDstWaitForCompletion(driver, vm, asyncJob, false) < 0)
+ if (qemuMigrationDstWaitForCompletion(vm, asyncJob, false) < 0)
return -1;
return 0;
virConnectPtr conn)
{
qemuDomainObjPrivate *priv = vm->privateData;
- virQEMUDriver *driver = priv->driver;
qemuDomainJobPrivate *jobPriv = priv->job.privateData;
bool postcopy = false;
int phase;
qemuMigrationDstPostcopyFailed(vm);
qemuMigrationJobContinue(vm, qemuProcessCleanupMigrationJob);
} else {
- qemuMigrationParamsReset(driver, vm, priv->job.asyncJob,
+ qemuMigrationParamsReset(vm, priv->job.asyncJob,
jobPriv->migParams, priv->job.apiFlags);
qemuMigrationJobFinish(vm);
}
int
-qemuMigrationAnyRefreshStatus(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationAnyRefreshStatus(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobStatus *status)
{
jobData = virDomainJobDataInit(&qemuJobDataPrivateDataCallbacks);
priv = jobData->privateData;
- if (qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobData, NULL) < 0)
+ if (qemuMigrationAnyFetchStats(vm, asyncJob, jobData, NULL) < 0)
return -1;
qemuMigrationUpdateJobType(jobData);
static char *
-qemuMigrationSrcBeginResume(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcBeginResume(virDomainObj *vm,
const char *xmlin,
char **cookieout,
int *cookieoutlen,
{
virDomainJobStatus status;
- if (qemuMigrationAnyRefreshStatus(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationAnyRefreshStatus(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
&status) < 0)
return NULL;
qemuMigrationAnyConnectionClosed);
qemuDomainCleanupRemove(vm, qemuProcessCleanupMigrationJob);
- xml = qemuMigrationSrcBeginResume(driver, vm, xmlin, cookieout, cookieoutlen, flags);
+ xml = qemuMigrationSrcBeginResume(vm, xmlin, cookieout, cookieoutlen, flags);
if (virCloseCallbacksSet(driver->closeCallbacks, vm, conn,
qemuMigrationAnyConnectionClosed) < 0)
}
if ((flags & VIR_MIGRATE_CHANGE_PROTECTION)) {
- if (qemuMigrationJobStart(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationJobStart(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
flags) < 0)
goto cleanup;
asyncJob = VIR_ASYNC_JOB_MIGRATION_OUT;
if (!qemuMigrationJobIsAllowed(vm))
goto cleanup;
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
asyncJob = VIR_ASYNC_JOB_NONE;
}
* We don't want to require them on the destination.
*/
if (!(flags & VIR_MIGRATE_OFFLINE) &&
- qemuProcessRefreshDisks(driver, vm, asyncJob) < 0)
+ qemuProcessRefreshDisks(vm, asyncJob) < 0)
goto endjob;
if (!(xml = qemuMigrationSrcBeginPhase(driver, vm, xmlin, dname,
if (qemuMigrationDstPrepareAnyBlockDirtyBitmaps(vm, mig, migParams, flags) < 0)
goto error;
- if (qemuMigrationParamsCheck(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ if (qemuMigrationParamsCheck(vm, VIR_ASYNC_JOB_MIGRATION_IN,
migParams, mig->caps->automatic) < 0)
goto error;
goto error;
}
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_MIGRATION_IN,
migParams, flags) < 0)
goto error;
VIR_DEBUG("Received no lockstate");
}
- if (qemuMigrationDstRun(driver, vm, incoming->uri,
+ if (qemuMigrationDstRun(vm, incoming->uri,
VIR_ASYNC_JOB_MIGRATION_IN) < 0)
goto error;
error:
virErrorPreserveLast(&origErr);
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_MIGRATION_IN,
jobPriv->migParams, priv->job.apiFlags);
if (stopProcess) {
priv->hookRun = true;
}
- if (qemuMigrationJobStart(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ if (qemuMigrationJobStart(vm, VIR_ASYNC_JOB_MIGRATION_IN,
flags) < 0)
goto cleanup;
qemuDomainCleanupRemove(vm, qemuProcessCleanupMigrationJob);
- if (qemuMigrationAnyRefreshStatus(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ if (qemuMigrationAnyRefreshStatus(vm, VIR_ASYNC_JOB_MIGRATION_IN,
&status) < 0)
goto cleanup;
listenAddress, port, -1)))
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_MIGRATION_IN) < 0)
goto cleanup;
ret = qemuMonitorMigrateRecover(priv->mon, incoming->uri);
if (virDomainObjGetState(vm, &reason) == VIR_DOMAIN_PAUSED &&
reason == VIR_DOMAIN_PAUSED_POSTCOPY) {
VIR_DEBUG("Refreshing migration statistics");
- if (qemuMigrationAnyFetchStats(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationAnyFetchStats(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
jobData, NULL) < 0)
VIR_WARN("Could not refresh migration statistics");
}
virErrorPreserveLast(&orig_err);
/* cancel any outstanding NBD jobs */
- qemuMigrationSrcNBDCopyCancel(driver, vm, false,
+ qemuMigrationSrcNBDCopyCancel(vm, false,
VIR_ASYNC_JOB_MIGRATION_OUT, NULL);
virErrorRestore(&orig_err);
} else if (!virDomainObjIsFailedPostcopy(vm)) {
qemuMigrationSrcRestoreDomainState(driver, vm);
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
jobPriv->migParams, priv->job.apiFlags);
qemuDomainSetMaxMemLock(vm, 0, &priv->preMigrationMemlock);
}
static int
-qemuMigrationSrcContinue(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcContinue(virDomainObj *vm,
qemuMonitorMigrationStatus status,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorMigrateContinue(priv->mon, status);
if (qemuHotplugAttachDBusVMState(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
rv = qemuMonitorSetDBusVMStateIdList(priv->mon, priv->dbusVMStateIds);
return rv;
} else {
- if (qemuHotplugRemoveDBusVMState(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuHotplugRemoveDBusVMState(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
}
g_autoslist(qemuDomainJobPrivateMigrateTempBitmap) tmpbitmaps = NULL;
qemuDomainObjPrivate *priv = vm->privateData;
qemuDomainJobPrivate *jobPriv = priv->job.privateData;
- virQEMUDriver *driver = priv->driver;
g_autoptr(virJSONValue) actions = virJSONValueNewArray();
g_autoptr(GHashTable) blockNamedNodeData = NULL;
GSList *nextdisk;
}
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
return -1;
rc = qemuMonitorTransaction(priv->mon, &actions);
if (!mig)
goto error;
- if (qemuMigrationSrcGraphicsRelocate(driver, vm, mig, graphicsuri) < 0)
+ if (qemuMigrationSrcGraphicsRelocate(vm, mig, graphicsuri) < 0)
VIR_WARN("unable to provide data for graphics client relocation");
if (mig->blockDirtyBitmaps &&
qemuMigrationSrcRunPrepareBlockDirtyBitmaps(vm, mig, migParams, flags) < 0)
goto error;
- if (qemuMigrationParamsCheck(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationParamsCheck(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
migParams, mig->caps->automatic) < 0)
goto error;
priv->migMaxBandwidth * 1024 * 1024) < 0)
goto error;
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
migParams, flags) < 0)
goto error;
goto error;
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
goto error;
if (flags & VIR_MIGRATE_POSTCOPY)
waitFlags |= QEMU_MIGRATION_COMPLETED_POSTCOPY;
- rc = qemuMigrationSrcWaitForCompletion(driver, vm,
+ rc = qemuMigrationSrcWaitForCompletion(vm,
VIR_ASYNC_JOB_MIGRATION_OUT,
dconn, waitFlags);
if (rc == -2)
}
if (mig->nbd &&
- qemuMigrationSrcNBDCopyCancel(driver, vm, false,
+ qemuMigrationSrcNBDCopyCancel(vm, false,
VIR_ASYNC_JOB_MIGRATION_OUT,
dconn) < 0)
goto error;
* end of the migration.
*/
if (priv->job.current->status == VIR_DOMAIN_JOB_STATUS_PAUSED) {
- if (qemuMigrationSrcContinue(driver, vm,
+ if (qemuMigrationSrcContinue(vm,
QEMU_MONITOR_MIGRATION_STATUS_PRE_SWITCHOVER,
VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
goto error;
waitFlags ^= QEMU_MIGRATION_COMPLETED_PRE_SWITCHOVER;
- rc = qemuMigrationSrcWaitForCompletion(driver, vm,
+ rc = qemuMigrationSrcWaitForCompletion(vm,
VIR_ASYNC_JOB_MIGRATION_OUT,
dconn, waitFlags);
if (rc == -2)
if (cancel &&
priv->job.current->status != VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED &&
- qemuDomainObjEnterMonitorAsync(driver, vm,
+ qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) == 0) {
qemuMonitorMigrateCancel(priv->mon);
qemuDomainObjExitMonitor(vm);
/* cancel any outstanding NBD jobs */
if (mig && mig->nbd)
- qemuMigrationSrcNBDCopyCancel(driver, vm, true,
+ qemuMigrationSrcNBDCopyCancel(vm, true,
VIR_ASYNC_JOB_MIGRATION_OUT,
dconn);
if (!mig)
return -1;
- if (qemuMigrationParamsApply(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationParamsApply(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
migParams, flags) < 0)
return -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_MIGRATION_OUT) < 0)
return -1;
* a single job. */
if (flags & VIR_MIGRATE_POSTCOPY_RESUME) {
- dom_xml = qemuMigrationSrcBeginResume(driver, vm, xmlin,
+ dom_xml = qemuMigrationSrcBeginResume(vm, xmlin,
&cookieout, &cookieoutlen, flags);
} else {
dom_xml = qemuMigrationSrcBeginPhase(driver, vm, xmlin, dname,
qemuMigrationAnyConnectionClosed);
qemuDomainCleanupRemove(vm, qemuProcessCleanupMigrationJob);
} else {
- if (qemuMigrationJobStart(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationJobStart(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
flags) < 0)
goto cleanup;
* here
*/
if (!v3proto && ret < 0)
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
jobPriv->migParams, priv->job.apiFlags);
qemuMigrationSrcRestoreDomainState(driver, vm);
/* If we didn't start the job in the begin phase, start it now. */
if (!(flags & VIR_MIGRATE_CHANGE_PROTECTION)) {
- if (qemuMigrationJobStart(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ if (qemuMigrationJobStart(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
flags) < 0)
return ret;
} else if (!qemuMigrationJobIsActive(vm, VIR_ASYNC_JOB_MIGRATION_OUT)) {
cleanup:
if (ret < 0 && !virDomainObjIsFailedPostcopy(vm)) {
qemuMigrationSrcRestoreDomainState(driver, vm);
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_MIGRATION_OUT,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_MIGRATION_OUT,
jobPriv->migParams, priv->job.apiFlags);
qemuDomainSetMaxMemLock(vm, 0, &priv->preMigrationMemlock);
qemuMigrationJobFinish(vm);
if (inPostCopy)
g_clear_pointer(&job->completed, virDomainJobDataFree);
- qemuMigrationParamsReset(driver, vm, asyncJob, jobPriv->migParams,
+ qemuMigrationParamsReset(vm, asyncJob, jobPriv->migParams,
job->apiFlags);
virPortAllocatorRelease(priv->migrationPort);
if (mig->network && qemuMigrationDstOPDRelocate(driver, vm, mig) < 0)
VIR_WARN("unable to provide network data for relocation");
- if (qemuMigrationDstStopNBDServer(driver, vm, mig) < 0)
+ if (qemuMigrationDstStopNBDServer(vm, mig) < 0)
return -1;
if (qemuRefreshVirtioChannelState(driver, vm,
/* We need to wait for QEMU to process all data sent by the source
* before starting guest CPUs.
*/
- if (qemuMigrationDstWaitForCompletion(driver, vm,
+ if (qemuMigrationDstWaitForCompletion(vm,
VIR_ASYNC_JOB_MIGRATION_IN,
!!(flags & VIR_MIGRATE_POSTCOPY)) < 0) {
/* There's not much we can do for v2 protocol since the
}
if (*inPostCopy &&
- qemuMigrationDstWaitForCompletion(driver, vm,
+ qemuMigrationDstWaitForCompletion(vm,
VIR_ASYNC_JOB_MIGRATION_IN,
false) < 0) {
return -1;
static int
-qemuMigrationDstFinishResume(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuMigrationDstFinishResume(virDomainObj *vm)
{
VIR_DEBUG("vm=%p", vm);
- if (qemuMigrationDstWaitForCompletion(driver, vm,
+ if (qemuMigrationDstWaitForCompletion(vm,
VIR_ASYNC_JOB_MIGRATION_IN,
false) < 0) {
return -1;
/* Check for a possible error on the monitor in case Finish was called
* earlier than monitor EOF handler got a chance to process the error
*/
- qemuDomainCheckMonitor(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN);
+ qemuDomainCheckMonitor(vm, VIR_ASYNC_JOB_MIGRATION_IN);
goto error;
}
}
if (flags & VIR_MIGRATE_POSTCOPY_RESUME) {
- rc = qemuMigrationDstFinishResume(driver, vm);
+ rc = qemuMigrationDstFinishResume(vm);
inPostCopy = true;
} else {
rc = qemuMigrationDstFinishFresh(driver, vm, mig, flags, v3proto,
qemuProcessAutoDestroyRemove(driver, vm);
*finishJob = false;
} else {
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_MIGRATION_IN,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_MIGRATION_IN,
jobPriv->migParams, priv->job.apiFlags);
}
QEMU_DOMAIN_MIG_BANDWIDTH_MAX * 1024 * 1024) < 0)
return -1;
- if (qemuMigrationParamsApply(driver, vm, asyncJob, migParams, 0) < 0)
+ if (qemuMigrationParamsApply(vm, asyncJob, migParams, 0) < 0)
return -1;
priv->migMaxBandwidth = QEMU_DOMAIN_MIG_BANDWIDTH_MAX;
compressor ? pipeFD[1] : fd) < 0)
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
if (!compressor) {
if (rc < 0)
goto cleanup;
- rc = qemuMigrationSrcWaitForCompletion(driver, vm, asyncJob, NULL, 0);
+ rc = qemuMigrationSrcWaitForCompletion(vm, asyncJob, NULL, 0);
if (rc < 0) {
if (rc == -2) {
virErrorPreserveLast(&orig_err);
virCommandAbort(compressor);
if (virDomainObjIsActive(vm) &&
- qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
+ qemuDomainObjEnterMonitorAsync(vm, asyncJob) == 0) {
qemuMonitorMigrateCancel(priv->mon);
qemuDomainObjExitMonitor(vm);
}
if (qemuMigrationParamsSetULL(migParams,
QEMU_MIGRATION_PARAM_MAX_BANDWIDTH,
saveMigBandwidth * 1024 * 1024) == 0)
- ignore_value(qemuMigrationParamsApply(driver, vm, asyncJob,
+ ignore_value(qemuMigrationParamsApply(vm, asyncJob,
migParams, 0));
priv->migMaxBandwidth = saveMigBandwidth;
}
int
-qemuMigrationSrcCancel(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuMigrationSrcCancel(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
bool storage = false;
VIR_DEBUG("Canceling unfinished outgoing migration of domain %s",
vm->def->name);
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ignore_value(qemuMonitorMigrateCancel(priv->mon));
qemuDomainObjExitMonitor(vm);
}
if (storage &&
- qemuMigrationSrcNBDCopyCancel(driver, vm, true,
+ qemuMigrationSrcNBDCopyCancel(vm, true,
VIR_ASYNC_JOB_NONE, NULL) < 0)
return -1;
int
-qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcFetchMirrorStats(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobData *jobData)
{
if (!nbd)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
blockinfo = qemuMonitorGetAllBlockJobInfo(priv->mon, false);
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) G_GNUC_WARN_UNUSED_RESULT;
int
-qemuMigrationSrcCancel(virQEMUDriver *driver,
- virDomainObj *vm);
+qemuMigrationSrcCancel(virDomainObj *vm);
int
-qemuMigrationAnyFetchStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationAnyFetchStats(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobData *jobData,
char **error);
int migrateFd);
int
-qemuMigrationDstRun(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationDstRun(virDomainObj *vm,
const char *uri,
virDomainAsyncJob asyncJob);
qemuMigrationDstPostcopyFailed(virDomainObj *vm);
int
-qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationSrcFetchMirrorStats(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobData *jobData);
int
-qemuMigrationAnyRefreshStatus(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationAnyRefreshStatus(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainJobStatus *status);
static int
qemuMigrationCookieAddNBD(qemuMigrationCookie *mig,
- virQEMUDriver *driver,
virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
mig->nbd->disks = g_new0(struct qemuMigrationCookieNBDDisk, vm->def->ndisks);
mig->nbd->ndisks = 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, priv->job.asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, priv->job.asyncJob) < 0)
return -1;
if (blockdev)
rc = qemuMonitorBlockStatsUpdateCapacityBlockdev(priv->mon, stats);
}
if ((flags & QEMU_MIGRATION_COOKIE_NBD) &&
- qemuMigrationCookieAddNBD(mig, driver, dom) < 0)
+ qemuMigrationCookieAddNBD(mig, dom) < 0)
return -1;
if (flags & QEMU_MIGRATION_COOKIE_STATS &&
* Returns 0 on success, -1 on failure.
*/
int
-qemuMigrationParamsApply(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsApply(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *migParams,
unsigned long apiFlags)
bool postcopyResume = !!(apiFlags & VIR_MIGRATE_POSTCOPY_RESUME);
int ret = -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
/* Changing capabilities is only allowed before migration starts, we need
* This should prevent any issues just in case some cleanup wasn't
* properly completed (both src and dst use the same alias) or
* some other error path between now and perform . */
- qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, *tlsAlias);
+ qemuDomainDelTLSObjects(vm, asyncJob, secAlias, *tlsAlias);
- if (qemuDomainAddTLSObjects(driver, vm, asyncJob, &secProps, &tlsProps) < 0)
+ if (qemuDomainAddTLSObjects(vm, asyncJob, &secProps, &tlsProps) < 0)
return -1;
if (qemuMigrationParamsSetString(migParams,
* security objects and free the secinfo
*/
static void
-qemuMigrationParamsResetTLS(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsResetTLS(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *origParams,
unsigned long apiFlags)
tlsAlias = qemuAliasTLSObjFromSrcAlias(QEMU_MIGRATION_TLS_ALIAS_BASE);
secAlias = qemuAliasForSecret(QEMU_MIGRATION_TLS_ALIAS_BASE, NULL);
- qemuDomainDelTLSObjects(driver, vm, asyncJob, secAlias, tlsAlias);
+ qemuDomainDelTLSObjects(vm, asyncJob, secAlias, tlsAlias);
g_clear_pointer(&QEMU_DOMAIN_PRIVATE(vm)->migSecinfo, qemuDomainSecretInfoFree);
}
int
-qemuMigrationParamsFetch(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsFetch(virDomainObj *vm,
int asyncJob,
qemuMigrationParams **migParams)
{
*migParams = NULL;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetMigrationParams(priv->mon, &jsonParams);
* are unsupported by QEMU.
*/
int
-qemuMigrationParamsCheck(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsCheck(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *migParams,
virBitmap *remoteCaps)
* to ask QEMU for their current settings.
*/
- return qemuMigrationParamsFetch(driver, vm, asyncJob, &jobPriv->migParams);
+ return qemuMigrationParamsFetch(vm, asyncJob, &jobPriv->migParams);
}
* migration (save, managedsave, snapshots, dump) will not try to use them.
*/
void
-qemuMigrationParamsReset(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsReset(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *origParams,
unsigned long apiFlags)
if (!virDomainObjIsActive(vm) || !origParams)
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
clearCaps = virBitmapNew(0);
if (rc < 0)
goto cleanup;
- qemuMigrationParamsResetTLS(driver, vm, asyncJob, origParams, apiFlags);
+ qemuMigrationParamsResetTLS(vm, asyncJob, origParams, apiFlags);
cleanup:
virErrorRestore(&err);
int
-qemuMigrationCapsCheck(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationCapsCheck(virDomainObj *vm,
int asyncJob,
bool reconnect)
{
char **capStr;
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetMigrationCapabilities(priv->mon, &caps);
if (!(json = qemuMigrationCapsToJSON(migEvent, migEvent)))
return -1;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorSetMigrationCapabilities(priv->mon, &json);
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuMigrationParams, qemuMigrationParamsFree);
int
-qemuMigrationParamsApply(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsApply(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *migParams,
unsigned long apiFlags);
qemuMigrationParamsTLSHostnameIsSet(qemuMigrationParams *migParams);
int
-qemuMigrationParamsFetch(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsFetch(virDomainObj *vm,
int asyncJob,
qemuMigrationParams **migParams);
virJSONValue **params);
int
-qemuMigrationParamsCheck(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsCheck(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *migParams,
virBitmap *remoteCaps);
void
-qemuMigrationParamsReset(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationParamsReset(virDomainObj *vm,
int asyncJob,
qemuMigrationParams *origParams,
unsigned long apiFlags);
qemuMigrationParams **migParams);
int
-qemuMigrationCapsCheck(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuMigrationCapsCheck(virDomainObj *vm,
int asyncJob,
bool reconnect);
VIR_DEBUG("vm=%p", vm);
virObjectLock(vm);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
goto cleanup;
if (!virDomainObjIsActive(vm)) {
goto endjob;
}
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorSystemReset(priv->mon);
qemuDomainObjExitMonitor(vm);
static int
-qemuProcessInitMonitor(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessInitMonitor(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
int ret;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
ret = qemuMonitorSetCapabilities(QEMU_DOMAIN_PRIVATE(vm)->mon);
return -1;
}
- if (qemuProcessInitMonitor(driver, vm, asyncJob) < 0)
+ if (qemuProcessInitMonitor(vm, asyncJob) < 0)
return -1;
- if (qemuMigrationCapsCheck(driver, vm, asyncJob, reconnect) < 0)
+ if (qemuMigrationCapsCheck(vm, asyncJob, reconnect) < 0)
return -1;
return 0;
g_autoptr(GHashTable) info = NULL;
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetChardevInfo(priv->mon, &info);
static int
-qemuRefreshPRManagerState(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuRefreshPRManagerState(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) info = NULL;
!qemuDomainDefHasManagedPR(vm))
return 0;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorGetPRManagerInfo(priv->mon, &info);
qemuDomainObjExitMonitor(vm);
if (priv->fdsetindexParsed)
return 0;
- qemuDomainObjEnterMonitor(priv->driver, vm);
+ qemuDomainObjEnterMonitor(vm);
rc = qemuMonitorQueryFdsets(priv->mon, &fdsets);
qemuDomainObjExitMonitor(vm);
static void
-qemuRefreshRTC(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuRefreshRTC(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
time_t now, then;
return;
memset(&thenbits, 0, sizeof(thenbits));
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
now = time(NULL);
rv = qemuMonitorGetRTCTime(priv->mon, &thenbits);
qemuDomainObjExitMonitor(vm);
}
int
-qemuProcessRefreshBalloonState(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessRefreshBalloonState(virDomainObj *vm,
int asyncJob)
{
unsigned long long balloon;
return 0;
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetBalloonInfo(qemuDomainGetMonitor(vm), &balloon);
* reliable if it's available.
* Note that the monitor itself can be on a pty, so we still need to try the
* log output method. */
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
ret = qemuMonitorGetChardevInfo(priv->mon, &info);
VIR_DEBUG("qemuMonitorGetChardevInfo returned %i", ret);
static int
-qemuProcessDetectIOThreadPIDs(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessDetectIOThreadPIDs(virDomainObj *vm,
int asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
}
/* Get the list of IOThreads from qemu */
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
ret = qemuMonitorGetIOThreads(priv->mon, &iothreads, &niothreads);
qemuDomainObjExitMonitor(vm);
/* set link states to down on interfaces at qemu start */
static int
-qemuProcessSetLinkStates(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessSetLinkStates(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
int ret = -1;
int rv;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
for (i = 0; i < def->nnets; i++) {
for (i = 0; i < vm->def->ngraphics; ++i) {
virDomainGraphicsDef *graphics = vm->def->graphics[i];
if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
- ret = qemuDomainChangeGraphicsPasswords(driver, vm,
+ ret = qemuDomainChangeGraphicsPasswords(vm,
VIR_DOMAIN_GRAPHICS_TYPE_VNC,
&graphics->data.vnc.auth,
cfg->vncPassword,
asyncJob);
} else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
- ret = qemuDomainChangeGraphicsPasswords(driver, vm,
+ ret = qemuDomainChangeGraphicsPasswords(vm,
VIR_DOMAIN_GRAPHICS_TYPE_SPICE,
&graphics->data.spice.auth,
cfg->spicePassword,
virDomainVideoDef *video = NULL;
g_autoptr(virQEMUDriverConfig) cfg = NULL;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
for (i = 0; i < vm->def->nvideos; i++) {
priv->runningReason = reason;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto release;
ret = qemuMonitorStartCPUs(priv->mon);
priv->pausedReason = reason;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
ret = qemuMonitorStopCPUs(priv->mon);
}
static int
-qemuProcessUpdateState(virQEMUDriver *driver, virDomainObj *vm)
+qemuProcessUpdateState(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
virDomainState state;
g_autofree char *msg = NULL;
int ret;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ret = qemuMonitorGetStatus(priv->mon, &running, &reason);
qemuDomainObjExitMonitor(vm);
*/
VIR_DEBUG("Cancelling unfinished migration of domain %s",
vm->def->name);
- if (qemuMigrationSrcCancel(driver, vm) < 0) {
+ if (qemuMigrationSrcCancel(vm) < 0) {
VIR_WARN("Could not cancel ongoing migration of domain %s",
vm->def->name);
}
state = virDomainObjGetState(vm, &reason);
- qemuMigrationAnyRefreshStatus(driver, vm, VIR_ASYNC_JOB_NONE, &migStatus);
+ qemuMigrationAnyRefreshStatus(vm, VIR_ASYNC_JOB_NONE, &migStatus);
if (job->asyncJob == VIR_ASYNC_JOB_MIGRATION_OUT) {
rc = qemuProcessRecoverMigrationOut(driver, vm, job, migStatus,
return 0;
}
- qemuMigrationParamsReset(driver, vm, VIR_ASYNC_JOB_NONE,
+ qemuMigrationParamsReset(vm, VIR_ASYNC_JOB_NONE,
jobPriv->migParams, job->apiFlags);
qemuDomainSetMaxMemLock(vm, 0, &priv->preMigrationMemlock);
case VIR_ASYNC_JOB_SAVE:
case VIR_ASYNC_JOB_DUMP:
case VIR_ASYNC_JOB_SNAPSHOT:
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
ignore_value(qemuMonitorMigrateCancel(priv->mon));
qemuDomainObjExitMonitor(vm);
/* resume the domain but only if it was paused as a result of
g_auto(GStrv) old = g_steal_pointer(&priv->qemuDevices);
GStrv tmp;
- if (qemuDomainUpdateDeviceList(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuDomainUpdateDeviceList(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
if (!old)
static int
-qemuProcessFetchGuestCPU(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessFetchGuestCPU(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virCPUData **enabled,
virCPUData **disabled)
if (!generic && !ARCH_IS_X86(vm->def->os.arch))
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
if (generic) {
static int
-qemuProcessUpdateAndVerifyCPU(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessUpdateAndVerifyCPU(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
g_autoptr(virCPUData) cpu = NULL;
g_autoptr(virCPUData) disabled = NULL;
- if (qemuProcessFetchGuestCPU(driver, vm, asyncJob, &cpu, &disabled) < 0)
+ if (qemuProcessFetchGuestCPU(vm, asyncJob, &cpu, &disabled) < 0)
return -1;
if (qemuProcessVerifyCPU(vm, cpu) < 0)
static int
-qemuProcessFetchCPUDefinitions(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessFetchCPUDefinitions(virDomainObj *vm,
virDomainAsyncJob asyncJob,
virDomainCapsCPUModels **cpuModels)
{
g_autoptr(virDomainCapsCPUModels) models = NULL;
int rc;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = virQEMUCapsFetchCPUModels(priv->mon, vm->def->os.arch, &models);
static int
-qemuProcessUpdateCPU(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessUpdateCPU(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
g_autoptr(virCPUData) cpu = NULL;
*/
vm->def->cpu->fallback = VIR_CPU_FALLBACK_ALLOW;
- if (qemuProcessFetchGuestCPU(driver, vm, asyncJob, &cpu, &disabled) < 0)
+ if (qemuProcessFetchGuestCPU(vm, asyncJob, &cpu, &disabled) < 0)
return -1;
if (qemuProcessUpdateLiveGuestCPU(vm, cpu, disabled) < 0)
return -1;
- if (qemuProcessFetchCPUDefinitions(driver, vm, asyncJob, &models) < 0 ||
+ if (qemuProcessFetchCPUDefinitions(vm, asyncJob, &models) < 0 ||
virCPUTranslate(vm->def->os.arch, vm->def->cpu, models) < 0)
return -1;
* parameter between qemuProcessBeginJob and qemuProcessEndJob.
*/
int
-qemuProcessBeginJob(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessBeginJob(virDomainObj *vm,
virDomainJobOperation operation,
unsigned long apiFlags)
{
- if (qemuDomainObjBeginAsyncJob(driver, vm, VIR_ASYNC_JOB_START,
+ if (qemuDomainObjBeginAsyncJob(vm, VIR_ASYNC_JOB_START,
operation, apiFlags) < 0)
return -1;
static int
-qemuProcessSetupBalloon(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessSetupBalloon(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
unsigned long long balloon = vm->def->mem.cur_balloon;
if (!virDomainDefHasMemballoon(vm->def))
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
if (vm->def->memballoon->period)
static int
-qemuProcessSetupHotpluggableVcpus(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessSetupHotpluggableVcpus(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
unsigned int maxvcpus = virDomainDefGetVcpusMax(vm->def);
if (!(vcpuprops = qemuBuildHotpluggableCPUProps(vcpu)))
goto cleanup;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
goto cleanup;
rc = qemuMonitorAddDeviceProps(qemuDomainGetMonitor(vm), &vcpuprops);
* Same hack is done in qemuDomainAttachDiskGeneric.
*/
static int
-qemuProcessSetupDiskThrottlingBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessSetupDiskThrottlingBlockdev(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Setting up disk throttling for -blockdev via block_set_io_throttle");
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
for (i = 0; i < vm->def->ndisks; i++) {
domdisk->transientShareBacking != VIR_TRISTATE_BOOL_YES)
continue;
- if (qemuDomainAttachDiskGeneric(priv->driver, vm, domdisk, asyncJob) < 0)
+ if (qemuDomainAttachDiskGeneric(vm, domdisk, asyncJob) < 0)
return -1;
hasHotpluggedDisk = true;
if (hasHotpluggedDisk) {
int rc;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorSystemReset(priv->mon);
if (vm->def->onReboot != VIR_DOMAIN_LIFECYCLE_ACTION_DESTROY)
return 0;
- if (qemuDomainObjEnterMonitorAsync(priv->driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorSetAction(priv->mon,
VIR_DEBUG("setting up hotpluggable cpus");
if (qemuDomainHasHotpluggableStartupVcpus(vm->def)) {
- if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob, false) < 0)
+ if (qemuDomainRefreshVcpuInfo(vm, asyncJob, false) < 0)
goto cleanup;
if (qemuProcessValidateHotpluggableVcpus(vm->def) < 0)
goto cleanup;
- if (qemuProcessSetupHotpluggableVcpus(driver, vm, asyncJob) < 0)
+ if (qemuProcessSetupHotpluggableVcpus(vm, asyncJob) < 0)
goto cleanup;
}
VIR_DEBUG("Refreshing VCPU info");
- if (qemuDomainRefreshVcpuInfo(driver, vm, asyncJob, false) < 0)
+ if (qemuDomainRefreshVcpuInfo(vm, asyncJob, false) < 0)
goto cleanup;
if (qemuDomainValidateVcpuInfo(vm) < 0)
qemuDomainVcpuPersistOrder(vm->def);
VIR_DEBUG("Verifying and updating provided guest CPU");
- if (qemuProcessUpdateAndVerifyCPU(driver, vm, asyncJob) < 0)
+ if (qemuProcessUpdateAndVerifyCPU(vm, asyncJob) < 0)
goto cleanup;
VIR_DEBUG("Detecting IOThread PIDs");
- if (qemuProcessDetectIOThreadPIDs(driver, vm, asyncJob) < 0)
+ if (qemuProcessDetectIOThreadPIDs(vm, asyncJob) < 0)
goto cleanup;
VIR_DEBUG("Setting global CPU cgroup (if required)");
/* qemu doesn't support setting this on the command line, so
* enter the monitor */
VIR_DEBUG("Setting network link states");
- if (qemuProcessSetLinkStates(driver, vm, asyncJob) < 0)
+ if (qemuProcessSetLinkStates(vm, asyncJob) < 0)
goto cleanup;
VIR_DEBUG("Setting initial memory amount");
- if (qemuProcessSetupBalloon(driver, vm, asyncJob) < 0)
+ if (qemuProcessSetupBalloon(vm, asyncJob) < 0)
goto cleanup;
- if (qemuProcessSetupDiskThrottlingBlockdev(driver, vm, asyncJob) < 0)
+ if (qemuProcessSetupDiskThrottlingBlockdev(vm, asyncJob) < 0)
goto cleanup;
/* Since CPUs were not started yet, the balloon could not return the memory
* to the host and thus cur_balloon needs to be updated so that GetXMLdesc
* and friends return the correct size in case they can't grab the job */
if (!incoming && !snapshot &&
- qemuProcessRefreshBalloonState(driver, vm, asyncJob) < 0)
+ qemuProcessRefreshBalloonState(vm, asyncJob) < 0)
goto cleanup;
if (flags & VIR_QEMU_PROCESS_START_AUTODESTROY &&
qemuDomainObjPrivate *priv = vm->privateData;
VIR_DEBUG("Fetching list of active devices");
- if (qemuDomainUpdateDeviceList(driver, vm, asyncJob) < 0)
+ if (qemuDomainUpdateDeviceList(vm, asyncJob) < 0)
return -1;
VIR_DEBUG("Updating info of memory devices");
- if (qemuDomainUpdateMemoryDeviceInfo(driver, vm, asyncJob) < 0)
+ if (qemuDomainUpdateMemoryDeviceInfo(vm, asyncJob) < 0)
return -1;
VIR_DEBUG("Detecting actual memory size for video device");
return -1;
VIR_DEBUG("Updating disk data");
- if (qemuProcessRefreshDisks(driver, vm, asyncJob) < 0)
+ if (qemuProcessRefreshDisks(vm, asyncJob) < 0)
return -1;
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
- qemuBlockNodeNamesDetect(driver, vm, asyncJob) < 0)
+ qemuBlockNodeNamesDetect(vm, asyncJob) < 0)
return -1;
return 0;
relabel = true;
if (incoming) {
- if (qemuMigrationDstRun(driver, vm, incoming->uri, asyncJob) < 0)
+ if (qemuMigrationDstRun(vm, incoming->uri, asyncJob) < 0)
goto stop;
} else {
/* Refresh state of devices from QEMU. During migration this happens
* qemuProcessStop.
*/
int
-qemuProcessBeginStopJob(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessBeginStopJob(virDomainObj *vm,
virDomainJob job,
bool forceKill)
{
/* Wake up anything waiting on domain condition */
virDomainObjBroadcast(vm);
- if (qemuDomainObjBeginJob(driver, vm, job) < 0)
+ if (qemuDomainObjBeginJob(vm, job) < 0)
goto cleanup;
ret = 0;
virErrorPreserveLast(&orig_err);
if (asyncJob != VIR_ASYNC_JOB_NONE) {
- if (qemuDomainObjBeginNestedJob(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjBeginNestedJob(vm, asyncJob) < 0)
goto cleanup;
} else if (priv->job.asyncJob != VIR_ASYNC_JOB_NONE &&
priv->job.asyncOwner == virThreadSelfID() &&
VIR_DEBUG("Killing domain");
- if (qemuProcessBeginStopJob(driver, dom, VIR_JOB_DESTROY, true) < 0)
+ if (qemuProcessBeginStopJob(dom, VIR_JOB_DESTROY, true) < 0)
return;
qemuProcessStop(driver, dom, VIR_DOMAIN_SHUTOFF_DESTROYED,
int
-qemuProcessRefreshDisks(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessRefreshDisks(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
g_autoptr(GHashTable) table = NULL;
size_t i;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) == 0) {
table = qemuMonitorGetBlockInfo(priv->mon);
qemuDomainObjExitMonitor(vm);
}
static int
-qemuProcessRefreshCPUMigratability(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuProcessRefreshCPUMigratability(virDomainObj *vm,
virDomainAsyncJob asyncJob)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (!ARCH_IS_X86(def->os.arch))
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuMonitorGetCPUMigratable(priv->mon, cpuQOMPath, &migratable);
if (!vm->def->cpu)
return 0;
- if (qemuProcessRefreshCPUMigratability(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuProcessRefreshCPUMigratability(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
if (!(host = virQEMUDriverGetHostCPU(driver))) {
if (virCPUUpdate(vm->def->os.arch, vm->def->cpu, cpu) < 0)
return -1;
- if (qemuProcessUpdateCPU(driver, vm, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuProcessUpdateCPU(vm, VIR_ASYNC_JOB_NONE) < 0)
return -1;
} else if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION)) {
/* We only try to fix CPUs when the libvirt/QEMU combo used to start
static int
-qemuProcessRefreshLegacyBlockjobs(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuProcessRefreshLegacyBlockjobs(virDomainObj *vm)
{
g_autoptr(GHashTable) blockJobs = NULL;
- qemuDomainObjEnterMonitor(driver, vm);
+ qemuDomainObjEnterMonitor(vm);
blockJobs = qemuMonitorGetAllBlockJobInfo(qemuDomainGetMonitor(vm), true);
qemuDomainObjExitMonitor(vm);
static int
-qemuProcessRefreshBlockjobs(virQEMUDriver *driver,
- virDomainObj *vm)
+qemuProcessRefreshBlockjobs(virDomainObj *vm)
{
qemuDomainObjPrivate *priv = vm->privateData;
if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV))
- return qemuBlockJobRefreshJobs(driver, vm);
+ return qemuBlockJobRefreshJobs(vm);
- return qemuProcessRefreshLegacyBlockjobs(driver, vm);
+ return qemuProcessRefreshLegacyBlockjobs(vm);
}
if (oldjob.asyncJob == VIR_ASYNC_JOB_BACKUP && priv->backup)
priv->backup->apiFlags = oldjob.apiFlags;
- if (qemuDomainObjBeginJob(driver, obj, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(obj, VIR_JOB_MODIFY) < 0)
goto error;
jobStarted = true;
goto error;
}
- if (qemuProcessUpdateState(driver, obj) < 0)
+ if (qemuProcessUpdateState(obj) < 0)
goto error;
state = virDomainObjGetState(obj, &reason);
ignore_value(qemuSecurityCheckAllLabel(driver->securityManager,
obj->def));
- if (qemuDomainRefreshVcpuInfo(driver, obj, VIR_ASYNC_JOB_NONE, true) < 0)
+ if (qemuDomainRefreshVcpuInfo(obj, VIR_ASYNC_JOB_NONE, true) < 0)
goto error;
qemuDomainVcpuPersistOrder(obj->def);
if (qemuProcessRefreshCPU(driver, obj) < 0)
goto error;
- if (qemuDomainUpdateMemoryDeviceInfo(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuDomainUpdateMemoryDeviceInfo(obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
- if (qemuProcessDetectIOThreadPIDs(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuProcessDetectIOThreadPIDs(obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
if (qemuSecurityReserveLabel(driver->securityManager, obj->def, obj->pid) < 0)
qemuProcessFiltersInstantiate(obj->def);
- if (qemuProcessRefreshDisks(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuProcessRefreshDisks(obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
/* At this point we've already checked that the startup of the VM was
}
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKDEV) &&
- qemuBlockNodeNamesDetect(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
+ qemuBlockNodeNamesDetect(obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
if (qemuRefreshVirtioChannelState(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
/* If querying of guest's RTC failed, report error, but do not kill the domain. */
- qemuRefreshRTC(driver, obj);
+ qemuRefreshRTC(obj);
- if (qemuProcessRefreshBalloonState(driver, obj, VIR_ASYNC_JOB_NONE) < 0)
+ if (qemuProcessRefreshBalloonState(obj, VIR_ASYNC_JOB_NONE) < 0)
goto error;
if (qemuProcessRecoverJob(driver, obj, &oldjob, &stopFlags) < 0)
goto error;
- if (qemuProcessRefreshBlockjobs(driver, obj) < 0)
+ if (qemuProcessRefreshBlockjobs(obj) < 0)
goto error;
if (qemuProcessUpdateDevices(driver, obj) < 0)
goto error;
- if (qemuRefreshPRManagerState(driver, obj) < 0)
+ if (qemuRefreshPRManagerState(obj) < 0)
goto error;
if (qemuProcessRefreshFdsetIndex(obj) < 0)
const char *path);
void qemuProcessIncomingDefFree(qemuProcessIncomingDef *inc);
-int qemuProcessBeginJob(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuProcessBeginJob(virDomainObj *vm,
virDomainJobOperation operation,
unsigned long apiFlags);
void qemuProcessEndJob(virDomainObj *vm);
VIR_QEMU_PROCESS_STOP_NO_RELABEL = 1 << 1,
} qemuProcessStopFlags;
-int qemuProcessBeginStopJob(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuProcessBeginStopJob(virDomainObj *vm,
virDomainJob job,
bool forceKill);
void qemuProcessStop(virQEMUDriver *driver,
virDomainObj *vm,
virDomainAsyncJob asyncJob);
-int qemuProcessRefreshBalloonState(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuProcessRefreshBalloonState(virDomainObj *vm,
int asyncJob);
-int qemuProcessRefreshDisks(virQEMUDriver *driver,
- virDomainObj *vm,
+int qemuProcessRefreshDisks(virDomainObj *vm,
virDomainAsyncJob asyncJob);
int qemuProcessStartManagedPRDaemon(virDomainObj *vm) G_NO_INLINE;
}
}
- if (qemuDomainObjEnterMonitorAsync(driver, vm,
+ if (qemuDomainObjEnterMonitorAsync(vm,
VIR_ASYNC_JOB_SNAPSHOT) < 0) {
resume = false;
goto cleanup;
* be set to NULL by qemuSnapshotDiskUpdateSource */
if (data[i].src) {
if (data[i].blockdevadded) {
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) == 0) {
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) == 0) {
qemuBlockStorageSourceAttachRollback(qemuDomainGetMonitor(vm),
data[i].crdata->srcdata[0]);
static int
-qemuSnapshotDiskPrepareOneBlockdev(virQEMUDriver *driver,
- virDomainObj *vm,
+qemuSnapshotDiskPrepareOneBlockdev(virDomainObj *vm,
qemuSnapshotDiskData *dd,
virQEMUDriverConfig *cfg,
bool reuse,
return -1;
if (reuse) {
- if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(vm, asyncJob) < 0)
return -1;
rc = qemuBlockStorageSourceAttachApply(qemuDomainGetMonitor(vm),
dd->prepared = true;
if (blockdev) {
- if (qemuSnapshotDiskPrepareOneBlockdev(driver, vm, dd, snapctxt->cfg, reuse,
+ if (qemuSnapshotDiskPrepareOneBlockdev(vm, dd, snapctxt->cfg, reuse,
blockNamedNodeData, snapctxt->asyncJob) < 0)
return -1;
if (snapctxt->ndd == 0)
return 0;
- if (qemuDomainObjEnterMonitorAsync(driver, snapctxt->vm, snapctxt->asyncJob) < 0)
+ if (qemuDomainObjEnterMonitorAsync(snapctxt->vm, snapctxt->asyncJob) < 0)
return -1;
rc = qemuMonitorTransaction(priv->mon, &snapctxt->actions);
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_QUIESCE) {
int frozen;
- if (qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) < 0)
goto cleanup;
if (virDomainObjCheckActive(vm) < 0) {
}
if (thaw &&
- qemuDomainObjBeginAgentJob(driver, vm, VIR_AGENT_JOB_MODIFY) >= 0 &&
+ qemuDomainObjBeginAgentJob(vm, VIR_AGENT_JOB_MODIFY) >= 0 &&
virDomainObjIsActive(vm)) {
/* report error only on an otherwise successful snapshot */
if (qemuSnapshotFSThaw(vm, ret == 0) < 0)
* a regular job, so we need to set the job mask to disallow query as
* 'savevm' blocks the monitor. External snapshot will then modify the
* job mask appropriately. */
- if (qemuDomainObjBeginAsyncJob(driver, vm, VIR_ASYNC_JOB_SNAPSHOT,
+ if (qemuDomainObjBeginAsyncJob(vm, VIR_ASYNC_JOB_SNAPSHOT,
VIR_DOMAIN_JOB_OPERATION_SNAPSHOT, flags) < 0)
return NULL;
return -1;
}
- if (qemuProcessBeginJob(driver, vm,
+ if (qemuProcessBeginJob(vm,
VIR_DOMAIN_JOB_OPERATION_SNAPSHOT_REVERT,
flags) < 0)
return -1;
VIR_DOMAIN_SNAPSHOT_DELETE_METADATA_ONLY |
VIR_DOMAIN_SNAPSHOT_DELETE_CHILDREN_ONLY, -1);
- if (qemuDomainObjBeginJob(driver, vm, VIR_JOB_MODIFY) < 0)
+ if (qemuDomainObjBeginJob(vm, VIR_JOB_MODIFY) < 0)
return -1;
if (!(snap = qemuSnapObjFromSnapshot(vm, snapshot)))
ret = qemuDomainAttachChrDevice(&driver, vm, dev);
break;
case VIR_DOMAIN_DEVICE_SHMEM:
- ret = qemuDomainAttachShmemDevice(&driver, vm, dev->data.shmem);
+ ret = qemuDomainAttachShmemDevice(vm, dev->data.shmem);
break;
case VIR_DOMAIN_DEVICE_WATCHDOG:
- ret = qemuDomainAttachWatchdog(&driver, vm, dev->data.watchdog);
+ ret = qemuDomainAttachWatchdog(vm, dev->data.watchdog);
break;
case VIR_DOMAIN_DEVICE_HOSTDEV:
ret = qemuDomainAttachHostDevice(&driver, vm, dev->data.hostdev);
priv->mon = qemuMonitorTestGetMonitor(data->mon);
virObjectUnlock(priv->mon);
- if (qemuDomainRefreshVcpuInfo(&driver, data->vm, 0, false) < 0)
+ if (qemuDomainRefreshVcpuInfo(data->vm, 0, false) < 0)
goto error;
return data;
projects / thirdparty / libvirt.git / commitdiff
