External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-08-01 14:37:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Do not use opaque pointer in QEMU monitor callbacks

Browse Source 
It always points to QEMU driver, which is quite redundant as all
callbacks also get a pointer to a vm object. Let's get the driver
pointer from there instead.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
This commit is contained in:
Jiri Denemark 2022-05-24 15:01:07 +02:00
parent 64d5d06c56
commit 88f3727e71
1 changed files with 70 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
src/qemu/qemu_process.c
View File

@ -305,9 +305,8 @@ qemuProcessEventSubmit(virDomainObj *vm,
static void static void
qemuProcessHandleMonitorEOF(qemuMonitor *mon, qemuProcessHandleMonitorEOF(qemuMonitor *mon,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque;
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virObjectLock(vm); virObjectLock(vm);
@ -332,7 +331,7 @@ qemuProcessHandleMonitorEOF(qemuMonitor *mon,
/* We don't want any cleanup from EOF handler (or any other /* We don't want any cleanup from EOF handler (or any other
* thread) to enter qemu namespace. */ * thread) to enter qemu namespace. */
qemuDomainDestroyNamespace(driver, vm); qemuDomainDestroyNamespace(priv->driver, vm);
cleanup: cleanup:
virObjectUnlock(vm); virObjectUnlock(vm);
@ -348,17 +347,18 @@ qemuProcessHandleMonitorEOF(qemuMonitor *mon,
static void static void
qemuProcessHandleMonitorError(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleMonitorError(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; qemuDomainObjPrivate *priv;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectLock(vm); virObjectLock(vm);
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name); VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
((qemuDomainObjPrivate *) vm->privateData)->monError = true; priv = vm->privateData;
priv->monError = true;
event = virDomainEventControlErrorNewFromObj(vm); event = virDomainEventControlErrorNewFromObj(vm);
virObjectEventStateQueue(driver->domainEventState, event); virObjectEventStateQueue(priv->driver->domainEventState, event);
virObjectUnlock(vm); virObjectUnlock(vm);
} }
@ -409,15 +409,17 @@ qemuProcessFindDomainDiskByAliasOrQOM(virDomainObj *vm,
static void static void
qemuProcessHandleReset(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleReset(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virDomainState state; virDomainState state;
int reason; int reason;
virObjectLock(vm); virObjectLock(vm);
priv = vm->privateData;
driver = priv->driver;
state = virDomainObjGetState(vm, &reason); state = virDomainObjGetState(vm, &reason);
@ -430,7 +432,6 @@ qemuProcessHandleReset(qemuMonitor *mon G_GNUC_UNUSED,
} }
event = virDomainEventRebootNewFromObj(vm); event = virDomainEventRebootNewFromObj(vm);
priv = vm->privateData;
if (priv->agent) if (priv->agent)
qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_RESET); qemuAgentNotifyEvent(priv->agent, QEMU_AGENT_EVENT_RESET);
@ -542,14 +543,15 @@ qemuProcessHandleEvent(qemuMonitor *mon G_GNUC_UNUSED,
long long seconds, long long seconds,
unsigned int micros, unsigned int micros,
const char *details, const char *details,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
VIR_DEBUG("vm=%p", vm); VIR_DEBUG("vm=%p", vm);
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainQemuMonitorEventNew(vm->def->id, vm->def->name, event = virDomainQemuMonitorEventNew(vm->def->id, vm->def->name,
vm->def->uuid, eventName, vm->def->uuid, eventName,
seconds, micros, details); seconds, micros, details);
@ -563,9 +565,9 @@ static void
qemuProcessHandleShutdown(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleShutdown(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
virTristateBool guest_initiated, virTristateBool guest_initiated,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
int detail = 0; int detail = 0;
@ -575,6 +577,8 @@ qemuProcessHandleShutdown(qemuMonitor *mon G_GNUC_UNUSED,
virObjectLock(vm); virObjectLock(vm);
priv = vm->privateData; priv = vm->privateData;
driver = priv->driver;
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_SHUTDOWN) { if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_SHUTDOWN) {
VIR_DEBUG("Ignoring repeated SHUTDOWN event from domain %s", VIR_DEBUG("Ignoring repeated SHUTDOWN event from domain %s",
vm->def->name); vm->def->name);
@ -633,9 +637,9 @@ qemuProcessHandleShutdown(qemuMonitor *mon G_GNUC_UNUSED,
static void static void
qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virDomainPausedReason reason; virDomainPausedReason reason;
virDomainEventSuspendedDetailType detail; virDomainEventSuspendedDetailType detail;
@ -643,6 +647,7 @@ qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED,
virObjectLock(vm); virObjectLock(vm);
driver = priv->driver;
reason = priv->pausedReason; reason = priv->pausedReason;
priv->pausedReason = VIR_DOMAIN_PAUSED_UNKNOWN; priv->pausedReason = VIR_DOMAIN_PAUSED_UNKNOWN;
@ -690,9 +695,9 @@ qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED,
static void static void
qemuProcessHandleResume(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleResume(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virDomainRunningReason reason = VIR_DOMAIN_RUNNING_UNPAUSED; virDomainRunningReason reason = VIR_DOMAIN_RUNNING_UNPAUSED;
@ -701,6 +706,8 @@ qemuProcessHandleResume(qemuMonitor *mon G_GNUC_UNUSED,
virObjectLock(vm); virObjectLock(vm);
priv = vm->privateData; priv = vm->privateData;
driver = priv->driver;
if (priv->runningReason != VIR_DOMAIN_RUNNING_UNKNOWN) { if (priv->runningReason != VIR_DOMAIN_RUNNING_UNKNOWN) {
reason = priv->runningReason; reason = priv->runningReason;
priv->runningReason = VIR_DOMAIN_RUNNING_UNKNOWN; priv->runningReason = VIR_DOMAIN_RUNNING_UNKNOWN;
@ -728,12 +735,13 @@ static void
qemuProcessHandleRTCChange(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleRTCChange(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
long long offset, long long offset,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
if (vm->def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE) { if (vm->def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_VARIABLE) {
/* when a basedate is manually given on the qemu commandline /* when a basedate is manually given on the qemu commandline
@ -769,13 +777,14 @@ static void
qemuProcessHandleWatchdog(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleWatchdog(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
int action, int action,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *watchdogEvent = NULL; virObjectEvent *watchdogEvent = NULL;
virObjectEvent *lifecycleEvent = NULL; virObjectEvent *lifecycleEvent = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action); watchdogEvent = virDomainEventWatchdogNewFromObj(vm, action);
if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE && if (action == VIR_DOMAIN_EVENT_WATCHDOG_PAUSE &&
@ -814,9 +823,9 @@ qemuProcessHandleIOError(qemuMonitor *mon G_GNUC_UNUSED,
const char *nodename, const char *nodename,
int action, int action,
const char *reason, const char *reason,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *ioErrorEvent = NULL; virObjectEvent *ioErrorEvent = NULL;
virObjectEvent *ioErrorEvent2 = NULL; virObjectEvent *ioErrorEvent2 = NULL;
virObjectEvent *lifecycleEvent = NULL; virObjectEvent *lifecycleEvent = NULL;
@ -825,6 +834,7 @@ qemuProcessHandleIOError(qemuMonitor *mon G_GNUC_UNUSED,
virDomainDiskDef *disk; virDomainDiskDef *disk;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
if (*diskAlias == '\0') if (*diskAlias == '\0')
diskAlias = NULL; diskAlias = NULL;
@ -980,9 +990,9 @@ qemuProcessHandleGraphics(qemuMonitor *mon G_GNUC_UNUSED,
const char *authScheme, const char *authScheme,
const char *x509dname, const char *x509dname,
const char *saslUsername, const char *saslUsername,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event; virObjectEvent *event;
virDomainEventGraphicsAddressPtr localAddr = NULL; virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL; virDomainEventGraphicsAddressPtr remoteAddr = NULL;
@ -1013,6 +1023,7 @@ qemuProcessHandleGraphics(qemuMonitor *mon G_GNUC_UNUSED,
} }
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainEventGraphicsNewFromObj(vm, phase, localAddr, remoteAddr, authScheme, subject); event = virDomainEventGraphicsNewFromObj(vm, phase, localAddr, remoteAddr, authScheme, subject);
virObjectUnlock(vm); virObjectUnlock(vm);
@ -1025,13 +1036,14 @@ qemuProcessHandleTrayChange(qemuMonitor *mon G_GNUC_UNUSED,
const char *devAlias, const char *devAlias,
const char *devid, const char *devid,
int reason, int reason,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virDomainDiskDef *disk; virDomainDiskDef *disk;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
disk = qemuProcessFindDomainDiskByAliasOrQOM(vm, devAlias, devid); disk = qemuProcessFindDomainDiskByAliasOrQOM(vm, devAlias, devid);
if (disk) { if (disk) {
@ -1053,13 +1065,14 @@ qemuProcessHandleTrayChange(qemuMonitor *mon G_GNUC_UNUSED,
static void static void
qemuProcessHandlePMWakeup(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandlePMWakeup(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectEvent *lifecycleEvent = NULL; virObjectEvent *lifecycleEvent = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainEventPMWakeupNewFromObj(vm); event = virDomainEventPMWakeupNewFromObj(vm);
/* Don't set domain status back to running if it wasn't paused /* Don't set domain status back to running if it wasn't paused
@ -1085,13 +1098,14 @@ qemuProcessHandlePMWakeup(qemuMonitor *mon G_GNUC_UNUSED,
static void static void
qemuProcessHandlePMSuspend(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandlePMSuspend(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectEvent *lifecycleEvent = NULL; virObjectEvent *lifecycleEvent = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainEventPMSuspendNewFromObj(vm); event = virDomainEventPMSuspendNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
@ -1121,13 +1135,14 @@ static void
qemuProcessHandleBalloonChange(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleBalloonChange(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
unsigned long long actual, unsigned long long actual,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
size_t i; size_t i;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainEventBalloonChangeNewFromObj(vm, actual); event = virDomainEventBalloonChangeNewFromObj(vm, actual);
/* We want the balloon size stored in domain definition to /* We want the balloon size stored in domain definition to
@ -1154,13 +1169,14 @@ qemuProcessHandleBalloonChange(qemuMonitor *mon G_GNUC_UNUSED,
static void static void
qemuProcessHandlePMSuspendDisk(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandlePMSuspendDisk(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectEvent *lifecycleEvent = NULL; virObjectEvent *lifecycleEvent = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
event = virDomainEventPMSuspendDiskNewFromObj(vm); event = virDomainEventPMSuspendDiskNewFromObj(vm);
if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) { if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
@ -1230,12 +1246,13 @@ qemuProcessHandleDeviceUnplugErr(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
const char *devPath, const char *devPath,
const char *devAlias, const char *devAlias,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
VIR_DEBUG("Device %s QOM path %s failed to be removed from domain %p %s", VIR_DEBUG("Device %s QOM path %s failed to be removed from domain %p %s",
devAlias, devPath, vm, vm->def->name); devAlias, devPath, vm, vm->def->name);
@ -1325,12 +1342,13 @@ qemuProcessHandleAcpiOstInfo(qemuMonitor *mon G_GNUC_UNUSED,
const char *slot, const char *slot,
unsigned int source, unsigned int source,
unsigned int status, unsigned int status,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
VIR_DEBUG("ACPI OST info for device %s domain %p %s. " VIR_DEBUG("ACPI OST info for device %s domain %p %s. "
"slotType='%s' slot='%s' source=%u status=%u", "slotType='%s' slot='%s' source=%u status=%u",
@ -1361,10 +1379,10 @@ qemuProcessHandleBlockThreshold(qemuMonitor *mon G_GNUC_UNUSED,
const char *nodename, const char *nodename,
unsigned long long threshold, unsigned long long threshold,
unsigned long long excess, unsigned long long excess,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *eventSource = NULL; virObjectEvent *eventSource = NULL;
virObjectEvent *eventDevice = NULL; virObjectEvent *eventDevice = NULL;
virDomainDiskDef *disk; virDomainDiskDef *disk;
@ -1374,6 +1392,7 @@ qemuProcessHandleBlockThreshold(qemuMonitor *mon G_GNUC_UNUSED,
virObjectLock(vm); virObjectLock(vm);
priv = vm->privateData; priv = vm->privateData;
driver = priv->driver;
VIR_DEBUG("BLOCK_WRITE_THRESHOLD event for block node '%s' in domain %p %s:" VIR_DEBUG("BLOCK_WRITE_THRESHOLD event for block node '%s' in domain %p %s:"
"threshold '%llu' exceeded by '%llu'", "threshold '%llu' exceeded by '%llu'",
@ -1474,11 +1493,11 @@ static void
qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
int status, int status,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
qemuDomainJobDataPrivate *privJob = NULL; qemuDomainJobDataPrivate *privJob = NULL;
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
int reason; int reason;
@ -1489,6 +1508,8 @@ qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED,
qemuMonitorMigrationStatusTypeToString(status)); qemuMonitorMigrationStatusTypeToString(status));
priv = vm->privateData; priv = vm->privateData;
driver = priv->driver;
if (priv->job.asyncJob == VIR_ASYNC_JOB_NONE) { if (priv->job.asyncJob == VIR_ASYNC_JOB_NONE) {
VIR_DEBUG("got MIGRATION event without a migration job"); VIR_DEBUG("got MIGRATION event without a migration job");
goto cleanup; goto cleanup;
@ -1524,9 +1545,8 @@ static void
qemuProcessHandleMigrationPass(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleMigrationPass(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
int pass, int pass,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque;
qemuDomainObjPrivate *priv; qemuDomainObjPrivate *priv;
virObjectLock(vm); virObjectLock(vm);
@ -1540,7 +1560,7 @@ qemuProcessHandleMigrationPass(qemuMonitor *mon G_GNUC_UNUSED,
goto cleanup; goto cleanup;
} }
virObjectEventStateQueue(driver->domainEventState, virObjectEventStateQueue(priv->driver->domainEventState,
virDomainEventMigrationIterationNewFromObj(vm, pass)); virDomainEventMigrationIterationNewFromObj(vm, pass));
cleanup: cleanup:
@ -1677,15 +1697,16 @@ static void
qemuProcessHandleMemoryFailure(qemuMonitor *mon G_GNUC_UNUSED, qemuProcessHandleMemoryFailure(qemuMonitor *mon G_GNUC_UNUSED,
virDomainObj *vm, virDomainObj *vm,
qemuMonitorEventMemoryFailure *mfp, qemuMonitorEventMemoryFailure *mfp,
void *opaque) void *opaque G_GNUC_UNUSED)
{ {
virQEMUDriver *driver = opaque; virQEMUDriver *driver;
virObjectEvent *event = NULL; virObjectEvent *event = NULL;
virDomainMemoryFailureRecipientType recipient; virDomainMemoryFailureRecipientType recipient;
virDomainMemoryFailureActionType action; virDomainMemoryFailureActionType action;
unsigned int flags = 0; unsigned int flags = 0;
virObjectLock(vm); virObjectLock(vm);
driver = QEMU_DOMAIN_PRIVATE(vm)->driver;
switch (mfp->recipient) { switch (mfp->recipient) {
case QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_HYPERVISOR: case QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_HYPERVISOR: