External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-22 11:22:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Wrap text mode monitor APIs, pass qemuMonitorPtr directly to APIs

Browse Source 
Change the QEMU driver to not directly invoke the text mode monitor
APIs. Instead add a generic wrapper layer, which will eventually
invoke either the text or JSON protocol code as needed. Pass an
qemuMonitorPtr object into the monitor APIs instead of virDomainObjPtr
to complete the de-coupling of the monitor impl from virDomainObj
data structures

* src/qemu/qemu_conf.h: Remove qemuDomainObjPrivate definition
* src/qemu/qemu_driver.c: Add qemuDomainObjPrivate definition.
  Pass qemuMonitorPtr into all monitor APIs instead of the
  virDomainObjPtr instance.
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Add thin
  wrappers for all qemuMonitorXXX command APIs, calling into
  qemu_monitor_text.c/h
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
  Rename qemuMonitor -> qemuMonitorText & update to accept
  qemuMonitorPtr instead of virDomainObjPtr
This commit is contained in:
Daniel P. Berrange 2009-10-09 21:13:06 +01:00
parent 4604c18f0b
commit 41d8968d43
6 changed files with 829 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/qemu/qemu_conf.h
View File

@ -37,7 +37,6 @@
#include "security/security_driver.h"
#include "cgroup.h"
#include "pci.h"
#include "qemu_monitor.h"
#define qemudDebug(fmt, ...) do {} while(0)
@ -134,16 +133,6 @@ struct qemud_driver {
pciDeviceList *activePciHostdevs;
};
/* XXX temporarily exposed.
* This will be moved back into qemu_driver.c, once the
* qemu_monitor* code is refactored a little more
*/
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
struct _qemuDomainObjPrivate {
qemuMonitorPtr mon;
};
/* Port numbers used for KVM migration. */
#define QEMUD_MIGRATION_FIRST_PORT 49152

132
src/qemu/qemu_driver.c
View File

