static void processWatchdogEvent(void *data, void *opaque);
-static int qemudShutdown(void);
+static int qemuShutdown(void);
static int qemuDomainObjStart(virConnectPtr conn,
struct qemud_driver *driver,
virDomainObjPtr vm,
unsigned int flags);
-static int qemudDomainGetMaxVcpus(virDomainPtr dom);
+static int qemuDomainGetMaxVcpus(virDomainPtr dom);
static void qemuDomainManagedSaveLoad(void *payload,
const void *n ATTRIBUTE_UNUSED,
/**
- * qemudStartup:
+ * qemuStartup:
*
* Initialization function for the QEmu daemon
*/
static int
-qemudStartup(int privileged) {
+qemuStartup(int privileged) {
char *base = NULL;
char *driverConf = NULL;
int rc;
virStrerror(-rc, ebuf, sizeof(ebuf)));
}
- if (qemudLoadDriverConfig(qemu_driver, driverConf) < 0) {
+ if (qemuLoadDriverConfig(qemu_driver, driverConf) < 0) {
goto error;
}
VIR_FREE(driverConf);
VIR_FREE(driverConf);
VIR_FREE(membase);
VIR_FREE(mempath);
- qemudShutdown();
+ qemuShutdown();
return -1;
}
-static void qemudNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
+static void qemuNotifyLoadDomain(virDomainObjPtr vm, int newVM, void *opaque)
{
struct qemud_driver *driver = opaque;
}
/**
- * qemudReload:
+ * qemuReload:
*
* Function to restart the QEmu daemon, it will recheck the configuration
* files and update its state and the networking
*/
static int
-qemudReload(void) {
+qemuReload(void) {
if (!qemu_driver)
return 0;
qemu_driver->configDir,
qemu_driver->autostartDir,
0, QEMU_EXPECTED_VIRT_TYPES,
- qemudNotifyLoadDomain, qemu_driver);
+ qemuNotifyLoadDomain, qemu_driver);
qemuDriverUnlock(qemu_driver);
return 0;
}
/**
- * qemudActive:
+ * qemuActive:
*
* Checks if the QEmu daemon is active, i.e. has an active domain or
* an active network
* Returns 1 if active, 0 otherwise
*/
static int
-qemudActive(void) {
+qemuActive(void) {
int active = 0;
if (!qemu_driver)
}
/**
- * qemudShutdown:
+ * qemuShutdown:
*
* Shutdown the QEmu daemon, it will stop all active domains and networks
*/
static int
-qemudShutdown(void) {
+qemuShutdown(void) {
int i;
if (!qemu_driver)
}
-static virDrvOpenStatus qemudOpen(virConnectPtr conn,
- virConnectAuthPtr auth ATTRIBUTE_UNUSED,
- unsigned int flags)
+static virDrvOpenStatus qemuOpen(virConnectPtr conn,
+ virConnectAuthPtr auth ATTRIBUTE_UNUSED,
+ unsigned int flags)
{
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
return VIR_DRV_OPEN_SUCCESS;
}
-static int qemudClose(virConnectPtr conn) {
+static int qemuClose(virConnectPtr conn) {
struct qemud_driver *driver = conn->privateData;
/* Get rid of callbacks registered for this conn */
/* Which features are supported by this driver? */
static int
-qemudSupportsFeature(virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
+qemuSupportsFeature(virConnectPtr conn ATTRIBUTE_UNUSED, int feature)
{
switch (feature) {
case VIR_DRV_FEATURE_MIGRATION_V2:
}
}
-static const char *qemudGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
+static const char *qemuGetType(virConnectPtr conn ATTRIBUTE_UNUSED) {
return "QEMU";
}
return virBufferContentAndReset(&buf);
}
-static int qemudGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED, const char *type) {
+static int qemuGetMaxVCPUs(virConnectPtr conn ATTRIBUTE_UNUSED, const char *type) {
if (!type)
return 16;
}
-static char *qemudGetCapabilities(virConnectPtr conn) {
+static char *qemuGetCapabilities(virConnectPtr conn) {
struct qemud_driver *driver = conn->privateData;
virCapsPtr caps = NULL;
char *xml = NULL;
static int
-qemudGetProcessInfo(unsigned long long *cpuTime, int *lastCpu, long *vm_rss,
- pid_t pid, int tid)
+qemuGetProcessInfo(unsigned long long *cpuTime, int *lastCpu, long *vm_rss,
+ pid_t pid, int tid)
{
char *proc;
FILE *pidinfo;
}
-static virDomainPtr qemudDomainLookupByID(virConnectPtr conn,
- int id) {
+static virDomainPtr qemuDomainLookupByID(virConnectPtr conn,
+ int id) {
struct qemud_driver *driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
return dom;
}
-static virDomainPtr qemudDomainLookupByUUID(virConnectPtr conn,
- const unsigned char *uuid) {
+static virDomainPtr qemuDomainLookupByUUID(virConnectPtr conn,
+ const unsigned char *uuid) {
struct qemud_driver *driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
return dom;
}
-static virDomainPtr qemudDomainLookupByName(virConnectPtr conn,
- const char *name) {
+static virDomainPtr qemuDomainLookupByName(virConnectPtr conn,
+ const char *name) {
struct qemud_driver *driver = conn->privateData;
virDomainObjPtr vm;
virDomainPtr dom = NULL;
return ret;
}
-static int qemudGetVersion(virConnectPtr conn, unsigned long *version) {
+static int qemuGetVersion(virConnectPtr conn, unsigned long *version) {
struct qemud_driver *driver = conn->privateData;
int ret = -1;
return ret;
}
-static int qemudListDomains(virConnectPtr conn, int *ids, int nids) {
+static int qemuListDomains(virConnectPtr conn, int *ids, int nids) {
struct qemud_driver *driver = conn->privateData;
int n;
return n;
}
-static int qemudNumDomains(virConnectPtr conn) {
+static int qemuNumDomains(virConnectPtr conn) {
struct qemud_driver *driver = conn->privateData;
int n;
}
-static virDomainPtr qemudDomainCreate(virConnectPtr conn, const char *xml,
- unsigned int flags) {
+static virDomainPtr qemuDomainCreate(virConnectPtr conn, const char *xml,
+ unsigned int flags) {
struct qemud_driver *driver = conn->privateData;
virDomainDefPtr def;
virDomainObjPtr vm = NULL;
}
-static int qemudDomainSuspend(virDomainPtr dom) {
+static int qemuDomainSuspend(virDomainPtr dom) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
}
-static int qemudDomainResume(virDomainPtr dom) {
+static int qemuDomainResume(virDomainPtr dom) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
return qemuDomainDestroyFlags(dom, 0);
}
-static char *qemudDomainGetOSType(virDomainPtr dom) {
+static char *qemuDomainGetOSType(virDomainPtr dom) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
char *type = NULL;
return ret;
}
-static int qemudDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
- unsigned int flags) {
+static int qemuDomainSetMemoryFlags(virDomainPtr dom, unsigned long newmem,
+ unsigned int flags) {
struct qemud_driver *driver = dom->conn->privateData;
qemuDomainObjPrivatePtr priv;
virDomainObjPtr vm;
return ret;
}
-static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem)
+static int qemuDomainSetMemory(virDomainPtr dom, unsigned long newmem)
{
- return qemudDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_AFFECT_LIVE);
+ return qemuDomainSetMemoryFlags(dom, newmem, VIR_DOMAIN_AFFECT_LIVE);
}
-static int qemudDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
+static int qemuDomainSetMaxMemory(virDomainPtr dom, unsigned long memory)
{
- return qemudDomainSetMemoryFlags(dom, memory, VIR_DOMAIN_MEM_MAXIMUM);
+ return qemuDomainSetMemoryFlags(dom, memory, VIR_DOMAIN_MEM_MAXIMUM);
}
static int qemuDomainInjectNMI(virDomainPtr domain, unsigned int flags)
return ret;
}
-static int qemudDomainGetInfo(virDomainPtr dom,
- virDomainInfoPtr info)
+static int qemuDomainGetInfo(virDomainPtr dom,
+ virDomainInfoPtr info)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
if (!virDomainObjIsActive(vm)) {
info->cpuTime = 0;
} else {
- if (qemudGetProcessInfo(&(info->cpuTime), NULL, NULL, vm->pid, 0) < 0) {
+ if (qemuGetProcessInfo(&(info->cpuTime), NULL, NULL, vm->pid, 0) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("cannot read cputime for domain"));
goto cleanup;
}
-#define QEMUD_SAVE_MAGIC "LibvirtQemudSave"
-#define QEMUD_SAVE_PARTIAL "LibvirtQemudPart"
-#define QEMUD_SAVE_VERSION 2
+/* It would be nice to replace 'Qemud' with 'Qemu' but
+ * this magic string is ABI, so it can't be changed
+ */
+#define QEMU_SAVE_MAGIC "LibvirtQemudSave"
+#define QEMU_SAVE_PARTIAL "LibvirtQemudPart"
+#define QEMU_SAVE_VERSION 2
-verify(sizeof(QEMUD_SAVE_MAGIC) == sizeof(QEMUD_SAVE_PARTIAL));
+verify(sizeof(QEMU_SAVE_MAGIC) == sizeof(QEMU_SAVE_PARTIAL));
-enum qemud_save_formats {
- QEMUD_SAVE_FORMAT_RAW = 0,
- QEMUD_SAVE_FORMAT_GZIP = 1,
- QEMUD_SAVE_FORMAT_BZIP2 = 2,
+enum qemu_save_formats {
+ QEMU_SAVE_FORMAT_RAW = 0,
+ QEMU_SAVE_FORMAT_GZIP = 1,
+ QEMU_SAVE_FORMAT_BZIP2 = 2,
/*
* Deprecated by xz and never used as part of a release
- * QEMUD_SAVE_FORMAT_LZMA
+ * QEMU_SAVE_FORMAT_LZMA
*/
- QEMUD_SAVE_FORMAT_XZ = 3,
- QEMUD_SAVE_FORMAT_LZOP = 4,
+ QEMU_SAVE_FORMAT_XZ = 3,
+ QEMU_SAVE_FORMAT_LZOP = 4,
/* Note: add new members only at the end.
These values are used in the on-disk format.
Do not change or re-use numbers. */
- QEMUD_SAVE_FORMAT_LAST
+ QEMU_SAVE_FORMAT_LAST
};
-VIR_ENUM_DECL(qemudSaveCompression)
-VIR_ENUM_IMPL(qemudSaveCompression, QEMUD_SAVE_FORMAT_LAST,
+VIR_ENUM_DECL(qemuSaveCompression)
+VIR_ENUM_IMPL(qemuSaveCompression, QEMU_SAVE_FORMAT_LAST,
"raw",
"gzip",
"bzip2",
"xz",
"lzop")
-struct qemud_save_header {
- char magic[sizeof(QEMUD_SAVE_MAGIC)-1];
+struct qemu_save_header {
+ char magic[sizeof(QEMU_SAVE_MAGIC)-1];
uint32_t version;
uint32_t xml_len;
uint32_t was_running;
};
static inline void
-bswap_header(struct qemud_save_header *hdr) {
+bswap_header(struct qemu_save_header *hdr) {
hdr->version = bswap_32(hdr->version);
hdr->xml_len = bswap_32(hdr->xml_len);
hdr->was_running = bswap_32(hdr->was_running);
/* return -errno on failure, or 0 on success */
static int
qemuDomainSaveHeader(int fd, const char *path, const char *xml,
- struct qemud_save_header *header)
+ struct qemu_save_header *header)
{
int ret = 0;
return ret;
}
-/* Given a enum qemud_save_formats compression level, return the name
+/* Given a enum qemu_save_formats compression level, return the name
* of the program to run, or NULL if no program is needed. */
static const char *
qemuCompressProgramName(int compress)
{
- return (compress == QEMUD_SAVE_FORMAT_RAW ? NULL :
- qemudSaveCompressionTypeToString(compress));
+ return (compress == QEMU_SAVE_FORMAT_RAW ? NULL :
+ qemuSaveCompressionTypeToString(compress));
}
/* Internal function to properly create or open existing files, with
unsigned int flags,
enum qemuDomainAsyncJob asyncJob)
{
- struct qemud_save_header header;
+ struct qemu_save_header header;
bool bypassSecurityDriver = false;
bool needUnlink = false;
int ret = -1;
char *xml = NULL;
memset(&header, 0, sizeof(header));
- memcpy(header.magic, QEMUD_SAVE_PARTIAL, sizeof(header.magic));
- header.version = QEMUD_SAVE_VERSION;
+ memcpy(header.magic, QEMU_SAVE_PARTIAL, sizeof(header.magic));
+ header.version = QEMU_SAVE_VERSION;
header.was_running = was_running ? 1 : 0;
header.compressed = compressed;
if ((fd = qemuOpenFile(driver, path, O_WRONLY, NULL, NULL)) < 0)
goto cleanup;
- memcpy(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic));
+ memcpy(header.magic, QEMU_SAVE_MAGIC, sizeof(header.magic));
if (safewrite(fd, &header, sizeof(header)) != sizeof(header)) {
virReportSystemError(errno, _("unable to write %s"), path);
}
/* Returns true if a compression program is available in PATH */
-static bool qemudCompressProgramAvailable(enum qemud_save_formats compress)
+static bool qemuCompressProgramAvailable(enum qemu_save_formats compress)
{
const char *prog;
char *c;
- if (compress == QEMUD_SAVE_FORMAT_RAW)
+ if (compress == QEMU_SAVE_FORMAT_RAW)
return true;
- prog = qemudSaveCompressionTypeToString(compress);
+ prog = qemuSaveCompressionTypeToString(compress);
c = virFindFileInPath(prog);
if (!c)
return false;
qemuDriverLock(driver);
if (driver->saveImageFormat == NULL)
- compressed = QEMUD_SAVE_FORMAT_RAW;
+ compressed = QEMU_SAVE_FORMAT_RAW;
else {
- compressed = qemudSaveCompressionTypeFromString(driver->saveImageFormat);
+ compressed = qemuSaveCompressionTypeFromString(driver->saveImageFormat);
if (compressed < 0) {
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("Invalid save image format specified "
"in configuration file"));
goto cleanup;
}
- if (!qemudCompressProgramAvailable(compressed)) {
+ if (!qemuCompressProgramAvailable(compressed)) {
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("Compression program for image format "
"in configuration file isn't available"));
VIR_INFO("Saving state to %s", name);
- compressed = QEMUD_SAVE_FORMAT_RAW;
+ compressed = QEMU_SAVE_FORMAT_RAW;
if ((ret = qemuDomainSaveInternal(driver, dom, vm, name, compressed,
NULL, flags)) == 0)
vm->hasManagedSave = true;
doCoreDump(struct qemud_driver *driver,
virDomainObjPtr vm,
const char *path,
- enum qemud_save_formats compress,
+ enum qemu_save_formats compress,
unsigned int dump_flags)
{
int fd = -1;
return ret;
}
-static enum qemud_save_formats
+static enum qemu_save_formats
getCompressionType(struct qemud_driver *driver)
{
- int compress = QEMUD_SAVE_FORMAT_RAW;
+ int compress = QEMU_SAVE_FORMAT_RAW;
/*
* We reuse "save" flag for "dump" here. Then, we can support the same
* format in "save" and "dump".
*/
if (driver->dumpImageFormat) {
- compress = qemudSaveCompressionTypeFromString(driver->dumpImageFormat);
+ compress = qemuSaveCompressionTypeFromString(driver->dumpImageFormat);
/* Use "raw" as the format if the specified format is not valid,
* or the compress program is not available.
*/
if (compress < 0) {
VIR_WARN("%s", _("Invalid dump image format specified in "
"configuration file, using raw"));
- return QEMUD_SAVE_FORMAT_RAW;
+ return QEMU_SAVE_FORMAT_RAW;
}
- if (!qemudCompressProgramAvailable(compress)) {
+ if (!qemuCompressProgramAvailable(compress)) {
VIR_WARN("%s", _("Compression program for dump image format "
"in configuration file isn't available, "
"using raw"));
- return QEMUD_SAVE_FORMAT_RAW;
+ return QEMU_SAVE_FORMAT_RAW;
}
}
return compress;
}
-static int qemudDomainCoreDump(virDomainPtr dom,
- const char *path,
- unsigned int flags)
+static int qemuDomainCoreDump(virDomainPtr dom,
+ const char *path,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
VIR_FREE(wdEvent);
}
-static int qemudDomainHotplugVcpus(struct qemud_driver *driver,
- virDomainObjPtr vm,
- unsigned int nvcpus)
+static int qemuDomainHotplugVcpus(struct qemud_driver *driver,
+ virDomainObjPtr vm,
+ unsigned int nvcpus)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int i, rc = 1;
goto endjob;
}
- if ((max = qemudGetMaxVCPUs(NULL, type)) < 0) {
+ if ((max = qemuGetMaxVCPUs(NULL, type)) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("could not determine max vcpus for the domain"));
goto endjob;
}
if (flags & VIR_DOMAIN_AFFECT_LIVE) {
- if (qemudDomainHotplugVcpus(driver, vm, nvcpus) < 0)
+ if (qemuDomainHotplugVcpus(driver, vm, nvcpus) < 0)
goto endjob;
}
static int
-qemudDomainPinVcpuFlags(virDomainPtr dom,
- unsigned int vcpu,
- unsigned char *cpumap,
- int maplen,
- unsigned int flags) {
+qemuDomainPinVcpuFlags(virDomainPtr dom,
+ unsigned int vcpu,
+ unsigned char *cpumap,
+ int maplen,
+ unsigned int flags) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
}
static int
-qemudDomainPinVcpu(virDomainPtr dom,
+qemuDomainPinVcpu(virDomainPtr dom,
unsigned int vcpu,
unsigned char *cpumap,
int maplen) {
- return qemudDomainPinVcpuFlags(dom, vcpu, cpumap, maplen,
- VIR_DOMAIN_AFFECT_LIVE);
+ return qemuDomainPinVcpuFlags(dom, vcpu, cpumap, maplen,
+ VIR_DOMAIN_AFFECT_LIVE);
}
static int
-qemudDomainGetVcpuPinInfo(virDomainPtr dom,
- int ncpumaps,
- unsigned char *cpumaps,
- int maplen,
- unsigned int flags) {
+qemuDomainGetVcpuPinInfo(virDomainPtr dom,
+ int ncpumaps,
+ unsigned char *cpumaps,
+ int maplen,
+ unsigned int flags) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
}
static int
-qemudDomainPinEmulator(virDomainPtr dom,
- unsigned char *cpumap,
- int maplen,
- unsigned int flags)
+qemuDomainPinEmulator(virDomainPtr dom,
+ unsigned char *cpumap,
+ int maplen,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
}
static int
-qemudDomainGetEmulatorPinInfo(virDomainPtr dom,
- unsigned char *cpumaps,
- int maplen,
- unsigned int flags)
+qemuDomainGetEmulatorPinInfo(virDomainPtr dom,
+ unsigned char *cpumaps,
+ int maplen,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
}
static int
-qemudDomainGetVcpus(virDomainPtr dom,
- virVcpuInfoPtr info,
- int maxinfo,
- unsigned char *cpumaps,
- int maplen) {
+qemuDomainGetVcpus(virDomainPtr dom,
+ virVcpuInfoPtr info,
+ int maxinfo,
+ unsigned char *cpumaps,
+ int maplen) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
int i, v, maxcpu, hostcpus;
info[i].state = VIR_VCPU_RUNNING;
if (priv->vcpupids != NULL &&
- qemudGetProcessInfo(&(info[i].cpuTime),
- &(info[i].cpu),
- NULL,
- vm->pid,
- priv->vcpupids[i]) < 0) {
+ qemuGetProcessInfo(&(info[i].cpuTime),
+ &(info[i].cpu),
+ NULL,
+ vm->pid,
+ priv->vcpupids[i]) < 0) {
virReportSystemError(errno, "%s",
_("cannot get vCPU placement & pCPU time"));
goto cleanup;
static int
-qemudDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
+qemuDomainGetVcpusFlags(virDomainPtr dom, unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
}
static int
-qemudDomainGetMaxVcpus(virDomainPtr dom)
+qemuDomainGetMaxVcpus(virDomainPtr dom)
{
- return qemudDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
- VIR_DOMAIN_VCPU_MAXIMUM));
+ return qemuDomainGetVcpusFlags(dom, (VIR_DOMAIN_AFFECT_LIVE |
+ VIR_DOMAIN_VCPU_MAXIMUM));
}
-static int qemudDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
+static int qemuDomainGetSecurityLabel(virDomainPtr dom, virSecurityLabelPtr seclabel)
{
struct qemud_driver *driver = (struct qemud_driver *)dom->conn->privateData;
virDomainObjPtr vm;
}
/*
- * Check the comment in qemudDomainGetSecurityLabel function.
+ * Check the comment in qemuDomainGetSecurityLabel function.
*/
if (!virDomainObjIsActive(vm)) {
/* No seclabels */
qemuDriverUnlock(driver);
return ret;
}
-static int qemudNodeGetSecurityModel(virConnectPtr conn,
- virSecurityModelPtr secmodel)
+static int qemuNodeGetSecurityModel(virConnectPtr conn,
+ virSecurityModelPtr secmodel)
{
struct qemud_driver *driver = (struct qemud_driver *)conn->privateData;
char *p;
qemuDomainSaveImageOpen(struct qemud_driver *driver,
const char *path,
virDomainDefPtr *ret_def,
- struct qemud_save_header *ret_header,
+ struct qemu_save_header *ret_header,
bool bypass_cache,
virFileWrapperFdPtr *wrapperFd,
const char *xmlin, int state, bool edit,
bool unlink_corrupt)
{
int fd = -1;
- struct qemud_save_header header;
+ struct qemu_save_header header;
char *xml = NULL;
virDomainDefPtr def = NULL;
int oflags = edit ? O_RDWR : O_RDONLY;
goto error;
}
- if (memcmp(header.magic, QEMUD_SAVE_MAGIC, sizeof(header.magic)) != 0) {
+ if (memcmp(header.magic, QEMU_SAVE_MAGIC, sizeof(header.magic)) != 0) {
const char *msg = _("image magic is incorrect");
- if (memcmp(header.magic, QEMUD_SAVE_PARTIAL,
+ if (memcmp(header.magic, QEMU_SAVE_PARTIAL,
sizeof(header.magic)) == 0) {
msg = _("save image is incomplete");
if (unlink_corrupt) {
goto error;
}
- if (header.version > QEMUD_SAVE_VERSION) {
+ if (header.version > QEMU_SAVE_VERSION) {
/* convert endianess and try again */
bswap_header(&header);
}
- if (header.version > QEMUD_SAVE_VERSION) {
+ if (header.version > QEMU_SAVE_VERSION) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("image version is not supported (%d > %d)"),
- header.version, QEMUD_SAVE_VERSION);
+ header.version, QEMU_SAVE_VERSION);
goto error;
}
struct qemud_driver *driver,
virDomainObjPtr vm,
int *fd,
- const struct qemud_save_header *header,
+ const struct qemu_save_header *header,
const char *path,
bool start_paused)
{
virCommandPtr cmd = NULL;
if (header->version == 2) {
- const char *prog = qemudSaveCompressionTypeToString(header->compressed);
+ const char *prog = qemuSaveCompressionTypeToString(header->compressed);
if (prog == NULL) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("Invalid compressed save format %d"),
goto out;
}
- if (header->compressed != QEMUD_SAVE_FORMAT_RAW) {
+ if (header->compressed != QEMU_SAVE_FORMAT_RAW) {
cmd = virCommandNewArgList(prog, "-dc", NULL);
intermediatefd = *fd;
*fd = -1;
virDomainObjPtr vm = NULL;
int fd = -1;
int ret = -1;
- struct qemud_save_header header;
+ struct qemu_save_header header;
virFileWrapperFdPtr wrapperFd = NULL;
int state = -1;
char *ret = NULL;
virDomainDefPtr def = NULL;
int fd = -1;
- struct qemud_save_header header;
+ struct qemu_save_header header;
/* We only take subset of virDomainDefFormat flags. */
virCheckFlags(VIR_DOMAIN_XML_SECURE, NULL);
int ret = -1;
virDomainDefPtr def = NULL;
int fd = -1;
- struct qemud_save_header header;
+ struct qemu_save_header header;
char *xml = NULL;
size_t len;
int state = -1;
virDomainDefPtr def = NULL;
int fd = -1;
int ret = -1;
- struct qemud_save_header header;
+ struct qemu_save_header header;
virFileWrapperFdPtr wrapperFd = NULL;
fd = qemuDomainSaveImageOpen(driver, path, &def, &header,
}
-static int qemudListDefinedDomains(virConnectPtr conn,
- char **const names, int nnames) {
+static int qemuListDefinedDomains(virConnectPtr conn,
+ char **const names, int nnames) {
struct qemud_driver *driver = conn->privateData;
int n;
return n;
}
-static int qemudNumDefinedDomains(virConnectPtr conn) {
+static int qemuNumDefinedDomains(virConnectPtr conn) {
struct qemud_driver *driver = conn->privateData;
int n;
return qemuDomainStartWithFlags(dom, 0);
}
-static virDomainPtr qemudDomainDefine(virConnectPtr conn, const char *xml) {
+static virDomainPtr qemuDomainDefine(virConnectPtr conn, const char *xml) {
struct qemud_driver *driver = conn->privateData;
virDomainDefPtr def;
virDomainDefPtr def_backup = NULL;
}
static int
-qemudDomainUndefine(virDomainPtr dom)
+qemuDomainUndefine(virDomainPtr dom)
{
return qemuDomainUndefineFlags(dom, 0);
}
VIR_DOMAIN_AFFECT_LIVE);
}
-static int qemudDomainGetAutostart(virDomainPtr dom,
- int *autostart) {
+static int qemuDomainGetAutostart(virDomainPtr dom,
+ int *autostart) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
return ret;
}
-static int qemudDomainSetAutostart(virDomainPtr dom,
- int autostart) {
+static int qemuDomainSetAutostart(virDomainPtr dom,
+ int autostart) {
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
char *configFile = NULL, *autostartLink = NULL;
#ifdef __linux__
static int
-qemudDomainInterfaceStats(virDomainPtr dom,
- const char *path,
- struct _virDomainInterfaceStats *stats)
+qemuDomainInterfaceStats(virDomainPtr dom,
+ const char *path,
+ struct _virDomainInterfaceStats *stats)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
}
#else
static int
-qemudDomainInterfaceStats(virDomainPtr dom,
- const char *path ATTRIBUTE_UNUSED,
- struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
+qemuDomainInterfaceStats(virDomainPtr dom,
+ const char *path ATTRIBUTE_UNUSED,
+ struct _virDomainInterfaceStats *stats ATTRIBUTE_UNUSED)
{
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("interface stats not implemented on this platform"));
}
static int
-qemudDomainMemoryStats(virDomainPtr dom,
- struct _virDomainMemoryStat *stats,
- unsigned int nr_stats,
- unsigned int flags)
+qemuDomainMemoryStats(virDomainPtr dom,
+ struct _virDomainMemoryStat *stats,
+ unsigned int nr_stats,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
if (ret >= 0 && ret < nr_stats) {
long rss;
- if (qemudGetProcessInfo(NULL, NULL, &rss, vm->pid, 0) < 0) {
+ if (qemuGetProcessInfo(NULL, NULL, &rss, vm->pid, 0) < 0) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("cannot get RSS for domain"));
} else {
}
static int
-qemudDomainBlockPeek(virDomainPtr dom,
- const char *path,
- unsigned long long offset, size_t size,
- void *buffer,
- unsigned int flags)
+qemuDomainBlockPeek(virDomainPtr dom,
+ const char *path,
+ unsigned long long offset, size_t size,
+ void *buffer,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
}
static int
-qemudDomainMemoryPeek(virDomainPtr dom,
- unsigned long long offset, size_t size,
- void *buffer,
- unsigned int flags)
+qemuDomainMemoryPeek(virDomainPtr dom,
+ unsigned long long offset, size_t size,
+ void *buffer,
+ unsigned int flags)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
* sets up the corresponding virStream to handle the incoming data.
*/
static int
-qemudDomainMigratePrepareTunnel(virConnectPtr dconn,
- virStreamPtr st,
- unsigned long flags,
- const char *dname,
- unsigned long resource ATTRIBUTE_UNUSED,
- const char *dom_xml)
+qemuDomainMigratePrepareTunnel(virConnectPtr dconn,
+ virStreamPtr st,
+ unsigned long flags,
+ const char *dname,
+ unsigned long resource ATTRIBUTE_UNUSED,
+ const char *dom_xml)
{
struct qemud_driver *driver = dconn->privateData;
int ret = -1;
* This starts an empty VM listening on a TCP port.
*/
static int ATTRIBUTE_NONNULL(5)
-qemudDomainMigratePrepare2(virConnectPtr dconn,
- char **cookie ATTRIBUTE_UNUSED,
- int *cookielen ATTRIBUTE_UNUSED,
- const char *uri_in,
- char **uri_out,
- unsigned long flags,
- const char *dname,
- unsigned long resource ATTRIBUTE_UNUSED,
- const char *dom_xml)
+qemuDomainMigratePrepare2(virConnectPtr dconn,
+ char **cookie ATTRIBUTE_UNUSED,
+ int *cookielen ATTRIBUTE_UNUSED,
+ const char *uri_in,
+ char **uri_out,
+ unsigned long flags,
+ const char *dname,
+ unsigned long resource ATTRIBUTE_UNUSED,
+ const char *dom_xml)
{
struct qemud_driver *driver = dconn->privateData;
int ret = -1;
/* Perform is the second step, and it runs on the source host. */
static int
-qemudDomainMigratePerform(virDomainPtr dom,
- const char *cookie,
- int cookielen,
- const char *uri,
- unsigned long flags,
- const char *dname,
- unsigned long resource)
+qemuDomainMigratePerform(virDomainPtr dom,
+ const char *cookie,
+ int cookielen,
+ const char *uri,
+ unsigned long flags,
+ const char *dname,
+ unsigned long resource)
{
struct qemud_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
/* Finish is the third and final step, and it runs on the destination host. */
static virDomainPtr
-qemudDomainMigrateFinish2(virConnectPtr dconn,
- const char *dname,
- const char *cookie ATTRIBUTE_UNUSED,
- int cookielen ATTRIBUTE_UNUSED,
- const char *uri ATTRIBUTE_UNUSED,
- unsigned long flags,
- int retcode)
+qemuDomainMigrateFinish2(virConnectPtr dconn,
+ const char *dname,
+ const char *cookie ATTRIBUTE_UNUSED,
+ int cookielen ATTRIBUTE_UNUSED,
+ const char *uri ATTRIBUTE_UNUSED,
+ unsigned long flags,
+ int retcode)
{
struct qemud_driver *driver = dconn->privateData;
virDomainObjPtr vm;
static int
-qemudNodeDeviceGetPciInfo(virNodeDevicePtr dev,
- unsigned *domain,
- unsigned *bus,
- unsigned *slot,
- unsigned *function)
+qemuNodeDeviceGetPciInfo(virNodeDevicePtr dev,
+ unsigned *domain,
+ unsigned *bus,
+ unsigned *slot,
+ unsigned *function)
{
virNodeDeviceDefPtr def = NULL;
virNodeDevCapsDefPtr cap;
}
static int
-qemudNodeDeviceDettach(virNodeDevicePtr dev)
+qemuNodeDeviceDettach(virNodeDevicePtr dev)
{
struct qemud_driver *driver = dev->conn->privateData;
pciDevice *pci;
int ret = -1;
bool in_inactive_list = false;
- if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = pciGetDevice(domain, bus, slot, function);
}
static int
-qemudNodeDeviceReAttach(virNodeDevicePtr dev)
+qemuNodeDeviceReAttach(virNodeDevicePtr dev)
{
struct qemud_driver *driver = dev->conn->privateData;
pciDevice *pci;
unsigned domain, bus, slot, function;
int ret = -1;
- if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = pciGetDevice(domain, bus, slot, function);
}
static int
-qemudNodeDeviceReset(virNodeDevicePtr dev)
+qemuNodeDeviceReset(virNodeDevicePtr dev)
{
struct qemud_driver *driver = dev->conn->privateData;
pciDevice *pci;
unsigned domain, bus, slot, function;
int ret = -1;
- if (qemudNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
+ if (qemuNodeDeviceGetPciInfo(dev, &domain, &bus, &slot, &function) < 0)
return -1;
pci = pciGetDevice(domain, bus, slot, function);
goto endjob;
if ((ret = qemuDomainSaveMemory(driver, vm, snap->def->file,
- xml, QEMUD_SAVE_FORMAT_RAW,
+ xml, QEMU_SAVE_FORMAT_RAW,
resume, 0,
QEMU_ASYNC_JOB_SNAPSHOT)) < 0)
goto endjob;
static virDriver qemuDriver = {
.no = VIR_DRV_QEMU,
.name = QEMU_DRIVER_NAME,
- .open = qemudOpen, /* 0.2.0 */
- .close = qemudClose, /* 0.2.0 */
- .supports_feature = qemudSupportsFeature, /* 0.5.0 */
- .type = qemudGetType, /* 0.2.0 */
- .version = qemudGetVersion, /* 0.2.0 */
+ .open = qemuOpen, /* 0.2.0 */
+ .close = qemuClose, /* 0.2.0 */
+ .supports_feature = qemuSupportsFeature, /* 0.5.0 */
+ .type = qemuGetType, /* 0.2.0 */
+ .version = qemuGetVersion, /* 0.2.0 */
.getHostname = virGetHostname, /* 0.3.3 */
.getSysinfo = qemuGetSysinfo, /* 0.8.8 */
- .getMaxVcpus = qemudGetMaxVCPUs, /* 0.2.1 */
+ .getMaxVcpus = qemuGetMaxVCPUs, /* 0.2.1 */
.nodeGetInfo = nodeGetInfo, /* 0.2.0 */
- .getCapabilities = qemudGetCapabilities, /* 0.2.1 */
- .listDomains = qemudListDomains, /* 0.2.0 */
- .numOfDomains = qemudNumDomains, /* 0.2.0 */
+ .getCapabilities = qemuGetCapabilities, /* 0.2.1 */
+ .listDomains = qemuListDomains, /* 0.2.0 */
+ .numOfDomains = qemuNumDomains, /* 0.2.0 */
.listAllDomains = qemuListAllDomains, /* 0.9.13 */
- .domainCreateXML = qemudDomainCreate, /* 0.2.0 */
- .domainLookupByID = qemudDomainLookupByID, /* 0.2.0 */
- .domainLookupByUUID = qemudDomainLookupByUUID, /* 0.2.0 */
- .domainLookupByName = qemudDomainLookupByName, /* 0.2.0 */
- .domainSuspend = qemudDomainSuspend, /* 0.2.0 */
- .domainResume = qemudDomainResume, /* 0.2.0 */
+ .domainCreateXML = qemuDomainCreate, /* 0.2.0 */
+ .domainLookupByID = qemuDomainLookupByID, /* 0.2.0 */
+ .domainLookupByUUID = qemuDomainLookupByUUID, /* 0.2.0 */
+ .domainLookupByName = qemuDomainLookupByName, /* 0.2.0 */
+ .domainSuspend = qemuDomainSuspend, /* 0.2.0 */
+ .domainResume = qemuDomainResume, /* 0.2.0 */
.domainShutdown = qemuDomainShutdown, /* 0.2.0 */
.domainShutdownFlags = qemuDomainShutdownFlags, /* 0.9.10 */
.domainReboot = qemuDomainReboot, /* 0.9.3 */
.domainReset = qemuDomainReset, /* 0.9.7 */
.domainDestroy = qemuDomainDestroy, /* 0.2.0 */
.domainDestroyFlags = qemuDomainDestroyFlags, /* 0.9.4 */
- .domainGetOSType = qemudDomainGetOSType, /* 0.2.2 */
+ .domainGetOSType = qemuDomainGetOSType, /* 0.2.2 */
.domainGetMaxMemory = qemuDomainGetMaxMemory, /* 0.4.2 */
- .domainSetMaxMemory = qemudDomainSetMaxMemory, /* 0.4.2 */
- .domainSetMemory = qemudDomainSetMemory, /* 0.4.2 */
- .domainSetMemoryFlags = qemudDomainSetMemoryFlags, /* 0.9.0 */
+ .domainSetMaxMemory = qemuDomainSetMaxMemory, /* 0.4.2 */
+ .domainSetMemory = qemuDomainSetMemory, /* 0.4.2 */
+ .domainSetMemoryFlags = qemuDomainSetMemoryFlags, /* 0.9.0 */
.domainSetMemoryParameters = qemuDomainSetMemoryParameters, /* 0.8.5 */
.domainGetMemoryParameters = qemuDomainGetMemoryParameters, /* 0.8.5 */
.domainSetBlkioParameters = qemuDomainSetBlkioParameters, /* 0.9.0 */
.domainGetBlkioParameters = qemuDomainGetBlkioParameters, /* 0.9.0 */
- .domainGetInfo = qemudDomainGetInfo, /* 0.2.0 */
+ .domainGetInfo = qemuDomainGetInfo, /* 0.2.0 */
.domainGetState = qemuDomainGetState, /* 0.9.2 */
.domainGetControlInfo = qemuDomainGetControlInfo, /* 0.9.3 */
.domainSave = qemuDomainSave, /* 0.2.0 */
.domainRestoreFlags = qemuDomainRestoreFlags, /* 0.9.4 */
.domainSaveImageGetXMLDesc = qemuDomainSaveImageGetXMLDesc, /* 0.9.4 */
.domainSaveImageDefineXML = qemuDomainSaveImageDefineXML, /* 0.9.4 */
- .domainCoreDump = qemudDomainCoreDump, /* 0.7.0 */
+ .domainCoreDump = qemuDomainCoreDump, /* 0.7.0 */
.domainScreenshot = qemuDomainScreenshot, /* 0.9.2 */
.domainSetVcpus = qemuDomainSetVcpus, /* 0.4.4 */
.domainSetVcpusFlags = qemuDomainSetVcpusFlags, /* 0.8.5 */
- .domainGetVcpusFlags = qemudDomainGetVcpusFlags, /* 0.8.5 */
- .domainPinVcpu = qemudDomainPinVcpu, /* 0.4.4 */
- .domainPinVcpuFlags = qemudDomainPinVcpuFlags, /* 0.9.3 */
- .domainGetVcpuPinInfo = qemudDomainGetVcpuPinInfo, /* 0.9.3 */
- .domainPinEmulator = qemudDomainPinEmulator, /* 0.10.0 */
- .domainGetEmulatorPinInfo = qemudDomainGetEmulatorPinInfo, /* 0.10.0 */
- .domainGetVcpus = qemudDomainGetVcpus, /* 0.4.4 */
- .domainGetMaxVcpus = qemudDomainGetMaxVcpus, /* 0.4.4 */
- .domainGetSecurityLabel = qemudDomainGetSecurityLabel, /* 0.6.1 */
+ .domainGetVcpusFlags = qemuDomainGetVcpusFlags, /* 0.8.5 */
+ .domainPinVcpu = qemuDomainPinVcpu, /* 0.4.4 */
+ .domainPinVcpuFlags = qemuDomainPinVcpuFlags, /* 0.9.3 */
+ .domainGetVcpuPinInfo = qemuDomainGetVcpuPinInfo, /* 0.9.3 */
+ .domainPinEmulator = qemuDomainPinEmulator, /* 0.10.0 */
+ .domainGetEmulatorPinInfo = qemuDomainGetEmulatorPinInfo, /* 0.10.0 */
+ .domainGetVcpus = qemuDomainGetVcpus, /* 0.4.4 */
+ .domainGetMaxVcpus = qemuDomainGetMaxVcpus, /* 0.4.4 */
+ .domainGetSecurityLabel = qemuDomainGetSecurityLabel, /* 0.6.1 */
.domainGetSecurityLabelList = qemuDomainGetSecurityLabelList, /* 0.10.0 */
- .nodeGetSecurityModel = qemudNodeGetSecurityModel, /* 0.6.1 */
+ .nodeGetSecurityModel = qemuNodeGetSecurityModel, /* 0.6.1 */
.domainGetXMLDesc = qemuDomainGetXMLDesc, /* 0.2.0 */
.domainXMLFromNative = qemuDomainXMLFromNative, /* 0.6.4 */
.domainXMLToNative = qemuDomainXMLToNative, /* 0.6.4 */
- .listDefinedDomains = qemudListDefinedDomains, /* 0.2.0 */
- .numOfDefinedDomains = qemudNumDefinedDomains, /* 0.2.0 */
+ .listDefinedDomains = qemuListDefinedDomains, /* 0.2.0 */
+ .numOfDefinedDomains = qemuNumDefinedDomains, /* 0.2.0 */
.domainCreate = qemuDomainStart, /* 0.2.0 */
.domainCreateWithFlags = qemuDomainStartWithFlags, /* 0.8.2 */
- .domainDefineXML = qemudDomainDefine, /* 0.2.0 */
- .domainUndefine = qemudDomainUndefine, /* 0.2.0 */
+ .domainDefineXML = qemuDomainDefine, /* 0.2.0 */
+ .domainUndefine = qemuDomainUndefine, /* 0.2.0 */
.domainUndefineFlags = qemuDomainUndefineFlags, /* 0.9.4 */
.domainAttachDevice = qemuDomainAttachDevice, /* 0.4.1 */
.domainAttachDeviceFlags = qemuDomainAttachDeviceFlags, /* 0.7.7 */
.domainDetachDevice = qemuDomainDetachDevice, /* 0.5.0 */
.domainDetachDeviceFlags = qemuDomainDetachDeviceFlags, /* 0.7.7 */
.domainUpdateDeviceFlags = qemuDomainUpdateDeviceFlags, /* 0.8.0 */
- .domainGetAutostart = qemudDomainGetAutostart, /* 0.2.1 */
- .domainSetAutostart = qemudDomainSetAutostart, /* 0.2.1 */
+ .domainGetAutostart = qemuDomainGetAutostart, /* 0.2.1 */
+ .domainSetAutostart = qemuDomainSetAutostart, /* 0.2.1 */
.domainGetSchedulerType = qemuGetSchedulerType, /* 0.7.0 */
.domainGetSchedulerParameters = qemuGetSchedulerParameters, /* 0.7.0 */
.domainGetSchedulerParametersFlags = qemuGetSchedulerParametersFlags, /* 0.9.2 */
.domainSetSchedulerParameters = qemuSetSchedulerParameters, /* 0.7.0 */
.domainSetSchedulerParametersFlags = qemuSetSchedulerParametersFlags, /* 0.9.2 */
- .domainMigratePerform = qemudDomainMigratePerform, /* 0.5.0 */
+ .domainMigratePerform = qemuDomainMigratePerform, /* 0.5.0 */
.domainBlockResize = qemuDomainBlockResize, /* 0.9.8 */
.domainBlockStats = qemuDomainBlockStats, /* 0.4.1 */
.domainBlockStatsFlags = qemuDomainBlockStatsFlags, /* 0.9.5 */
- .domainInterfaceStats = qemudDomainInterfaceStats, /* 0.4.1 */
- .domainMemoryStats = qemudDomainMemoryStats, /* 0.7.5 */
- .domainBlockPeek = qemudDomainBlockPeek, /* 0.4.4 */
- .domainMemoryPeek = qemudDomainMemoryPeek, /* 0.4.4 */
+ .domainInterfaceStats = qemuDomainInterfaceStats, /* 0.4.1 */
+ .domainMemoryStats = qemuDomainMemoryStats, /* 0.7.5 */
+ .domainBlockPeek = qemuDomainBlockPeek, /* 0.4.4 */
+ .domainMemoryPeek = qemuDomainMemoryPeek, /* 0.4.4 */
.domainGetBlockInfo = qemuDomainGetBlockInfo, /* 0.8.1 */
.nodeGetCPUStats = nodeGetCPUStats, /* 0.9.3 */
.nodeGetMemoryStats = nodeGetMemoryStats, /* 0.9.3 */
.nodeGetFreeMemory = nodeGetFreeMemory, /* 0.4.4 */
.domainEventRegister = qemuDomainEventRegister, /* 0.5.0 */
.domainEventDeregister = qemuDomainEventDeregister, /* 0.5.0 */
- .domainMigratePrepare2 = qemudDomainMigratePrepare2, /* 0.5.0 */
- .domainMigrateFinish2 = qemudDomainMigrateFinish2, /* 0.5.0 */
- .nodeDeviceDettach = qemudNodeDeviceDettach, /* 0.6.1 */
- .nodeDeviceReAttach = qemudNodeDeviceReAttach, /* 0.6.1 */
- .nodeDeviceReset = qemudNodeDeviceReset, /* 0.6.1 */
- .domainMigratePrepareTunnel = qemudDomainMigratePrepareTunnel, /* 0.7.2 */
+ .domainMigratePrepare2 = qemuDomainMigratePrepare2, /* 0.5.0 */
+ .domainMigrateFinish2 = qemuDomainMigrateFinish2, /* 0.5.0 */
+ .nodeDeviceDettach = qemuNodeDeviceDettach, /* 0.6.1 */
+ .nodeDeviceReAttach = qemuNodeDeviceReAttach, /* 0.6.1 */
+ .nodeDeviceReset = qemuNodeDeviceReset, /* 0.6.1 */
+ .domainMigratePrepareTunnel = qemuDomainMigratePrepareTunnel, /* 0.7.2 */
.isEncrypted = qemuIsEncrypted, /* 0.7.3 */
.isSecure = qemuIsSecure, /* 0.7.3 */
.domainIsActive = qemuDomainIsActive, /* 0.7.3 */
static virStateDriver qemuStateDriver = {
.name = "QEMU",
- .initialize = qemudStartup,
- .cleanup = qemudShutdown,
- .reload = qemudReload,
- .active = qemudActive,
+ .initialize = qemuStartup,
+ .cleanup = qemuShutdown,
+ .reload = qemuReload,
+ .active = qemuActive,
};
int qemuRegister(void) {
projects / libvirt.git / commitdiff