2011-02-14 16:09:39 +00:00
|
|
|
/*
|
2013-07-26 12:24:55 +00:00
|
|
|
* qemu_process.h: QEMU process management
|
2011-02-14 16:09:39 +00:00
|
|
|
*
|
2015-01-08 14:37:50 +00:00
|
|
|
* Copyright (C) 2006-2012, 2015 Red Hat, Inc.
|
2011-02-14 16:09:39 +00:00
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2012-09-20 22:30:55 +00:00
|
|
|
* License along with this library. If not, see
|
2012-07-21 10:06:23 +00:00
|
|
|
* <http://www.gnu.org/licenses/>.
|
2011-02-14 16:09:39 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2019-06-18 16:12:37 +00:00
|
|
|
#pragma once
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2019-06-18 16:12:37 +00:00
|
|
|
#include "qemu_conf.h"
|
|
|
|
#include "qemu_domain.h"
|
|
|
|
#include "virstoragefile.h"
|
2020-02-12 12:51:30 +00:00
|
|
|
#include "vireventthread.h"
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2016-02-26 08:15:55 +00:00
|
|
|
int qemuProcessPrepareMonitorChr(virDomainChrSourceDefPtr monConfig,
|
|
|
|
const char *domainDir);
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2012-11-28 16:43:10 +00:00
|
|
|
int qemuProcessStartCPUs(virQEMUDriverPtr driver,
|
2011-05-04 09:07:01 +00:00
|
|
|
virDomainObjPtr vm,
|
qemu: fix crash when mixing sync and async monitor jobs
Currently, we attempt to run sync job and async job at the same time. It
means that the monitor commands for two jobs can be run in any order.
In the function qemuDomainObjEnterMonitorInternal():
if (priv->job.active == QEMU_JOB_NONE && priv->job.asyncJob) {
if (qemuDomainObjBeginNestedJob(driver, obj) < 0)
We check whether the caller is an async job by priv->job.active and
priv->job.asynJob. But when an async job is running, and a sync job is
also running at the time of the check, then priv->job.active is not
QEMU_JOB_NONE. So we cannot check whether the caller is an async job
in the function qemuDomainObjEnterMonitorInternal(), and must instead
put the burden on the caller to tell us when an async command wants
to do a nested job.
Once the burden is on the caller, then only async monitor enters need
to worry about whether the VM is still running; for sync monitor enter,
the internal return is always 0, so lots of ignore_value can be dropped.
* src/qemu/THREADS.txt: Reflect new rules.
* src/qemu/qemu_domain.h (qemuDomainObjEnterMonitorAsync): New
prototype.
* src/qemu/qemu_process.h (qemuProcessStartCPUs)
(qemuProcessStopCPUs): Add parameter.
* src/qemu/qemu_migration.h (qemuMigrationToFile): Likewise.
(qemuMigrationWaitForCompletion): Make static.
* src/qemu/qemu_domain.c (qemuDomainObjEnterMonitorInternal): Add
parameter.
(qemuDomainObjEnterMonitorAsync): New function.
(qemuDomainObjEnterMonitor, qemuDomainObjEnterMonitorWithDriver):
Update callers.
* src/qemu/qemu_driver.c (qemuDomainSaveInternal)
(qemudDomainCoreDump, doCoreDump, processWatchdogEvent)
(qemudDomainSuspend, qemudDomainResume, qemuDomainSaveImageStartVM)
(qemuDomainSnapshotCreateActive, qemuDomainRevertToSnapshot):
Likewise.
* src/qemu/qemu_process.c (qemuProcessStopCPUs)
(qemuProcessFakeReboot, qemuProcessRecoverMigration)
(qemuProcessRecoverJob, qemuProcessStart): Likewise.
* src/qemu/qemu_migration.c (qemuMigrationToFile)
(qemuMigrationWaitForCompletion, qemuMigrationUpdateJobStatus)
(qemuMigrationJobStart, qemuDomainMigrateGraphicsRelocate)
(doNativeMigrate, doTunnelMigrate, qemuMigrationPerformJob)
(qemuMigrationPerformPhase, qemuMigrationFinish)
(qemuMigrationConfirm): Likewise.
* src/qemu/qemu_hotplug.c: Drop unneeded ignore_value.
2011-07-28 23:18:24 +00:00
|
|
|
virDomainRunningReason reason,
|
2014-06-15 16:32:56 +00:00
|
|
|
qemuDomainAsyncJob asyncJob);
|
2012-11-28 16:43:10 +00:00
|
|
|
int qemuProcessStopCPUs(virQEMUDriverPtr driver,
|
2011-05-04 09:07:01 +00:00
|
|
|
virDomainObjPtr vm,
|
qemu: fix crash when mixing sync and async monitor jobs
Currently, we attempt to run sync job and async job at the same time. It
means that the monitor commands for two jobs can be run in any order.
In the function qemuDomainObjEnterMonitorInternal():
if (priv->job.active == QEMU_JOB_NONE && priv->job.asyncJob) {
if (qemuDomainObjBeginNestedJob(driver, obj) < 0)
We check whether the caller is an async job by priv->job.active and
priv->job.asynJob. But when an async job is running, and a sync job is
also running at the time of the check, then priv->job.active is not
QEMU_JOB_NONE. So we cannot check whether the caller is an async job
in the function qemuDomainObjEnterMonitorInternal(), and must instead
put the burden on the caller to tell us when an async command wants
to do a nested job.
Once the burden is on the caller, then only async monitor enters need
to worry about whether the VM is still running; for sync monitor enter,
the internal return is always 0, so lots of ignore_value can be dropped.
* src/qemu/THREADS.txt: Reflect new rules.
* src/qemu/qemu_domain.h (qemuDomainObjEnterMonitorAsync): New
prototype.
* src/qemu/qemu_process.h (qemuProcessStartCPUs)
(qemuProcessStopCPUs): Add parameter.
* src/qemu/qemu_migration.h (qemuMigrationToFile): Likewise.
(qemuMigrationWaitForCompletion): Make static.
* src/qemu/qemu_domain.c (qemuDomainObjEnterMonitorInternal): Add
parameter.
(qemuDomainObjEnterMonitorAsync): New function.
(qemuDomainObjEnterMonitor, qemuDomainObjEnterMonitorWithDriver):
Update callers.
* src/qemu/qemu_driver.c (qemuDomainSaveInternal)
(qemudDomainCoreDump, doCoreDump, processWatchdogEvent)
(qemudDomainSuspend, qemudDomainResume, qemuDomainSaveImageStartVM)
(qemuDomainSnapshotCreateActive, qemuDomainRevertToSnapshot):
Likewise.
* src/qemu/qemu_process.c (qemuProcessStopCPUs)
(qemuProcessFakeReboot, qemuProcessRecoverMigration)
(qemuProcessRecoverJob, qemuProcessStart): Likewise.
* src/qemu/qemu_migration.c (qemuMigrationToFile)
(qemuMigrationWaitForCompletion, qemuMigrationUpdateJobStatus)
(qemuMigrationJobStart, qemuDomainMigrateGraphicsRelocate)
(doNativeMigrate, doTunnelMigrate, qemuMigrationPerformJob)
(qemuMigrationPerformPhase, qemuMigrationFinish)
(qemuMigrationConfirm): Likewise.
* src/qemu/qemu_hotplug.c: Drop unneeded ignore_value.
2011-07-28 23:18:24 +00:00
|
|
|
virDomainPausedReason reason,
|
2014-06-15 16:32:56 +00:00
|
|
|
qemuDomainAsyncJob asyncJob);
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2017-11-07 14:19:43 +00:00
|
|
|
int qemuProcessBuildDestroyMemoryPaths(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainMemoryDefPtr mem,
|
|
|
|
bool build);
|
2017-06-07 12:47:37 +00:00
|
|
|
|
2018-01-11 12:02:52 +00:00
|
|
|
int qemuProcessDestroyMemoryBackingPath(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
virDomainMemoryDefPtr mem);
|
|
|
|
|
2018-02-09 17:19:44 +00:00
|
|
|
void qemuProcessReconnectAll(virQEMUDriverPtr driver);
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2015-11-06 17:41:37 +00:00
|
|
|
typedef struct _qemuProcessIncomingDef qemuProcessIncomingDef;
|
|
|
|
typedef qemuProcessIncomingDef *qemuProcessIncomingDefPtr;
|
|
|
|
struct _qemuProcessIncomingDef {
|
2016-01-07 23:07:37 +00:00
|
|
|
char *address; /* address where QEMU is supposed to listen */
|
2015-11-06 17:41:37 +00:00
|
|
|
char *launchURI; /* used as a parameter for -incoming command line option */
|
2015-11-11 17:02:23 +00:00
|
|
|
char *deferredURI; /* used when calling migrate-incoming QMP command */
|
2015-11-06 17:41:37 +00:00
|
|
|
int fd; /* for fd:N URI */
|
|
|
|
const char *path; /* path associated with fd */
|
|
|
|
};
|
|
|
|
|
|
|
|
qemuProcessIncomingDefPtr qemuProcessIncomingDefNew(virQEMUCapsPtr qemuCaps,
|
2016-01-07 23:07:37 +00:00
|
|
|
const char *listenAddress,
|
2015-11-06 17:41:37 +00:00
|
|
|
const char *migrateFrom,
|
|
|
|
int fd,
|
|
|
|
const char *path);
|
|
|
|
void qemuProcessIncomingDefFree(qemuProcessIncomingDefPtr inc);
|
|
|
|
|
2015-10-21 08:55:43 +00:00
|
|
|
int qemuProcessBeginJob(virQEMUDriverPtr driver,
|
2017-04-26 10:00:09 +00:00
|
|
|
virDomainObjPtr vm,
|
2018-03-21 12:01:59 +00:00
|
|
|
virDomainJobOperation operation,
|
|
|
|
unsigned long apiFlags);
|
2015-10-21 08:55:43 +00:00
|
|
|
void qemuProcessEndJob(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
2012-03-08 13:20:19 +00:00
|
|
|
typedef enum {
|
|
|
|
VIR_QEMU_PROCESS_START_COLD = 1 << 0,
|
|
|
|
VIR_QEMU_PROCESS_START_PAUSED = 1 << 1,
|
2013-02-27 16:53:08 +00:00
|
|
|
VIR_QEMU_PROCESS_START_AUTODESTROY = 1 << 2,
|
2016-03-15 12:00:59 +00:00
|
|
|
VIR_QEMU_PROCESS_START_PRETEND = 1 << 3,
|
2016-05-27 11:45:05 +00:00
|
|
|
VIR_QEMU_PROCESS_START_NEW = 1 << 4, /* internal, new VM is starting */
|
2018-04-09 14:31:17 +00:00
|
|
|
VIR_QEMU_PROCESS_START_GEN_VMID = 1 << 5, /* Generate a new VMID */
|
2018-06-28 11:49:12 +00:00
|
|
|
VIR_QEMU_PROCESS_START_STANDALONE = 1 << 6, /* Require CLI args to be usable standalone,
|
|
|
|
ie no FD passing and the like */
|
2012-03-08 13:20:19 +00:00
|
|
|
} qemuProcessStartFlags;
|
|
|
|
|
2011-02-14 16:09:39 +00:00
|
|
|
int qemuProcessStart(virConnectPtr conn,
|
2012-11-28 16:43:10 +00:00
|
|
|
virQEMUDriverPtr driver,
|
2011-02-14 16:09:39 +00:00
|
|
|
virDomainObjPtr vm,
|
2017-05-31 10:34:10 +00:00
|
|
|
virCPUDefPtr updatedCPU,
|
2015-10-21 08:55:43 +00:00
|
|
|
qemuDomainAsyncJob asyncJob,
|
2011-02-14 16:09:39 +00:00
|
|
|
const char *migrateFrom,
|
|
|
|
int stdin_fd,
|
|
|
|
const char *stdin_path,
|
2019-03-22 04:45:25 +00:00
|
|
|
virDomainMomentObjPtr snapshot,
|
2014-04-27 00:15:22 +00:00
|
|
|
virNetDevVPortProfileOp vmop,
|
2012-03-08 13:20:19 +00:00
|
|
|
unsigned int flags);
|
2011-02-14 16:09:39 +00:00
|
|
|
|
2020-10-15 12:39:16 +00:00
|
|
|
int qemuProcessCreatePretendCmdPrepare(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *migrateURI,
|
|
|
|
bool standalone,
|
|
|
|
unsigned int flags);
|
|
|
|
|
|
|
|
virCommandPtr qemuProcessCreatePretendCmdBuild(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *migrateURI,
|
|
|
|
bool enableFips,
|
|
|
|
bool standalone,
|
|
|
|
bool jsonPropsValidation);
|
2016-02-04 14:25:29 +00:00
|
|
|
|
2015-11-10 15:58:12 +00:00
|
|
|
int qemuProcessInit(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
2017-05-31 10:34:10 +00:00
|
|
|
virCPUDefPtr updatedCPU,
|
2016-01-28 14:56:07 +00:00
|
|
|
qemuDomainAsyncJob asyncJob,
|
2016-02-04 14:25:29 +00:00
|
|
|
bool migration,
|
2016-03-17 12:51:20 +00:00
|
|
|
unsigned int flags);
|
2015-11-10 15:58:12 +00:00
|
|
|
|
2018-02-09 16:36:24 +00:00
|
|
|
int qemuProcessPrepareDomain(virQEMUDriverPtr driver,
|
2016-03-15 12:00:59 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2018-05-30 11:53:52 +00:00
|
|
|
int qemuProcessOpenVhostVsock(virDomainVsockDefPtr vsock);
|
|
|
|
|
2020-10-15 13:06:01 +00:00
|
|
|
int qemuProcessPrepareHostHostdev(virDomainHostdevDefPtr hostdev);
|
|
|
|
|
2016-03-22 12:16:05 +00:00
|
|
|
int qemuProcessPrepareHost(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
2017-10-03 08:14:21 +00:00
|
|
|
unsigned int flags);
|
2016-03-22 12:16:05 +00:00
|
|
|
|
2015-11-10 15:58:41 +00:00
|
|
|
int qemuProcessLaunch(virConnectPtr conn,
|
|
|
|
virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainAsyncJob asyncJob,
|
|
|
|
qemuProcessIncomingDefPtr incoming,
|
2019-03-22 04:45:25 +00:00
|
|
|
virDomainMomentObjPtr snapshot,
|
2015-11-10 15:58:41 +00:00
|
|
|
virNetDevVPortProfileOp vmop,
|
|
|
|
unsigned int flags);
|
|
|
|
|
2018-02-09 15:40:51 +00:00
|
|
|
int qemuProcessFinishStartup(virQEMUDriverPtr driver,
|
2015-11-10 12:29:40 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainAsyncJob asyncJob,
|
|
|
|
bool startCPUs,
|
|
|
|
virDomainPausedReason pausedReason);
|
|
|
|
|
2018-02-01 14:02:17 +00:00
|
|
|
int qemuProcessRefreshState(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainAsyncJob asyncJob);
|
|
|
|
|
2012-06-11 13:20:44 +00:00
|
|
|
typedef enum {
|
2012-06-11 13:57:19 +00:00
|
|
|
VIR_QEMU_PROCESS_STOP_MIGRATED = 1 << 0,
|
|
|
|
VIR_QEMU_PROCESS_STOP_NO_RELABEL = 1 << 1,
|
2012-06-11 13:20:44 +00:00
|
|
|
} qemuProcessStopFlags;
|
|
|
|
|
2016-02-11 14:13:09 +00:00
|
|
|
int qemuProcessBeginStopJob(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainJob job,
|
|
|
|
bool forceKill);
|
2012-11-28 16:43:10 +00:00
|
|
|
void qemuProcessStop(virQEMUDriverPtr driver,
|
2011-02-14 16:09:39 +00:00
|
|
|
virDomainObjPtr vm,
|
2012-06-11 13:20:44 +00:00
|
|
|
virDomainShutoffReason reason,
|
2016-02-11 10:20:28 +00:00
|
|
|
qemuDomainAsyncJob asyncJob,
|
2012-06-11 13:20:44 +00:00
|
|
|
unsigned int flags);
|
2011-02-14 16:09:39 +00:00
|
|
|
|
qemu: new GRACEFUL flag for virDomainDestroy w/ QEMU support
When libvirt's virDomainDestroy API is shutting down the qemu process,
it first sends SIGTERM, then waits for 1.6 seconds and, if it sees the
process still there, sends a SIGKILL.
There have been reports that this behavior can lead to data loss
because the guest running in qemu doesn't have time to flush its disk
cache buffers before it's unceremoniously whacked.
This patch maintains that default behavior, but provides a new flag
VIR_DOMAIN_DESTROY_GRACEFUL to alter the behavior. If this flag is set
in the call to virDomainDestroyFlags, SIGKILL will never be sent to
the qemu process; instead, if the timeout is reached and the qemu
process still exists, virDomainDestroy will return an error.
Once this patch is in, the recommended method for applications to call
virDomainDestroyFlags will be with VIR_DOMAIN_DESTROY_GRACEFUL
included. If that fails, then the application can decide if and when
to call virDomainDestroyFlags again without
VIR_DOMAIN_DESTROY_GRACEFUL (to force the issue with SIGKILL).
(Note that this does not address the issue of existing applications
that have not yet been modified to use VIR_DOMAIN_DESTROY_GRACEFUL.
That is a separate patch.)
2012-01-27 18:28:23 +00:00
|
|
|
typedef enum {
|
|
|
|
VIR_QEMU_PROCESS_KILL_FORCE = 1 << 0,
|
|
|
|
VIR_QEMU_PROCESS_KILL_NOWAIT = 1 << 1,
|
2012-03-30 06:21:49 +00:00
|
|
|
VIR_QEMU_PROCESS_KILL_NOCHECK = 1 << 2, /* bypass the running vm check */
|
qemu: new GRACEFUL flag for virDomainDestroy w/ QEMU support
When libvirt's virDomainDestroy API is shutting down the qemu process,
it first sends SIGTERM, then waits for 1.6 seconds and, if it sees the
process still there, sends a SIGKILL.
There have been reports that this behavior can lead to data loss
because the guest running in qemu doesn't have time to flush its disk
cache buffers before it's unceremoniously whacked.
This patch maintains that default behavior, but provides a new flag
VIR_DOMAIN_DESTROY_GRACEFUL to alter the behavior. If this flag is set
in the call to virDomainDestroyFlags, SIGKILL will never be sent to
the qemu process; instead, if the timeout is reached and the qemu
process still exists, virDomainDestroy will return an error.
Once this patch is in, the recommended method for applications to call
virDomainDestroyFlags will be with VIR_DOMAIN_DESTROY_GRACEFUL
included. If that fails, then the application can decide if and when
to call virDomainDestroyFlags again without
VIR_DOMAIN_DESTROY_GRACEFUL (to force the issue with SIGKILL).
(Note that this does not address the issue of existing applications
that have not yet been modified to use VIR_DOMAIN_DESTROY_GRACEFUL.
That is a separate patch.)
2012-01-27 18:28:23 +00:00
|
|
|
} virQemuProcessKillMode;
|
|
|
|
|
2013-02-06 18:17:20 +00:00
|
|
|
int qemuProcessKill(virDomainObjPtr vm, unsigned int flags);
|
2011-04-21 15:19:06 +00:00
|
|
|
|
2013-06-07 10:23:33 +00:00
|
|
|
void qemuProcessShutdownOrReboot(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
2012-11-28 16:43:10 +00:00
|
|
|
int qemuProcessAutoDestroyInit(virQEMUDriverPtr driver);
|
|
|
|
void qemuProcessAutoDestroyShutdown(virQEMUDriverPtr driver);
|
|
|
|
int qemuProcessAutoDestroyAdd(virQEMUDriverPtr driver,
|
2011-06-23 09:37:57 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virConnectPtr conn);
|
2012-11-28 16:43:10 +00:00
|
|
|
int qemuProcessAutoDestroyRemove(virQEMUDriverPtr driver,
|
2011-06-23 09:37:57 +00:00
|
|
|
virDomainObjPtr vm);
|
2012-11-28 16:43:10 +00:00
|
|
|
bool qemuProcessAutoDestroyActive(virQEMUDriverPtr driver,
|
2011-06-23 10:41:57 +00:00
|
|
|
virDomainObjPtr vm);
|
2011-06-23 09:37:57 +00:00
|
|
|
|
2015-01-08 14:37:50 +00:00
|
|
|
int qemuProcessSetSchedParams(int id, pid_t pid, size_t nsp,
|
|
|
|
virDomainThreadSchedParamPtr sp);
|
|
|
|
|
2018-08-13 13:58:07 +00:00
|
|
|
virDomainDiskDefPtr qemuProcessFindDomainDiskByAliasOrQOM(virDomainObjPtr vm,
|
|
|
|
const char *alias,
|
|
|
|
const char *qomid);
|
2015-03-13 15:59:26 +00:00
|
|
|
|
2015-04-24 14:48:26 +00:00
|
|
|
int qemuConnectAgent(virQEMUDriverPtr driver, virDomainObjPtr vm);
|
|
|
|
|
2016-01-13 15:36:52 +00:00
|
|
|
|
|
|
|
int qemuProcessSetupVcpu(virDomainObjPtr vm,
|
|
|
|
unsigned int vcpuid);
|
2016-01-14 09:38:02 +00:00
|
|
|
int qemuProcessSetupIOThread(virDomainObjPtr vm,
|
|
|
|
virDomainIOThreadIDDefPtr iothread);
|
2016-01-13 15:36:52 +00:00
|
|
|
|
2016-01-08 16:03:48 +00:00
|
|
|
int qemuRefreshVirtioChannelState(virQEMUDriverPtr driver,
|
2016-06-29 13:52:49 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainAsyncJob asyncJob);
|
2016-04-06 13:57:57 +00:00
|
|
|
|
|
|
|
int qemuProcessRefreshBalloonState(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
int asyncJob);
|
2016-05-23 12:00:35 +00:00
|
|
|
|
|
|
|
int qemuProcessRefreshDisks(virQEMUDriverPtr driver,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
qemuDomainAsyncJob asyncJob);
|
|
|
|
|
2020-08-04 14:17:07 +00:00
|
|
|
int qemuProcessStartManagedPRDaemon(virDomainObjPtr vm) G_GNUC_NO_INLINE;
|
2018-04-23 11:21:03 +00:00
|
|
|
|
2020-08-04 14:17:07 +00:00
|
|
|
void qemuProcessKillManagedPRDaemon(virDomainObjPtr vm) G_GNUC_NO_INLINE;
|
2018-04-23 11:21:03 +00:00
|
|
|
|
2019-01-13 00:50:01 +00:00
|
|
|
typedef struct _qemuProcessQMP qemuProcessQMP;
|
|
|
|
typedef qemuProcessQMP *qemuProcessQMPPtr;
|
|
|
|
struct _qemuProcessQMP {
|
2019-01-13 00:50:00 +00:00
|
|
|
char *binary;
|
2019-01-13 00:50:12 +00:00
|
|
|
char *libDir;
|
2019-01-13 00:50:00 +00:00
|
|
|
uid_t runUid;
|
|
|
|
gid_t runGid;
|
2019-10-16 11:22:13 +00:00
|
|
|
char *stdErr;
|
2019-01-13 00:50:00 +00:00
|
|
|
char *monarg;
|
|
|
|
char *monpath;
|
|
|
|
char *pidfile;
|
2019-02-13 16:22:31 +00:00
|
|
|
char *uniqDir;
|
2020-02-12 12:51:30 +00:00
|
|
|
virEventThread *eventThread;
|
2019-01-13 00:50:00 +00:00
|
|
|
virCommandPtr cmd;
|
|
|
|
qemuMonitorPtr mon;
|
|
|
|
pid_t pid;
|
|
|
|
virDomainObjPtr vm;
|
2019-01-13 00:50:06 +00:00
|
|
|
bool forceTCG;
|
2019-01-13 00:50:00 +00:00
|
|
|
};
|
|
|
|
|
2019-01-13 00:50:02 +00:00
|
|
|
qemuProcessQMPPtr qemuProcessQMPNew(const char *binary,
|
2019-01-13 00:50:01 +00:00
|
|
|
const char *libDir,
|
|
|
|
uid_t runUid,
|
|
|
|
gid_t runGid,
|
2019-01-13 00:50:06 +00:00
|
|
|
bool forceTCG);
|
2019-01-13 00:50:00 +00:00
|
|
|
|
2019-01-13 00:50:03 +00:00
|
|
|
void qemuProcessQMPFree(qemuProcessQMPPtr proc);
|
2020-07-17 21:15:52 +00:00
|
|
|
G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuProcessQMP, qemuProcessQMPFree);
|
2019-01-13 00:50:00 +00:00
|
|
|
|
2019-01-13 00:50:10 +00:00
|
|
|
int qemuProcessQMPStart(qemuProcessQMPPtr proc);
|