@ -78,6 +78,12 @@
#define VIR_FROM_THIS VIR_FROM_QEMU
typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
struct _qemuDomainObjPrivate {
qemuMonitorPtr mon;
};
static int qemudShutdown(void);
static void qemuDriverLock(struct qemud_driver *driver)
@ -1117,6 +1123,7 @@ qemuDetectVcpuPIDs(virConnectPtr conn,
virDomainObjPtr vm) {
pid_t *cpupids = NULL;
int ncpupids;
qemuDomainObjPrivatePtr priv = vm->privateData;
if (vm->def->virtType != VIR_DOMAIN_VIRT_KVM) {
vm->nvcpupids = 1;
@ -1130,7 +1137,7 @@ qemuDetectVcpuPIDs(virConnectPtr conn,
/* What follows is now all KVM specific */
if ((ncpupids = qemuMonitorGetCPUInfo(vm, &cpupids)) < 0)
if ((ncpupids = qemuMonitorGetCPUInfo(priv->mon, &cpupids)) < 0)
return -1;
/* Treat failure to get VCPU<->PID mapping as non-fatal */
@ -1158,6 +1165,7 @@ qemudInitCpus(virConnectPtr conn,
cpu_set_t mask;
int i, hostcpus, maxcpu = QEMUD_CPUMASK_LEN;
virNodeInfo nodeinfo;
qemuDomainObjPrivatePtr priv = vm->privateData;
if (nodeGetInfo(conn, &nodeinfo) < 0)
return -1;
@ -1190,7 +1198,7 @@ qemudInitCpus(virConnectPtr conn,
if (migrateFrom == NULL) {
/* Allow the CPUS to start executing */
if (qemuMonitorStartCPUs(conn, vm) < 0) {
if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
if (virGetLastError() == NULL)
qemudReportError(conn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("resume operation failed"));
@ -1206,12 +1214,13 @@ static int
qemuInitPasswords(struct qemud_driver *driver,
virDomainObjPtr vm) {
int ret = 0;
qemuDomainObjPrivatePtr priv = vm->privateData;
if ((vm->def->ngraphics == 1) &&
vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC &&
(vm->def->graphics[0]->data.vnc.passwd || driver->vncPassword)) {
ret = qemuMonitorSetVNCPassword(vm,
ret = qemuMonitorSetVNCPassword(priv->mon,
vm->def->graphics[0]->data.vnc.passwd ?
vm->def->graphics[0]->data.vnc.passwd :
driver->vncPassword);
@ -2081,7 +2090,7 @@ static int qemudStartVMDaemon(virConnectPtr conn,
(qemuDetectVcpuPIDs(conn, vm) < 0) ||
(qemudInitCpus(conn, vm, migrateFrom) < 0) ||
(qemuInitPasswords(driver, vm) < 0) ||
(qemuMonitorSetBalloon(vm, vm->def->memory) < 0) ||
(qemuMonitorSetBalloon(((qemuDomainObjPrivatePtr)vm->privateData)->mon, vm->def->memory) < 0) ||
(virDomainSaveStatus(conn, driver->stateDir, vm) < 0)) {
qemudShutdownVMDaemon(conn, driver, vm);
ret = -1;
@ -2611,7 +2620,8 @@ static int qemudDomainSuspend(virDomainPtr dom) {
goto cleanup;
}
if (vm->state != VIR_DOMAIN_PAUSED) {
if (qemuMonitorStopCPUs(vm) < 0)
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuMonitorStopCPUs(priv->mon) < 0)
goto cleanup;
vm->state = VIR_DOMAIN_PAUSED;
event = virDomainEventNewFromObj(vm,
@ -2655,7 +2665,8 @@ static int qemudDomainResume(virDomainPtr dom) {
goto cleanup;
}
if (vm->state == VIR_DOMAIN_PAUSED) {
if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
if (virGetLastError() == NULL)
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
"%s", _("resume operation failed"));
@ -2703,7 +2714,8 @@ static int qemudDomainShutdown(virDomainPtr dom) {
goto cleanup;
}
if (qemuMonitorSystemPowerdown(vm) < 0)
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuMonitorSystemPowerdown(priv->mon) < 0)
goto cleanup;
ret = 0;
@ -2864,7 +2876,8 @@ static int qemudDomainSetMemory(virDomainPtr dom, unsigned long newmem) {
}
if (virDomainObjIsActive(vm)) {
int r = qemuMonitorSetBalloon(vm, newmem);
qemuDomainObjPrivatePtr priv = vm->privateData;
int r = qemuMonitorSetBalloon(priv->mon, newmem);
if (r < 0)
goto cleanup;
@ -2918,7 +2931,8 @@ static int qemudDomainGetInfo(virDomainPtr dom,
info->maxMem = vm->def->maxmem;
if (virDomainObjIsActive(vm)) {
err = qemuMonitorGetBalloonInfo(vm, &balloon);
qemuDomainObjPrivatePtr priv = vm->privateData;
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
if (err < 0)
goto cleanup;
@ -3025,8 +3039,9 @@ static int qemudDomainSave(virDomainPtr dom,
/* Pause */
if (vm->state == VIR_DOMAIN_RUNNING) {
qemuDomainObjPrivatePtr priv = vm->privateData;
header.was_running = 1;
if (qemuMonitorStopCPUs(vm) < 0)
if (qemuMonitorStopCPUs(priv->mon) < 0)
goto cleanup;
vm->state = VIR_DOMAIN_PAUSED;
}
@ -3069,15 +3084,17 @@ static int qemudDomainSave(virDomainPtr dom,
if (header.compressed == QEMUD_SAVE_FORMAT_RAW) {
const char *args[] = { "cat", NULL };
ret = qemuMonitorMigrateToCommand(vm, 0, args, path);
qemuDomainObjPrivatePtr priv = vm->privateData;
ret = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
} else {
const char *prog = qemudSaveCompressionTypeToString(header.compressed);
qemuDomainObjPrivatePtr priv = vm->privateData;
const char *args[] = {
prog,
"-c",
NULL
};
ret = qemuMonitorMigrateToCommand(vm, 0, args, path);
ret = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
}
if (ret < 0)
@ -3144,14 +3161,16 @@ static int qemudDomainCoreDump(virDomainPtr dom,
the stop command is issued. */
resume = (vm->state == VIR_DOMAIN_RUNNING);
qemuDomainObjPrivatePtr priv = vm->privateData;
/* Pause domain for non-live dump */
if (vm->state == VIR_DOMAIN_RUNNING) {
if (qemuMonitorStopCPUs(vm) < 0)
if (qemuMonitorStopCPUs(priv->mon) < 0)
goto cleanup;
paused = 1;
}
ret = qemuMonitorMigrateToCommand(vm, 0, args, path);
ret = qemuMonitorMigrateToCommand(priv->mon, 0, args, path);
paused = 1;
cleanup:
@ -3159,7 +3178,7 @@ cleanup:
will support synchronous operations so we always get here after
the migration is complete. */
if (resume && paused) {
if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
if (virGetLastError() == NULL)
qemudReportError(dom->conn, dom, NULL, VIR_ERR_OPERATION_FAILED,
"%s", _("resuming after dump failed"));
@ -3648,7 +3667,8 @@ static int qemudDomainRestore(virConnectPtr conn,
/* If it was running before, resume it now. */
if (header.was_running) {
if (qemuMonitorStartCPUs(conn, vm) < 0) {
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuMonitorStartCPUs(priv->mon, conn) < 0) {
if (virGetLastError() == NULL)
qemudReportError(conn, NULL, NULL, VIR_ERR_OPERATION_FAILED,
"%s", _("failed to resume domain"));
@ -3695,7 +3715,8 @@ static char *qemudDomainDumpXML(virDomainPtr dom,
/* Refresh current memory based on balloon info */
if (virDomainObjIsActive(vm)) {
err = qemuMonitorGetBalloonInfo(vm, &balloon);
qemuDomainObjPrivatePtr priv = vm->privateData;
err = qemuMonitorGetBalloonInfo(priv->mon, &balloon);
if (err < 0)
goto cleanup;
if (err > 0)
@ -4239,10 +4260,11 @@ static int qemudDomainChangeEjectableMedia(virConnectPtr conn,
}
}
qemuDomainObjPrivatePtr priv = vm->privateData;
if (newdisk->src) {
ret = qemuMonitorChangeMedia(vm, devname, newdisk->src);
ret = qemuMonitorChangeMedia(priv->mon, devname, newdisk->src);
} else {
ret = qemuMonitorEjectMedia(vm, devname);
ret = qemuMonitorEjectMedia(priv->mon, devname);
}
if (ret == 0) {
@ -4262,6 +4284,7 @@ static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
{
int i;
const char* type = virDomainDiskBusTypeToString(dev->data.disk->bus);
qemuDomainObjPrivatePtr priv = vm->privateData;
for (i = 0 ; i < vm->def->ndisks ; i++) {
if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
@ -4276,7 +4299,7 @@ static int qemudDomainAttachPciDiskDevice(virConnectPtr conn,
return -1;
}
if (qemuMonitorAddPCIDisk(vm,
if (qemuMonitorAddPCIDisk(priv->mon,
dev->data.disk->src,
type,
&dev->data.disk->pci_addr.domain,
@ -4293,6 +4316,7 @@ static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
int i;
for (i = 0 ; i < vm->def->ndisks ; i++) {
@ -4314,7 +4338,7 @@ static int qemudDomainAttachUsbMassstorageDevice(virConnectPtr conn,
return -1;
}
if (qemuMonitorAddUSBDisk(vm, dev->data.disk->src) < 0)
if (qemuMonitorAddUSBDisk(priv->mon, dev->data.disk->src) < 0)
return -1;
virDomainDiskInsertPreAlloced(vm->def, dev->data.disk);
@ -4329,6 +4353,7 @@ static int qemudDomainAttachNetDevice(virConnectPtr conn,
unsigned int qemuCmdFlags)
{
virDomainNetDefPtr net = dev->data.net;
qemuDomainObjPrivatePtr priv = vm->privateData;
char *tapfd_name = NULL;
int i, tapfd = -1;
char *nicstr = NULL;
@ -4374,7 +4399,7 @@ static int qemudDomainAttachNetDevice(virConnectPtr conn,
if (virAsprintf(&tapfd_name, "fd-%s", net->hostnet_name) < 0)
goto no_memory;
if (qemuMonitorSendFileHandle(vm, tapfd_name, tapfd) < 0)
if (qemuMonitorSendFileHandle(priv->mon, tapfd_name, tapfd) < 0)
goto cleanup;
}
@ -4382,7 +4407,7 @@ static int qemudDomainAttachNetDevice(virConnectPtr conn,
net->vlan, tapfd_name, &netstr) < 0)
goto try_tapfd_close;
if (qemuMonitorAddHostNetwork(vm, netstr) < 0)
if (qemuMonitorAddHostNetwork(priv->mon, netstr) < 0)
goto try_tapfd_close;
if (tapfd != -1)
@ -4392,7 +4417,7 @@ static int qemudDomainAttachNetDevice(virConnectPtr conn,
if (qemuBuildNicStr(conn, net, NULL, net->vlan, &nicstr) < 0)
goto try_remove;
if (qemuMonitorAddPCINetwork(vm, nicstr,
if (qemuMonitorAddPCINetwork(priv->mon, nicstr,
&net->pci_addr.domain,
&net->pci_addr.bus,
&net->pci_addr.slot) < 0)
@ -4414,14 +4439,14 @@ cleanup:
try_remove:
if (!net->hostnet_name || net->vlan == 0)
VIR_WARN0(_("Unable to remove network backend\n"));
else if (qemuMonitorRemoveHostNetwork(vm, net->vlan, net->hostnet_name) < 0)
else if (qemuMonitorRemoveHostNetwork(priv->mon, net->vlan, net->hostnet_name) < 0)
VIR_WARN(_("Failed to remove network backend for vlan %d, net %s"),
net->vlan, net->hostnet_name);
goto cleanup;
try_tapfd_close:
if (tapfd_name &&
qemuMonitorCloseFileHandle(vm, tapfd_name) < 0)
qemuMonitorCloseFileHandle(priv->mon, tapfd_name) < 0)
VIR_WARN(_("Failed to close tapfd with '%s'\n"), tapfd_name);
goto cleanup;
@ -4436,6 +4461,7 @@ static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
virDomainObjPtr vm,
virDomainDeviceDefPtr dev)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
virDomainHostdevDefPtr hostdev = dev->data.hostdev;
pciDevice *pci;
@ -4463,7 +4489,7 @@ static int qemudDomainAttachHostPciDevice(virConnectPtr conn,
return -1;
}
if (qemuMonitorAddPCIHostDevice(vm,
if (qemuMonitorAddPCIHostDevice(priv->mon,
hostdev->source.subsys.u.pci.domain,
hostdev->source.subsys.u.pci.bus,
hostdev->source.subsys.u.pci.slot,
@ -4488,6 +4514,7 @@ static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
virDomainDeviceDefPtr dev)
{
int ret;
qemuDomainObjPrivatePtr priv = vm->privateData;
if (VIR_REALLOC_N(vm->def->hostdevs, vm->def->nhostdevs+1) < 0) {
virReportOOMError(conn);
@ -4495,11 +4522,11 @@ static int qemudDomainAttachHostUsbDevice(virConnectPtr conn,
}
if (dev->data.hostdev->source.subsys.u.usb.vendor) {
ret = qemuMonitorAddUSBDeviceMatch(vm,
ret = qemuMonitorAddUSBDeviceMatch(priv->mon,
dev->data.hostdev->source.subsys.u.usb.vendor,
dev->data.hostdev->source.subsys.u.usb.product);
} else {
ret = qemuMonitorAddUSBDeviceExact(vm,
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
dev->data.hostdev->source.subsys.u.usb.bus,
dev->data.hostdev->source.subsys.u.usb.device);
}
@ -4673,6 +4700,7 @@ static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
{
int i, ret = -1;
virDomainDiskDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
for (i = 0 ; i < vm->def->ndisks ; i++) {
if (STREQ(vm->def->disks[i]->dst, dev->data.disk->dst)) {
@ -4694,7 +4722,7 @@ static int qemudDomainDetachPciDiskDevice(virConnectPtr conn,
goto cleanup;
}
if (qemuMonitorRemovePCIDevice(vm,
if (qemuMonitorRemovePCIDevice(priv->mon,
detach->pci_addr.domain,
detach->pci_addr.bus,
detach->pci_addr.slot) < 0)
@ -4728,6 +4756,7 @@ qemudDomainDetachNetDevice(virConnectPtr conn,
{
int i, ret = -1;
virDomainNetDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
for (i = 0 ; i < vm->def->nnets ; i++) {
virDomainNetDefPtr net = vm->def->nets[i];
@ -4753,13 +4782,13 @@ qemudDomainDetachNetDevice(virConnectPtr conn,
goto cleanup;
}
if (qemuMonitorRemovePCIDevice(vm,
if (qemuMonitorRemovePCIDevice(priv->mon,
detach->pci_addr.domain,
detach->pci_addr.bus,
detach->pci_addr.slot) < 0)
goto cleanup;
if (qemuMonitorRemoveHostNetwork(vm, detach->vlan, detach->hostnet_name) < 0)
if (qemuMonitorRemoveHostNetwork(priv->mon, detach->vlan, detach->hostnet_name) < 0)
goto cleanup;
if (vm->def->nnets > 1) {
@ -4789,6 +4818,7 @@ static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
virDomainDeviceDefPtr dev)
{
virDomainHostdevDefPtr detach = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
int i, ret;
pciDevice *pci;
@ -4823,7 +4853,7 @@ static int qemudDomainDetachHostPciDevice(virConnectPtr conn,
return -1;
}
if (qemuMonitorRemovePCIDevice(vm,
if (qemuMonitorRemovePCIDevice(priv->mon,
detach->source.subsys.u.pci.guest_addr.domain,
detach->source.subsys.u.pci.guest_addr.bus,
detach->source.subsys.u.pci.guest_addr.slot) < 0)
@ -5256,7 +5286,9 @@ qemudDomainBlockStats (virDomainPtr dom,
if (!qemu_dev_name)
goto cleanup;
if (qemuMonitorGetBlockStatsInfo(vm, qemu_dev_name,
qemuDomainObjPrivatePtr priv = vm->privateData;
if (qemuMonitorGetBlockStatsInfo(priv->mon,
qemu_dev_name,
&stats->rd_req,
&stats->rd_bytes,
&stats->wr_req,
@ -5453,11 +5485,12 @@ qemudDomainMemoryPeek (virDomainPtr dom,
goto cleanup;
}
qemuDomainObjPrivatePtr priv = vm->privateData;
if (flags == VIR_MEMORY_VIRTUAL) {
if (qemuMonitorSaveVirtualMemory(vm, offset, size, tmp) < 0)
if (qemuMonitorSaveVirtualMemory(priv->mon, offset, size, tmp) < 0)
goto cleanup;
} else {
if (qemuMonitorSavePhysicalMemory(vm, offset, size, tmp) < 0)
if (qemuMonitorSavePhysicalMemory(priv->mon, offset, size, tmp) < 0)
goto cleanup;
}
@ -6175,6 +6208,7 @@ static int doNativeMigrate(virDomainPtr dom,
xmlURIPtr uribits = NULL;
int status;
unsigned long long transferred, remaining, total;
qemuDomainObjPrivatePtr priv = vm->privateData;
/* Issue the migrate command. */
if (STRPREFIX(uri, "tcp:") && !STRPREFIX(uri, "tcp://")) {
@ -6196,16 +6230,17 @@ static int doNativeMigrate(virDomainPtr dom,
}
if (resource > 0 &&
qemuMonitorSetMigrationSpeed(vm, resource) < 0)
qemuMonitorSetMigrationSpeed(priv->mon, resource) < 0)
goto cleanup;
if (qemuMonitorMigrateToHost(vm, 0, uribits->server, uribits->port) < 0)
if (qemuMonitorMigrateToHost(priv->mon, 0, uribits->server, uribits->port) < 0)
goto cleanup;
/* it is also possible that the migrate didn't fail initially, but
* rather failed later on. Check the output of "info migrate"
*/
if (qemuMonitorGetMigrationStatus(vm, &status,
if (qemuMonitorGetMigrationStatus(priv->mon,
&status,
&transferred,
&remaining,
&total) < 0) {
@ -6270,6 +6305,7 @@ static int doTunnelMigrate(virDomainPtr dom,
unsigned long resource)
{
struct qemud_driver *driver = dom->conn->privateData;
qemuDomainObjPrivatePtr priv = vm->privateData;
int client_sock = -1;
int qemu_sock = -1;
struct sockaddr_un sa_qemu, sa_client;
@ -6367,10 +6403,10 @@ static int doTunnelMigrate(virDomainPtr dom,
/* 3. start migration on source */
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)
internalret = qemuMonitorMigrateToUnix(vm, 1, unixfile);
internalret = qemuMonitorMigrateToUnix(priv->mon, 1, unixfile);
else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) {
const char *args[] = { "nc", "-U", unixfile, NULL };
internalret = qemuMonitorMigrateToCommand(vm, 1, args, "/dev/null");
internalret = qemuMonitorMigrateToCommand(priv->mon, 1, args, "/dev/null");
} else {
internalret = -1;
}
@ -6386,7 +6422,8 @@ static int doTunnelMigrate(virDomainPtr dom,
/* it is also possible that the migrate didn't fail initially, but
* rather failed later on. Check the output of "info migrate"
*/
if (qemuMonitorGetMigrationStatus(vm, &status,
if (qemuMonitorGetMigrationStatus(priv->mon,
&status,
&transferred,
&remaining,
&total) < 0) {
@ -6412,7 +6449,7 @@ static int doTunnelMigrate(virDomainPtr dom,
cancel:
if (retval != 0)
qemuMonitorMigrateCancel(vm);
qemuMonitorMigrateCancel(priv->mon);
finish:
dname = dname ? dname : dom->name;
@ -6573,8 +6610,9 @@ qemudDomainMigratePerform (virDomainPtr dom,
}
if (!(flags & VIR_MIGRATE_LIVE)) {
qemuDomainObjPrivatePtr priv = vm->privateData;
/* Pause domain for non-live migration */
if (qemuMonitorStopCPUs(vm) < 0)
if (qemuMonitorStopCPUs(priv->mon) < 0)
goto cleanup;
paused = 1;
@ -6611,8 +6649,9 @@ qemudDomainMigratePerform (virDomainPtr dom,
cleanup:
if (paused) {
qemuDomainObjPrivatePtr priv = vm->privateData;
/* we got here through some sort of failure; start the domain again */
if (qemuMonitorStartCPUs(dom->conn, vm) < 0) {
if (qemuMonitorStartCPUs(priv->mon, dom->conn) < 0) {
/* Hm, we already know we are in error here. We don't want to
* overwrite the previous error, though, so we just throw something
* to the logs and hope for the best
@ -6690,13 +6729,14 @@ qemudDomainMigrateFinish2 (virConnectPtr dconn,
qemuDomainEventQueue(driver, event);
}
qemuDomainObjPrivatePtr priv = vm->privateData;
dom = virGetDomain (dconn, vm->def->name, vm->def->uuid);
/* run 'cont' on the destination, which allows migration on qemu
* >= 0.10.6 to work properly. This isn't strictly necessary on
* older qemu's, but it also doesn't hurt anything there
*/
if (qemuMonitorStartCPUs(dconn, vm) < 0) {
if (qemuMonitorStartCPUs(priv->mon, dconn) < 0) {
if (virGetLastError() == NULL)
qemudReportError(dconn, NULL, NULL, VIR_ERR_INTERNAL_ERROR,
"%s", _("resume operation failed"));

319
src/qemu/qemu_monitor.c
View File

@ -29,6 +29,7 @@
#include <fcntl.h>
#include "qemu_monitor.h"
#include "qemu_monitor_text.h"
#include "qemu_conf.h"
#include "event.h"
#include "virterror_internal.h"
@ -432,3 +433,321 @@ int qemuMonitorGetDiskSecret(qemuMonitorPtr mon,
return mon->secretCB(mon, conn, mon->vm, path, secret, secretLen);
}
int
qemuMonitorStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextStartCPUs(mon, conn);
}
int
qemuMonitorStopCPUs(qemuMonitorPtr mon)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextStopCPUs(mon);
}
int qemuMonitorSystemPowerdown(qemuMonitorPtr mon)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextSystemPowerdown(mon);
}
int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
int **pids)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextGetCPUInfo(mon, pids);
}
int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
unsigned long *currmem)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextGetBalloonInfo(mon, currmem);
}
int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
const char *devname,
long long *rd_req,
long long *rd_bytes,
long long *wr_req,
long long *wr_bytes,
long long *errs)
{
DEBUG("mon=%p, fd=%d dev=%s", mon, mon->fd, devname);
return qemuMonitorTextGetBlockStatsInfo(mon, devname,
rd_req, rd_bytes,
wr_req, wr_bytes,
errs);
}
int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
const char *password)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextSetVNCPassword(mon, password);
}
int qemuMonitorSetBalloon(qemuMonitorPtr mon,
unsigned long newmem)
{
DEBUG("mon=%p, fd=%d newmem=%lu", mon, mon->fd, newmem);
return qemuMonitorTextSetBalloon(mon, newmem);
}
int qemuMonitorEjectMedia(qemuMonitorPtr mon,
const char *devname)
{
DEBUG("mon=%p, fd=%d devname=%s", mon, mon->fd, devname);
return qemuMonitorTextEjectMedia(mon, devname);
}
int qemuMonitorChangeMedia(qemuMonitorPtr mon,
const char *devname,
const char *newmedia)
{
DEBUG("mon=%p, fd=%d devname=%s newmedia=%s",
mon, mon->fd, devname, newmedia);
return qemuMonitorTextChangeMedia(mon, devname, newmedia);
}
int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path)
{
DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
mon, mon->fd, offset, length, path);
return qemuMonitorTextSaveVirtualMemory(mon, offset, length, path);
}
int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path)
{
DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
mon, mon->fd, offset, length, path);
return qemuMonitorTextSavePhysicalMemory(mon, offset, length, path);
}
int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
unsigned long bandwidth)
{
DEBUG("mon=%p, fd=%d bandwidth=%lu", mon, mon->fd, bandwidth);
return qemuMonitorTextSetMigrationSpeed(mon, bandwidth);
}
int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
int *status,
unsigned long long *transferred,
unsigned long long *remaining,
unsigned long long *total)
{
DEBUG("mon=%p, fd=%d", mon, mon->fd);
return qemuMonitorTextGetMigrationStatus(mon, status,
transferred,
remaining,
total);
}
int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
int background,
const char *hostname,
int port)
{
DEBUG("mon=%p, fd=%d hostname=%s port=%d",
mon, mon->fd, hostname, port);
return qemuMonitorTextMigrateToHost(mon, background, hostname, port);
}
int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
int background,
const char * const *argv,
const char *target)
{
DEBUG("mon=%p, fd=%d argv=%p target=%s",
mon, mon->fd, argv, target);
return qemuMonitorTextMigrateToCommand(mon, background, argv, target);
}
int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
int background,
const char *unixfile)
{
DEBUG("mon=%p fd=%d unixfile=%s",
mon, mon->fd, unixfile);
return qemuMonitorTextMigrateToUnix(mon, background, unixfile);
}
int qemuMonitorMigrateCancel(qemuMonitorPtr mon)
{
DEBUG("mon=%p fd=%d", mon, mon->fd);
return qemuMonitorTextMigrateCancel(mon);
}
int qemuMonitorAddUSBDisk(qemuMonitorPtr mon,
const char *path)
{
DEBUG("mon=%p, fd=%d path=%s", mon, mon->fd, path);
return qemuMonitorTextAddUSBDisk(mon, path);
}
int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon,
int bus,
int dev)
{
DEBUG("mon=%p, fd=%d bus=%d dev=%d", mon, mon->fd, bus, dev);
return qemuMonitorTextAddUSBDeviceExact(mon, bus, dev);
}
int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon,
int vendor,
int product)
{
DEBUG("mon=%p, fd=%d vendor=%d product=%d",
mon, mon->fd, vendor, product);
return qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product);
}
int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon,
unsigned hostDomain,
unsigned hostBus,
unsigned hostSlot,
unsigned hostFunction,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot)
{
DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d function=%d",
mon, mon->fd,
hostDomain, hostBus, hostSlot, hostFunction);
return qemuMonitorTextAddPCIHostDevice(mon, hostDomain,
hostBus, hostSlot,
hostFunction,
guestDomain,
guestBus,
guestSlot);
}
int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
const char *path,
const char *bus,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot)
{
DEBUG("mon=%p, fd=%d path=%s bus=%s",
mon, mon->fd, path, bus);
return qemuMonitorTextAddPCIDisk(mon, path, bus,
guestDomain, guestBus, guestSlot);
}
int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
const char *nicstr,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot)
{
DEBUG("mon=%p, fd=%d nicstr=%s", mon, mon->fd, nicstr);
return qemuMonitorTextAddPCINetwork(mon, nicstr, guestDomain,
guestBus, guestSlot);
}
int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
unsigned guestDomain,
unsigned guestBus,
unsigned guestSlot)
{
DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d",
mon, mon->fd, guestDomain, guestBus, guestSlot);
return qemuMonitorTextRemovePCIDevice(mon, guestDomain,
guestBus, guestSlot);
}
int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
const char *fdname,
int fd)
{
DEBUG("mon=%p, fd=%d fdname=%s fd=%d",
mon, mon->fd, fdname, fd);
return qemuMonitorTextSendFileHandle(mon, fdname, fd);
}
int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
const char *fdname)
{
DEBUG("mon=%p, fd=%d fdname=%s",
mon, mon->fd, fdname);
return qemuMonitorTextCloseFileHandle(mon, fdname);
}
int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
const char *netstr)
{
DEBUG("mon=%p, fd=%d netstr=%s",
mon, mon->fd, netstr);
return qemuMonitorTextAddHostNetwork(mon, netstr);
}
int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
int vlan,
const char *netname)
{
DEBUG("mon=%p, fd=%d netname=%s",
mon, mon->fd, netname);
return qemuMonitorTextRemoveHostNetwork(mon, vlan, netname);
}

148
src/qemu/qemu_monitor.h
View File

@ -78,4 +78,152 @@ int qemuMonitorGetDiskSecret(qemuMonitorPtr mon,
char **secret,
size_t *secretLen);
int qemuMonitorStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn);
int qemuMonitorStopCPUs(qemuMonitorPtr mon);
int qemuMonitorSystemPowerdown(qemuMonitorPtr mon);
int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
int **pids);
int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
unsigned long *currmem);
int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
const char *devname,
long long *rd_req,
long long *rd_bytes,
long long *wr_req,
long long *wr_bytes,
long long *errs);
int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
const char *password);
int qemuMonitorSetBalloon(qemuMonitorPtr mon,
unsigned long newmem);
/* XXX should we pass the virDomainDiskDefPtr instead
* and hide devname details inside monitor. Reconsider
* this when doing the QMP implementation
*/
int qemuMonitorEjectMedia(qemuMonitorPtr mon,
const char *devname);
int qemuMonitorChangeMedia(qemuMonitorPtr mon,
const char *devname,
const char *newmedia);
int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path);
int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path);
int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
unsigned long bandwidth);
enum {
QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
QEMU_MONITOR_MIGRATION_STATUS_ACTIVE,
QEMU_MONITOR_MIGRATION_STATUS_COMPLETED,
QEMU_MONITOR_MIGRATION_STATUS_ERROR,
QEMU_MONITOR_MIGRATION_STATUS_CANCELLED,
QEMU_MONITOR_MIGRATION_STATUS_LAST
};
int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
int *status,
unsigned long long *transferred,
unsigned long long *remaining,
unsigned long long *total);
int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
int background,
const char *hostname,
int port);
int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
int background,
const char * const *argv,
const char *target);
int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
int background,
const char *unixfile);
int qemuMonitorMigrateCancel(qemuMonitorPtr mon);
/* XXX disk driver type eg, qcow/etc.
* XXX cache mode
*/
int qemuMonitorAddUSBDisk(qemuMonitorPtr mon,
const char *path);
int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon,
int bus,
int dev);
int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon,
int vendor,
int product);
int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon,
unsigned hostDomain,
unsigned hostBus,
unsigned hostSlot,
unsigned hostFunction,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
/* XXX disk driver type eg, qcow/etc.
* XXX cache mode
*/
int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
const char *path,
const char *bus,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
/* XXX do we really want to hardcode 'nicstr' as the
* sendable item here
*/
int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
const char *nicstr,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
unsigned guestDomain,
unsigned guestBus,
unsigned guestSlot);
int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
const char *fdname,
int fd);
int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
const char *fdname);
/* XXX do we really want to hardcode 'netstr' as the
* sendable item here
*/
int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
const char *netstr);
int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
int vlan,
const char *netname);
#endif /* QEMU_MONITOR_H */

436
src/qemu/qemu_monitor_text.c
View File

File diff suppressed because it is too large Load Diff

237
src/qemu/qemu_monitor_text.h
View File

@ -27,155 +27,124 @@
#include "internal.h"
#include "domain_conf.h"
#include "qemu_monitor.h"
int qemuMonitorTextStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn);
int qemuMonitorTextStopCPUs(qemuMonitorPtr mon);
int qemuMonitorTextSystemPowerdown(qemuMonitorPtr mon);
int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon,
int **pids);
int qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon,
unsigned long *currmem);
int qemuMonitorTextGetBlockStatsInfo(qemuMonitorPtr mon,
const char *devname,
long long *rd_req,
long long *rd_bytes,
long long *wr_req,
long long *wr_bytes,
long long *errs);
/* Formal APIs for each required monitor command */
int qemuMonitorTextSetVNCPassword(qemuMonitorPtr mon,
const char *password);
int qemuMonitorTextSetBalloon(qemuMonitorPtr mon,
unsigned long newmem);
int qemuMonitorStartCPUs(virConnectPtr conn,
const virDomainObjPtr vm);
int qemuMonitorStopCPUs(const virDomainObjPtr vm);
int qemuMonitorSystemPowerdown(const virDomainObjPtr vm);
int qemuMonitorGetCPUInfo(const virDomainObjPtr vm,
int **pids);
int qemuMonitorGetBalloonInfo(const virDomainObjPtr vm,
unsigned long *currmem);
int qemuMonitorGetBlockStatsInfo(const virDomainObjPtr vm,
const char *devname,
long long *rd_req,
long long *rd_bytes,
long long *wr_req,
long long *wr_bytes,
long long *errs);
int qemuMonitorTextEjectMedia(qemuMonitorPtr mon,
const char *devname);
int qemuMonitorTextChangeMedia(qemuMonitorPtr mon,
const char *devname,
const char *newmedia);
int qemuMonitorSetVNCPassword(const virDomainObjPtr vm,
const char *password);
int qemuMonitorSetBalloon(const virDomainObjPtr vm,
unsigned long newmem);
int qemuMonitorTextSaveVirtualMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path);
int qemuMonitorTextSavePhysicalMemory(qemuMonitorPtr mon,
unsigned long long offset,
size_t length,
const char *path);
/* XXX should we pass the virDomainDiskDefPtr instead
* and hide devname details inside monitor. Reconsider
* this when doing the QMP implementation
*/
int qemuMonitorEjectMedia(const virDomainObjPtr vm,
const char *devname);
int qemuMonitorChangeMedia(const virDomainObjPtr vm,
const char *devname,
const char *newmedia);
int qemuMonitorTextSetMigrationSpeed(qemuMonitorPtr mon,
unsigned long bandwidth);
int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
int *status,
unsigned long long *transferred,
unsigned long long *remaining,
unsigned long long *total);
int qemuMonitorTextMigrateToHost(qemuMonitorPtr mon,
int background,
const char *hostname,
int port);
int qemuMonitorTextMigrateToCommand(qemuMonitorPtr mon,
int background,
const char * const *argv,
const char *target);
int qemuMonitorTextMigrateToUnix(qemuMonitorPtr mon,
int background,
const char *unixfile);
int qemuMonitorTextMigrateCancel(qemuMonitorPtr mon);
int qemuMonitorTextAddUSBDisk(qemuMonitorPtr mon,
const char *path);
int qemuMonitorTextAddUSBDeviceExact(qemuMonitorPtr mon,
int bus,
int dev);
int qemuMonitorTextAddUSBDeviceMatch(qemuMonitorPtr mon,
int vendor,
int product);
int qemuMonitorSaveVirtualMemory(const virDomainObjPtr vm,
unsigned long long offset,
size_t length,
const char *path);
int qemuMonitorSavePhysicalMemory(const virDomainObjPtr vm,
unsigned long long offset,
size_t length,
const char *path);
int qemuMonitorTextAddPCIHostDevice(qemuMonitorPtr mon,
unsigned hostDomain,
unsigned hostBus,
unsigned hostSlot,
unsigned hostFunction,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
int qemuMonitorSetMigrationSpeed(const virDomainObjPtr vm,
unsigned long bandwidth);
int qemuMonitorTextAddPCIDisk(qemuMonitorPtr mon,
const char *path,
const char *bus,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
enum {
QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
QEMU_MONITOR_MIGRATION_STATUS_ACTIVE,
QEMU_MONITOR_MIGRATION_STATUS_COMPLETED,
QEMU_MONITOR_MIGRATION_STATUS_ERROR,
QEMU_MONITOR_MIGRATION_STATUS_CANCELLED,
int qemuMonitorTextAddPCINetwork(qemuMonitorPtr mon,
const char *nicstr,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
QEMU_MONITOR_MIGRATION_STATUS_LAST
};
int qemuMonitorGetMigrationStatus(const virDomainObjPtr vm,
int *status,
unsigned long long *transferred,
unsigned long long *remaining,
unsigned long long *total);
int qemuMonitorMigrateToHost(const virDomainObjPtr vm,
int background,
const char *hostname,
int port);
int qemuMonitorMigrateToCommand(const virDomainObjPtr vm,
int background,
const char * const *argv,
const char *target);
int qemuMonitorMigrateToUnix(const virDomainObjPtr vm,
int background,
const char *unixfile);
int qemuMonitorMigrateCancel(const virDomainObjPtr vm);
int qemuMonitorTextRemovePCIDevice(qemuMonitorPtr mon,
unsigned guestDomain,
unsigned guestBus,
unsigned guestSlot);
/* XXX disk driver type eg, qcow/etc.
* XXX cache mode
*/
int qemuMonitorAddUSBDisk(const virDomainObjPtr vm,
const char *path);
int qemuMonitorTextSendFileHandle(qemuMonitorPtr mon,
const char *fdname,
int fd);
int qemuMonitorAddUSBDeviceExact(const virDomainObjPtr vm,
int bus,
int dev);
int qemuMonitorAddUSBDeviceMatch(const virDomainObjPtr vm,
int vendor,
int product);
int qemuMonitorTextCloseFileHandle(qemuMonitorPtr mon,
const char *fdname);
int qemuMonitorTextAddHostNetwork(qemuMonitorPtr mon,
const char *netstr);
int qemuMonitorAddPCIHostDevice(const virDomainObjPtr vm,
unsigned hostDomain,
unsigned hostBus,
unsigned hostSlot,
unsigned hostFunction,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
/* XXX disk driver type eg, qcow/etc.
* XXX cache mode
*/
int qemuMonitorAddPCIDisk(const virDomainObjPtr vm,
const char *path,
const char *bus,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
/* XXX do we really want to hardcode 'nicstr' as the
* sendable item here
*/
int qemuMonitorAddPCINetwork(const virDomainObjPtr vm,
const char *nicstr,
unsigned *guestDomain,
unsigned *guestBus,
unsigned *guestSlot);
int qemuMonitorRemovePCIDevice(const virDomainObjPtr vm,
unsigned guestDomain,
unsigned guestBus,
unsigned guestSlot);
int qemuMonitorSendFileHandle(const virDomainObjPtr vm,
const char *fdname,
int fd);
int qemuMonitorCloseFileHandle(const virDomainObjPtr vm,
const char *fdname);
/* XXX do we relaly want to hardcode 'netstr' as the
* sendable item here
*/
int qemuMonitorAddHostNetwork(const virDomainObjPtr vm,
const char *netstr);
int qemuMonitorRemoveHostNetwork(const virDomainObjPtr vm,
int vlan,
const char *netname);
int qemuMonitorTextRemoveHostNetwork(qemuMonitorPtr mon,
int vlan,
const char *netname);
#endif /* QEMU_MONITOR_TEXT_H */