2009-10-09 18:07:55 +00:00
|
|
|
/*
|
|
|
|
|
* qemu_monitor.h: interaction with QEMU monitor console
|
|
|
|
|
*
|
qemu: read backing chain names from qemu
https://bugzilla.redhat.com/show_bug.cgi?id=1199182 documents that
after a series of disk snapshots into existing destination images,
followed by active commits of the top image, it is possible for
qemu 2.2 and earlier to end up tracking a different name for the
image than what it would have had when opening the chain afresh.
That is, when starting with the chain 'a <- b <- c', the name
associated with 'b' is how it was spelled in the metadata of 'c',
but when starting with 'a', taking two snapshots into 'a <- b <- c',
then committing 'c' back into 'b', the name associated with 'b' is
now the name used when taking the first snapshot.
Sadly, older qemu doesn't know how to treat different spellings of
the same filename as identical files (it uses strcmp() instead of
checking for the same inode), which means libvirt's attempt to
commit an image using solely the names learned from qcow2 metadata
fails with a cryptic:
error: internal error: unable to execute QEMU command 'block-commit': Top image file /tmp/images/c/../b/b not found
even though the file exists. Trying to teach libvirt the rules on
which name qemu will expect is not worth the effort (besides, we'd
have to remember it across libvirtd restarts, and track whether a
file was opened via metadata or via snapshot creation for a given
qemu process); it is easier to just always directly ask qemu what
string it expects to see in the first place.
As a safety valve, we validate that any name returned by qemu
still maps to the same local file as we have tracked it, so that
a compromised qemu cannot accidentally cause us to act on an
incorrect file.
* src/qemu/qemu_monitor.h (qemuMonitorDiskNameLookup): New
prototype.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDiskNameLookup):
Likewise.
* src/qemu/qemu_monitor.c (qemuMonitorDiskNameLookup): New function.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONDiskNameLookup)
(qemuMonitorJSONDiskNameLookupOne): Likewise.
* src/qemu/qemu_driver.c (qemuDomainBlockCommit)
(qemuDomainBlockJobImpl): Use it.
Signed-off-by: Eric Blake <eblake@redhat.com>
2015-03-11 20:37:04 +00:00
|
|
|
* Copyright (C) 2006-2015 Red Hat, Inc.
|
2009-10-09 18:07:55 +00:00
|
|
|
* Copyright (C) 2006 Daniel P. Berrange
|
|
|
|
|
*
|
|
|
|
|
* 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/>.
|
2009-10-09 18:07:55 +00:00
|
|
|
*
|
|
|
|
|
* Author: Daniel P. Berrange <berrange@redhat.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef QEMU_MONITOR_H
|
2010-03-09 18:22:22 +00:00
|
|
|
# define QEMU_MONITOR_H
|
2009-10-09 18:07:55 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "internal.h"
|
2009-10-09 18:07:55 +00:00
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "domain_conf.h"
|
2012-12-04 11:56:32 +00:00
|
|
|
# include "virbitmap.h"
|
2012-01-25 16:13:59 +00:00
|
|
|
# include "virhash.h"
|
2012-12-12 17:53:50 +00:00
|
|
|
# include "virjson.h"
|
qemu: qemuMonitorQueryRxFilter - retrieve guest netdev rx-filter
This function can be called at any time to get the current status of a
guest's network device rx-filter. In particular it is useful to call
after libvirt recieves a NIC_RX_FILTER_CHANGED event - this event only
tells you that something has changed in the rx-filter, the details are
retrieved with the query-rx-filter monitor command (only available in
the json monitor). The command sent to the qemu monitor looks like this:
{"execute":"query-rx-filter", "arguments": {"name":"net2"} }'
and the results will look something like this:
{
"return": [
{
"promiscuous": false,
"name": "net2",
"main-mac": "52:54:00:98:2d:e3",
"unicast": "normal",
"vlan": "normal",
"vlan-table": [
42,
0
],
"unicast-table": [
],
"multicast": "normal",
"multicast-overflow": false,
"unicast-overflow": false,
"multicast-table": [
"33:33:ff:98:2d:e3",
"01:80:c2:00:00:21",
"01:00:5e:00:00:fb",
"33:33:ff:98:2d:e2",
"01:00:5e:00:00:01",
"33:33:00:00:00:01"
],
"broadcast-allowed": false
}
],
"id": "libvirt-14"
}
This is all parsed from JSON into a virNetDevRxFilter object for
easier consumption. (unicast-table is usually empty, but is also an
array of mac addresses similar to multicast-table).
(NB: LIBNL_CFLAGS was added to tests/Makefile.am because virnetdev.h
now includes util/virnetlink.h, which includes netlink/msg.h when
appropriate. Without LIBNL_CFLAGS, gcc can't find that file (if
libnl/netlink isn't available, LIBNL_CFLAGS will be empty and
virnetlink.h won't try to include netlink/msg.h anyway).)
2014-09-22 16:19:41 +00:00
|
|
|
# include "virnetdev.h"
|
2012-08-16 15:41:06 +00:00
|
|
|
# include "device_conf.h"
|
2013-07-22 11:07:23 +00:00
|
|
|
# include "cpu/cpu.h"
|
2016-03-08 17:24:18 +00:00
|
|
|
# include "util/virgic.h"
|
2009-10-09 18:07:55 +00:00
|
|
|
|
2009-10-09 19:13:29 +00:00
|
|
|
typedef struct _qemuMonitor qemuMonitor;
|
|
|
|
|
typedef qemuMonitor *qemuMonitorPtr;
|
2009-10-09 18:07:55 +00:00
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
typedef struct _qemuMonitorMessage qemuMonitorMessage;
|
|
|
|
|
typedef qemuMonitorMessage *qemuMonitorMessagePtr;
|
|
|
|
|
|
|
|
|
|
typedef int (*qemuMonitorPasswordHandler)(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMessagePtr msg,
|
|
|
|
|
const char *data,
|
|
|
|
|
size_t len,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
|
|
|
|
struct _qemuMonitorMessage {
|
|
|
|
|
int txFD;
|
|
|
|
|
|
|
|
|
|
char *txBuffer;
|
|
|
|
|
int txOffset;
|
|
|
|
|
int txLength;
|
|
|
|
|
|
2011-05-29 12:51:08 +00:00
|
|
|
/* Used by the text monitor reply / error */
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
char *rxBuffer;
|
|
|
|
|
int rxLength;
|
2011-05-29 12:51:08 +00:00
|
|
|
/* Used by the JSON monitor to hold reply / error */
|
|
|
|
|
void *rxObject;
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
|
2011-05-29 12:51:08 +00:00
|
|
|
/* True if rxBuffer / rxObject are ready, or a
|
|
|
|
|
* fatal error occurred on the monitor channel
|
|
|
|
|
*/
|
|
|
|
|
bool finished;
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
|
|
|
|
|
qemuMonitorPasswordHandler passwordHandler;
|
|
|
|
|
void *passwordOpaque;
|
|
|
|
|
};
|
|
|
|
|
|
2013-07-25 15:27:52 +00:00
|
|
|
|
|
|
|
|
typedef void (*qemuMonitorDestroyCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef void (*qemuMonitorEofNotifyCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef void (*qemuMonitorErrorNotifyCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
/* XXX we'd really like to avoid virConnectPtr here
|
|
|
|
|
* It is required so the callback can find the active
|
|
|
|
|
* secret driver. Need to change this to work like the
|
|
|
|
|
* security drivers do, to avoid this
|
|
|
|
|
*/
|
|
|
|
|
typedef int (*qemuMonitorDiskSecretLookupCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virConnectPtr conn,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *path,
|
|
|
|
|
char **secret,
|
2013-07-25 17:26:15 +00:00
|
|
|
size_t *secretLen,
|
|
|
|
|
void *opaque);
|
2014-01-30 00:14:44 +00:00
|
|
|
typedef int (*qemuMonitorDomainEventCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *event,
|
|
|
|
|
long long seconds,
|
|
|
|
|
unsigned int micros,
|
|
|
|
|
const char *details,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainShutdownCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainResetCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainPowerdownCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainStopCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainResumeCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainRTCChangeCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
2013-07-25 17:26:15 +00:00
|
|
|
long long offset,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainWatchdogCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
2013-07-25 17:26:15 +00:00
|
|
|
int action,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainIOErrorCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *diskAlias,
|
|
|
|
|
int action,
|
2013-07-25 17:26:15 +00:00
|
|
|
const char *reason,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainGraphicsCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
int phase,
|
|
|
|
|
int localFamily,
|
|
|
|
|
const char *localNode,
|
|
|
|
|
const char *localService,
|
|
|
|
|
int remoteFamily,
|
|
|
|
|
const char *remoteNode,
|
|
|
|
|
const char *remoteService,
|
|
|
|
|
const char *authScheme,
|
|
|
|
|
const char *x509dname,
|
2013-07-25 17:26:15 +00:00
|
|
|
const char *saslUsername,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainBlockJobCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *diskAlias,
|
|
|
|
|
int type,
|
2013-07-25 17:26:15 +00:00
|
|
|
int status,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainTrayChangeCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *devAlias,
|
2013-07-25 17:26:15 +00:00
|
|
|
int reason,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainPMWakeupCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainPMSuspendCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainBalloonChangeCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
2013-07-25 17:26:15 +00:00
|
|
|
unsigned long long actual,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainPMSuspendDiskCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainGuestPanicCallback)(qemuMonitorPtr mon,
|
2013-07-25 17:26:15 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainDeviceDeletedCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
2013-07-25 17:26:15 +00:00
|
|
|
const char *devAlias,
|
|
|
|
|
void *opaque);
|
2014-09-17 17:07:50 +00:00
|
|
|
typedef int (*qemuMonitorDomainNicRxFilterChangedCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *devAlias,
|
|
|
|
|
void *opaque);
|
2013-07-25 15:27:52 +00:00
|
|
|
|
2014-11-13 13:09:39 +00:00
|
|
|
typedef int (*qemuMonitorDomainSerialChangeCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *devAlias,
|
|
|
|
|
bool connected,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
2015-05-28 11:35:06 +00:00
|
|
|
typedef int (*qemuMonitorDomainSpiceMigratedCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
2015-05-28 11:35:52 +00:00
|
|
|
typedef int (*qemuMonitorDomainMigrationStatusCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
int status,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
2015-12-08 14:23:35 +00:00
|
|
|
typedef int (*qemuMonitorDomainMigrationPassCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
int pass,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
2016-04-01 14:41:08 +00:00
|
|
|
typedef int (*qemuMonitorDomainAcpiOstInfoCallback)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *alias,
|
|
|
|
|
const char *slotType,
|
|
|
|
|
const char *slot,
|
|
|
|
|
unsigned int source,
|
|
|
|
|
unsigned int status,
|
|
|
|
|
void *opaque);
|
|
|
|
|
|
|
|
|
|
|
2009-10-15 17:56:52 +00:00
|
|
|
typedef struct _qemuMonitorCallbacks qemuMonitorCallbacks;
|
|
|
|
|
typedef qemuMonitorCallbacks *qemuMonitorCallbacksPtr;
|
|
|
|
|
struct _qemuMonitorCallbacks {
|
2013-07-25 15:27:52 +00:00
|
|
|
qemuMonitorDestroyCallback destroy;
|
|
|
|
|
qemuMonitorEofNotifyCallback eofNotify;
|
|
|
|
|
qemuMonitorErrorNotifyCallback errorNotify;
|
|
|
|
|
qemuMonitorDiskSecretLookupCallback diskSecretLookup;
|
2014-01-30 00:14:44 +00:00
|
|
|
qemuMonitorDomainEventCallback domainEvent;
|
2013-07-25 15:27:52 +00:00
|
|
|
qemuMonitorDomainShutdownCallback domainShutdown;
|
|
|
|
|
qemuMonitorDomainResetCallback domainReset;
|
|
|
|
|
qemuMonitorDomainPowerdownCallback domainPowerdown;
|
|
|
|
|
qemuMonitorDomainStopCallback domainStop;
|
|
|
|
|
qemuMonitorDomainResumeCallback domainResume;
|
|
|
|
|
qemuMonitorDomainRTCChangeCallback domainRTCChange;
|
|
|
|
|
qemuMonitorDomainWatchdogCallback domainWatchdog;
|
|
|
|
|
qemuMonitorDomainIOErrorCallback domainIOError;
|
|
|
|
|
qemuMonitorDomainGraphicsCallback domainGraphics;
|
|
|
|
|
qemuMonitorDomainBlockJobCallback domainBlockJob;
|
|
|
|
|
qemuMonitorDomainTrayChangeCallback domainTrayChange;
|
|
|
|
|
qemuMonitorDomainPMWakeupCallback domainPMWakeup;
|
|
|
|
|
qemuMonitorDomainPMSuspendCallback domainPMSuspend;
|
|
|
|
|
qemuMonitorDomainBalloonChangeCallback domainBalloonChange;
|
|
|
|
|
qemuMonitorDomainPMSuspendDiskCallback domainPMSuspendDisk;
|
|
|
|
|
qemuMonitorDomainGuestPanicCallback domainGuestPanic;
|
|
|
|
|
qemuMonitorDomainDeviceDeletedCallback domainDeviceDeleted;
|
2014-09-17 17:07:50 +00:00
|
|
|
qemuMonitorDomainNicRxFilterChangedCallback domainNicRxFilterChanged;
|
2014-11-13 13:09:39 +00:00
|
|
|
qemuMonitorDomainSerialChangeCallback domainSerialChange;
|
2015-05-28 11:35:06 +00:00
|
|
|
qemuMonitorDomainSpiceMigratedCallback domainSpiceMigrated;
|
2015-05-28 11:35:52 +00:00
|
|
|
qemuMonitorDomainMigrationStatusCallback domainMigrationStatus;
|
2015-12-08 14:23:35 +00:00
|
|
|
qemuMonitorDomainMigrationPassCallback domainMigrationPass;
|
2016-04-01 14:41:08 +00:00
|
|
|
qemuMonitorDomainAcpiOstInfoCallback domainAcpiOstInfo;
|
2009-10-15 17:56:52 +00:00
|
|
|
};
|
|
|
|
|
|
2009-11-26 13:37:11 +00:00
|
|
|
char *qemuMonitorEscapeArg(const char *in);
|
2012-02-26 00:48:02 +00:00
|
|
|
char *qemuMonitorUnescapeArg(const char *in);
|
2009-11-26 13:37:11 +00:00
|
|
|
|
2009-10-09 19:13:29 +00:00
|
|
|
qemuMonitorPtr qemuMonitorOpen(virDomainObjPtr vm,
|
2011-01-07 23:36:25 +00:00
|
|
|
virDomainChrSourceDefPtr config,
|
2013-04-26 02:32:41 +00:00
|
|
|
bool json,
|
2013-07-25 17:26:15 +00:00
|
|
|
qemuMonitorCallbacksPtr cb,
|
|
|
|
|
void *opaque)
|
2012-08-20 12:39:47 +00:00
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(4);
|
2012-09-06 15:23:57 +00:00
|
|
|
qemuMonitorPtr qemuMonitorOpenFD(virDomainObjPtr vm,
|
|
|
|
|
int sockfd,
|
2013-04-26 02:32:41 +00:00
|
|
|
bool json,
|
2013-07-25 17:26:15 +00:00
|
|
|
qemuMonitorCallbacksPtr cb,
|
|
|
|
|
void *opaque)
|
2012-09-06 15:23:57 +00:00
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4);
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2016-02-11 14:32:48 +00:00
|
|
|
void qemuMonitorUnregister(qemuMonitorPtr mon)
|
|
|
|
|
ATTRIBUTE_NONNULL(1);
|
2010-06-10 14:11:30 +00:00
|
|
|
void qemuMonitorClose(qemuMonitorPtr mon);
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2015-07-02 06:26:48 +00:00
|
|
|
virErrorPtr qemuMonitorLastError(qemuMonitorPtr mon);
|
|
|
|
|
|
2012-09-13 14:54:02 +00:00
|
|
|
int qemuMonitorSetCapabilities(qemuMonitorPtr mon);
|
2010-02-12 13:45:20 +00:00
|
|
|
|
2011-09-06 08:18:57 +00:00
|
|
|
int qemuMonitorSetLink(qemuMonitorPtr mon,
|
|
|
|
|
const char *name,
|
2015-04-14 13:26:36 +00:00
|
|
|
virDomainNetInterfaceLinkState state)
|
|
|
|
|
ATTRIBUTE_NONNULL(2);
|
2011-09-06 08:18:57 +00:00
|
|
|
|
2011-03-09 20:24:04 +00:00
|
|
|
/* These APIs are for use by the internal Text/JSON monitor impl code only */
|
2011-05-29 12:51:08 +00:00
|
|
|
char *qemuMonitorNextCommandID(qemuMonitorPtr mon);
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
int qemuMonitorSend(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMessagePtr msg);
|
2013-04-26 17:13:45 +00:00
|
|
|
virJSONValuePtr qemuMonitorGetOptions(qemuMonitorPtr mon)
|
|
|
|
|
ATTRIBUTE_NONNULL(1);
|
|
|
|
|
void qemuMonitorSetOptions(qemuMonitorPtr mon, virJSONValuePtr options)
|
|
|
|
|
ATTRIBUTE_NONNULL(1);
|
2014-12-10 14:31:23 +00:00
|
|
|
int qemuMonitorUpdateVideoMemorySize(qemuMonitorPtr mon,
|
|
|
|
|
virDomainVideoDefPtr video,
|
2015-07-24 11:53:36 +00:00
|
|
|
const char *videoName)
|
2014-12-10 14:31:23 +00:00
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
2016-02-23 16:04:19 +00:00
|
|
|
int qemuMonitorUpdateVideoVram64Size(qemuMonitorPtr mon,
|
|
|
|
|
virDomainVideoDefPtr video,
|
|
|
|
|
const char *videoName)
|
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
2011-03-10 08:33:01 +00:00
|
|
|
int qemuMonitorHMPCommandWithFd(qemuMonitorPtr mon,
|
|
|
|
|
const char *cmd,
|
|
|
|
|
int scm_fd,
|
|
|
|
|
char **reply);
|
|
|
|
|
# define qemuMonitorHMPCommand(mon, cmd, reply) \
|
|
|
|
|
qemuMonitorHMPCommandWithFd(mon, cmd, -1, reply)
|
2009-10-09 18:07:55 +00:00
|
|
|
|
Fully asynchronous monitor I/O processing
Change the QEMU monitor file handle watch to poll for both
read & write events, as well as EOF. All I/O to/from the
QEMU monitor FD is now done in the event callback thread.
When the QEMU driver needs to send a command, it puts the
data to be sent into a qemuMonitorMessagePtr object instance,
queues it for dispatch, and then goes to sleep on a condition
variable. The event thread sends all the data, and then waits
for the reply to arrive, putting the response / error data
back into the qemuMonitorMessagePtr and notifying the condition
variable.
There is a temporary hack in the disk passphrase callback to
avoid acquiring the domain lock. This avoids a deadlock in
the command processing, since the domain lock is still held
when running monitor commands. The next commit will remove
the locking when running commands & thus allow re-introduction
of locking the disk passphrase callback
* src/qemu/qemu_driver.c: Temporarily don't acquire lock in
disk passphrase callback. To be reverted in next commit
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h: Remove
raw I/O functions, and a generic qemuMonitorSend() for
invoking a command
* src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h:
Remove all low level I/O, and use the new qemuMonitorSend()
API. Provide a qemuMonitorTextIOProcess() method for detecting
command/reply/prompt boundaries in the monitor data stream
2009-10-14 17:40:51 +00:00
|
|
|
/* XXX same comment about virConnectPtr as above */
|
2009-10-09 19:34:24 +00:00
|
|
|
int qemuMonitorGetDiskSecret(qemuMonitorPtr mon,
|
|
|
|
|
virConnectPtr conn,
|
|
|
|
|
const char *path,
|
|
|
|
|
char **secret,
|
|
|
|
|
size_t *secretLen);
|
2009-10-09 18:07:55 +00:00
|
|
|
|
2014-01-30 00:14:44 +00:00
|
|
|
int qemuMonitorEmitEvent(qemuMonitorPtr mon, const char *event,
|
|
|
|
|
long long seconds, unsigned int micros,
|
|
|
|
|
const char *details);
|
2009-11-26 13:05:24 +00:00
|
|
|
int qemuMonitorEmitShutdown(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitReset(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitPowerdown(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitStop(qemuMonitorPtr mon);
|
2013-01-07 21:25:01 +00:00
|
|
|
int qemuMonitorEmitResume(qemuMonitorPtr mon);
|
2010-03-18 18:28:15 +00:00
|
|
|
int qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset);
|
Add support for an explicit watchdog event
This introduces a new event type
VIR_DOMAIN_EVENT_ID_WATCHDOG
This event includes the action that is about to be taken
as a result of the watchdog triggering
typedef enum {
VIR_DOMAIN_EVENT_WATCHDOG_NONE = 0,
VIR_DOMAIN_EVENT_WATCHDOG_PAUSE,
VIR_DOMAIN_EVENT_WATCHDOG_RESET,
VIR_DOMAIN_EVENT_WATCHDOG_POWEROFF,
VIR_DOMAIN_EVENT_WATCHDOG_SHUTDOWN,
VIR_DOMAIN_EVENT_WATCHDOG_DEBUG,
} virDomainEventWatchdogAction;
Thus there is a new callback definition for this event type
typedef void (*virConnectDomainEventWatchdogCallback)(virConnectPtr conn,
virDomainPtr dom,
int action,
void *opaque);
* daemon/remote.c: Dispatch watchdog events to client
* examples/domain-events/events-c/event-test.c: Watch for
watchdog events
* include/libvirt/libvirt.h.in: Define new watchdg event ID
and callback signature
* src/conf/domain_event.c, src/conf/domain_event.h,
src/libvirt_private.syms: Extend API to handle watchdog events
* src/qemu/qemu_driver.c: Connect to the QEMU monitor event
for watchdogs and emit a libvirt watchdog event
* src/remote/remote_driver.c: Receive and dispatch watchdog
events to application
* src/remote/remote_protocol.x: Wire protocol definition for
watchdog events
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c: Watch for WATCHDOG event
from QEMU monitor
2010-03-18 19:07:48 +00:00
|
|
|
int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action);
|
Add support for an explicit IO error event
This introduces a new event type
VIR_DOMAIN_EVENT_ID_IO_ERROR
This event includes the action that is about to be taken
as a result of the watchdog triggering
typedef enum {
VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0,
VIR_DOMAIN_EVENT_IO_ERROR_PAUSE,
VIR_DOMAIN_EVENT_IO_ERROR_REPORT,
} virDomainEventIOErrorAction;
In addition it has the source path of the disk that had the
error and its unique device alias. It does not include the
target device name (/dev/sda), since this would preclude
triggering IO errors from other file backed devices (eg
serial ports connected to a file)
Thus there is a new callback definition for this event type
typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
void *opaque);
This is currently wired up to the QEMU block IO error events
* daemon/remote.c: Dispatch IO error events to client
* examples/domain-events/events-c/event-test.c: Watch for
IO error events
* include/libvirt/libvirt.h.in: Define new IO error event ID
and callback signature
* src/conf/domain_event.c, src/conf/domain_event.h,
src/libvirt_private.syms: Extend API to handle IO error events
* src/qemu/qemu_driver.c: Connect to the QEMU monitor event
for block IO errors and emit a libvirt IO error event
* src/remote/remote_driver.c: Receive and dispatch IO error
events to application
* src/remote/remote_protocol.x: Wire protocol definition for
IO error events
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c: Watch for BLOCK_IO_ERROR event
from QEMU monitor
2010-03-18 19:37:44 +00:00
|
|
|
int qemuMonitorEmitIOError(qemuMonitorPtr mon,
|
|
|
|
|
const char *diskAlias,
|
Add support for another explicit IO error event
This introduces a new event type
VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON
This event is the same as the previous VIR_DOMAIN_ID_IO_ERROR
event, but also includes a string describing the cause of
the event.
Thus there is a new callback definition for this event type
typedef void (*virConnectDomainEventIOErrorReasonCallback)(virConnectPtr conn,
virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
const char *reason,
void *opaque);
This is currently wired up to the QEMU block IO error events
* daemon/remote.c: Dispatch IO error events to client
* examples/domain-events/events-c/event-test.c: Watch for
IO error events
* include/libvirt/libvirt.h.in: Define new IO error event ID
and callback signature
* src/conf/domain_event.c, src/conf/domain_event.h,
src/libvirt_private.syms: Extend API to handle IO error events
* src/qemu/qemu_driver.c: Connect to the QEMU monitor event
for block IO errors and emit a libvirt IO error event
* src/remote/remote_driver.c: Receive and dispatch IO error
events to application
* src/remote/remote_protocol.x: Wire protocol definition for
IO error events
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c: Watch for BLOCK_IO_ERROR event
from QEMU monitor
2010-03-18 19:37:44 +00:00
|
|
|
int action,
|
|
|
|
|
const char *reason);
|
Add domain events for graphics network clients
This introduces a new event type
VIR_DOMAIN_EVENT_ID_GRAPHICS
The same event can be emitted in 3 scenarios
typedef enum {
VIR_DOMAIN_EVENT_GRAPHICS_CONNECT = 0,
VIR_DOMAIN_EVENT_GRAPHICS_INITIALIZE,
VIR_DOMAIN_EVENT_GRAPHICS_DISCONNECT,
} virDomainEventGraphicsPhase;
Connect/disconnect are triggered at socket accept/close.
The initialize phase is immediately after the protocol
setup and authentication has completed. ie when the
client is authorized and about to start interacting with
the graphical desktop
This event comes with *a lot* of potential information
- IP address, port & address family of client
- IP address, port & address family of server
- Authentication scheme (arbitrary string)
- Authenticated subject identity. A subject may have
multiple identities with some authentication schemes.
For example, vencrypt+sasl results in a x509dname
and saslUsername identities.
This results in a very complicated callback :-(
typedef enum {
VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV4,
VIR_DOMAIN_EVENT_GRAPHICS_ADDRESS_IPV6,
} virDomainEventGraphicsAddressType;
struct _virDomainEventGraphicsAddress {
int family;
const char *node;
const char *service;
};
typedef struct _virDomainEventGraphicsAddress virDomainEventGraphicsAddress;
typedef virDomainEventGraphicsAddress *virDomainEventGraphicsAddressPtr;
struct _virDomainEventGraphicsSubject {
int nidentity;
struct {
const char *type;
const char *name;
} *identities;
};
typedef struct _virDomainEventGraphicsSubject virDomainEventGraphicsSubject;
typedef virDomainEventGraphicsSubject *virDomainEventGraphicsSubjectPtr;
typedef void (*virConnectDomainEventGraphicsCallback)(virConnectPtr conn,
virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject,
void *opaque);
The wire protocol is similarly complex
struct remote_domain_event_graphics_address {
int family;
remote_nonnull_string node;
remote_nonnull_string service;
};
const REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX = 20;
struct remote_domain_event_graphics_identity {
remote_nonnull_string type;
remote_nonnull_string name;
};
struct remote_domain_event_graphics_msg {
remote_nonnull_domain dom;
int phase;
remote_domain_event_graphics_address local;
remote_domain_event_graphics_address remote;
remote_nonnull_string authScheme;
remote_domain_event_graphics_identity subject<REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX>;
};
This is currently implemented in QEMU for the VNC graphics
protocol, but designed to be usable with SPICE graphics in
the future too.
* daemon/remote.c: Dispatch graphics events to client
* examples/domain-events/events-c/event-test.c: Watch for
graphics events
* include/libvirt/libvirt.h.in: Define new graphics event ID
and callback signature
* src/conf/domain_event.c, src/conf/domain_event.h,
src/libvirt_private.syms: Extend API to handle graphics events
* src/qemu/qemu_driver.c: Connect to the QEMU monitor event
for VNC events and emit a libvirt graphics event
* src/remote/remote_driver.c: Receive and dispatch graphics
events to application
* src/remote/remote_protocol.x: Wire protocol definition for
graphics events
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c: Watch for VNC_CONNECTED,
VNC_INITIALIZED & VNC_DISCONNETED events from QEMU monitor
2010-03-19 13:27:45 +00:00
|
|
|
int qemuMonitorEmitGraphics(qemuMonitorPtr mon,
|
|
|
|
|
int phase,
|
|
|
|
|
int localFamily,
|
|
|
|
|
const char *localNode,
|
|
|
|
|
const char *localService,
|
|
|
|
|
int remoteFamily,
|
|
|
|
|
const char *remoteNode,
|
|
|
|
|
const char *remoteService,
|
|
|
|
|
const char *authScheme,
|
|
|
|
|
const char *x509dname,
|
|
|
|
|
const char *saslUsername);
|
2012-03-23 13:44:50 +00:00
|
|
|
int qemuMonitorEmitTrayChange(qemuMonitorPtr mon,
|
|
|
|
|
const char *devAlias,
|
|
|
|
|
int reason);
|
2012-03-23 14:43:14 +00:00
|
|
|
int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon);
|
2012-03-23 14:50:36 +00:00
|
|
|
int qemuMonitorEmitPMSuspend(qemuMonitorPtr mon);
|
2011-07-22 05:57:42 +00:00
|
|
|
int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
|
|
|
|
|
const char *diskAlias,
|
|
|
|
|
int type,
|
|
|
|
|
int status);
|
2012-07-12 15:45:57 +00:00
|
|
|
int qemuMonitorEmitBalloonChange(qemuMonitorPtr mon,
|
|
|
|
|
unsigned long long actual);
|
2012-10-12 19:13:39 +00:00
|
|
|
int qemuMonitorEmitPMSuspendDisk(qemuMonitorPtr mon);
|
2013-06-07 10:23:34 +00:00
|
|
|
int qemuMonitorEmitGuestPanic(qemuMonitorPtr mon);
|
2013-07-11 15:07:26 +00:00
|
|
|
int qemuMonitorEmitDeviceDeleted(qemuMonitorPtr mon,
|
|
|
|
|
const char *devAlias);
|
2014-09-17 17:07:50 +00:00
|
|
|
int qemuMonitorEmitNicRxFilterChanged(qemuMonitorPtr mon,
|
|
|
|
|
const char *devAlias);
|
2014-11-13 13:09:39 +00:00
|
|
|
int qemuMonitorEmitSerialChange(qemuMonitorPtr mon,
|
|
|
|
|
const char *devAlias,
|
|
|
|
|
bool connected);
|
2015-05-28 11:35:06 +00:00
|
|
|
int qemuMonitorEmitSpiceMigrated(qemuMonitorPtr mon);
|
2015-05-28 11:35:52 +00:00
|
|
|
int qemuMonitorEmitMigrationStatus(qemuMonitorPtr mon,
|
|
|
|
|
int status);
|
2015-12-08 14:23:35 +00:00
|
|
|
int qemuMonitorEmitMigrationPass(qemuMonitorPtr mon,
|
|
|
|
|
int pass);
|
2011-07-22 05:57:42 +00:00
|
|
|
|
2016-04-01 14:41:08 +00:00
|
|
|
int qemuMonitorEmitAcpiOstInfo(qemuMonitorPtr mon,
|
|
|
|
|
const char *alias,
|
|
|
|
|
const char *slotType,
|
|
|
|
|
const char *slot,
|
|
|
|
|
unsigned int source,
|
|
|
|
|
unsigned int status);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorStartCPUs(qemuMonitorPtr mon,
|
|
|
|
|
virConnectPtr conn);
|
|
|
|
|
int qemuMonitorStopCPUs(qemuMonitorPtr mon);
|
2011-09-27 09:42:04 +00:00
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_DEBUG,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_INMIGRATE,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_INTERNAL_ERROR,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_IO_ERROR,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_PAUSED,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_POSTMIGRATE,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_PRELAUNCH,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_FINISH_MIGRATE,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_RESTORE_VM,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_RUNNING,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_SAVE_VM,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_SHUTDOWN,
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_WATCHDOG,
|
2013-06-07 10:23:34 +00:00
|
|
|
QEMU_MONITOR_VM_STATUS_GUEST_PANICKED,
|
2011-09-27 09:42:04 +00:00
|
|
|
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_LAST
|
|
|
|
|
} qemuMonitorVMStatus;
|
|
|
|
|
VIR_ENUM_DECL(qemuMonitorVMStatus)
|
|
|
|
|
int qemuMonitorVMStatusToPausedReason(const char *status);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetStatus(qemuMonitorPtr mon,
|
|
|
|
|
bool *running,
|
2015-04-14 15:00:23 +00:00
|
|
|
virDomainPausedReason *reason)
|
|
|
|
|
ATTRIBUTE_NONNULL(2);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2011-06-15 16:49:58 +00:00
|
|
|
int qemuMonitorSystemReset(qemuMonitorPtr mon);
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorSystemPowerdown(qemuMonitorPtr mon);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
|
|
|
|
|
int **pids);
|
2011-06-17 14:31:45 +00:00
|
|
|
int qemuMonitorGetVirtType(qemuMonitorPtr mon,
|
2015-09-17 08:46:56 +00:00
|
|
|
virDomainVirtType *virtType);
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
|
2012-03-02 20:27:39 +00:00
|
|
|
unsigned long long *currmem);
|
2010-04-12 11:31:15 +00:00
|
|
|
int qemuMonitorGetMemoryStats(qemuMonitorPtr mon,
|
|
|
|
|
virDomainMemoryStatPtr stats,
|
|
|
|
|
unsigned int nr_stats);
|
2013-06-27 15:00:31 +00:00
|
|
|
int qemuMonitorSetMemoryStatsPeriod(qemuMonitorPtr mon,
|
|
|
|
|
int period);
|
2012-01-18 21:01:30 +00:00
|
|
|
|
2012-01-19 16:58:58 +00:00
|
|
|
int qemuMonitorBlockIOStatusToError(const char *status);
|
2012-01-18 21:01:30 +00:00
|
|
|
virHashTablePtr qemuMonitorGetBlockInfo(qemuMonitorPtr mon);
|
|
|
|
|
struct qemuDomainDiskInfo *
|
|
|
|
|
qemuMonitorBlockInfoLookup(virHashTablePtr blockInfo,
|
2014-10-01 14:07:46 +00:00
|
|
|
const char *dev_name);
|
2012-01-18 21:01:30 +00:00
|
|
|
|
2014-09-15 08:48:09 +00:00
|
|
|
typedef struct _qemuBlockStats qemuBlockStats;
|
|
|
|
|
typedef qemuBlockStats *qemuBlockStatsPtr;
|
|
|
|
|
struct _qemuBlockStats {
|
|
|
|
|
long long rd_req;
|
|
|
|
|
long long rd_bytes;
|
|
|
|
|
long long wr_req;
|
|
|
|
|
long long wr_bytes;
|
|
|
|
|
long long rd_total_times;
|
|
|
|
|
long long wr_total_times;
|
|
|
|
|
long long flush_req;
|
|
|
|
|
long long flush_total_times;
|
2014-09-25 10:03:26 +00:00
|
|
|
unsigned long long capacity;
|
|
|
|
|
unsigned long long physical;
|
2015-06-23 14:58:07 +00:00
|
|
|
|
|
|
|
|
/* value of wr_highest_offset is valid if it's non 0 or
|
|
|
|
|
* if wr_highest_offset_valid is true */
|
2014-09-15 15:42:52 +00:00
|
|
|
unsigned long long wr_highest_offset;
|
2015-06-23 14:58:07 +00:00
|
|
|
bool wr_highest_offset_valid;
|
2014-09-15 08:48:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetAllBlockStatsInfo(qemuMonitorPtr mon,
|
2014-12-11 22:28:41 +00:00
|
|
|
virHashTablePtr *ret_stats,
|
|
|
|
|
bool backingChain)
|
2014-09-25 08:12:15 +00:00
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
|
2014-09-15 08:48:09 +00:00
|
|
|
|
2014-09-25 10:03:26 +00:00
|
|
|
int qemuMonitorBlockStatsUpdateCapacity(qemuMonitorPtr mon,
|
2014-12-11 22:28:41 +00:00
|
|
|
virHashTablePtr stats,
|
|
|
|
|
bool backingChain)
|
2014-09-25 10:03:26 +00:00
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
|
|
|
|
|
|
2011-11-29 07:34:53 +00:00
|
|
|
int qemuMonitorBlockResize(qemuMonitorPtr mon,
|
2014-10-01 14:07:46 +00:00
|
|
|
const char *dev_name,
|
2011-11-29 07:34:53 +00:00
|
|
|
unsigned long long size);
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
|
|
|
|
|
const char *password);
|
2011-01-10 11:12:32 +00:00
|
|
|
int qemuMonitorSetPassword(qemuMonitorPtr mon,
|
|
|
|
|
int type,
|
|
|
|
|
const char *password,
|
|
|
|
|
const char *action_if_connected);
|
|
|
|
|
int qemuMonitorExpirePassword(qemuMonitorPtr mon,
|
|
|
|
|
int type,
|
|
|
|
|
const char *expire_time);
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorSetBalloon(qemuMonitorPtr mon,
|
2015-05-27 12:03:17 +00:00
|
|
|
unsigned long long newmem);
|
2013-05-27 13:35:35 +00:00
|
|
|
int qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, bool online);
|
2010-02-08 16:37:17 +00:00
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
/* XXX should we pass the virDomainDiskDefPtr instead
|
2014-10-01 14:07:46 +00:00
|
|
|
* and hide dev_name details inside monitor. Reconsider
|
2009-10-09 20:13:06 +00:00
|
|
|
* this when doing the QMP implementation
|
|
|
|
|
*/
|
|
|
|
|
int qemuMonitorEjectMedia(qemuMonitorPtr mon,
|
2011-09-16 12:05:58 +00:00
|
|
|
const char *dev_name,
|
2010-11-08 17:52:48 +00:00
|
|
|
bool force);
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorChangeMedia(qemuMonitorPtr mon,
|
2011-09-16 12:05:58 +00:00
|
|
|
const char *dev_name,
|
2009-11-26 13:48:17 +00:00
|
|
|
const char *newmedia,
|
|
|
|
|
const char *format);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
2010-03-17 15:53:14 +00:00
|
|
|
int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon,
|
|
|
|
|
unsigned long long downtime);
|
|
|
|
|
|
2013-02-18 20:54:58 +00:00
|
|
|
int qemuMonitorGetMigrationCacheSize(qemuMonitorPtr mon,
|
|
|
|
|
unsigned long long *cacheSize);
|
|
|
|
|
int qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon,
|
|
|
|
|
unsigned long long cacheSize);
|
|
|
|
|
|
2016-04-14 10:33:49 +00:00
|
|
|
typedef struct _qemuMonitorMigrationCompression qemuMonitorMigrationCompression;
|
|
|
|
|
typedef qemuMonitorMigrationCompression *qemuMonitorMigrationCompressionPtr;
|
|
|
|
|
struct _qemuMonitorMigrationCompression {
|
|
|
|
|
bool level_set;
|
|
|
|
|
bool threads_set;
|
|
|
|
|
bool dthreads_set;
|
|
|
|
|
|
|
|
|
|
int level;
|
|
|
|
|
int threads;
|
|
|
|
|
int dthreads;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetMigrationCompression(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMigrationCompressionPtr compress);
|
|
|
|
|
int qemuMonitorSetMigrationCompression(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMigrationCompressionPtr compress);
|
|
|
|
|
|
2015-11-26 12:24:31 +00:00
|
|
|
typedef enum {
|
2009-10-09 20:13:06 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_INACTIVE,
|
2015-11-26 11:45:25 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_SETUP,
|
2009-10-09 20:13:06 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_ACTIVE,
|
2015-11-26 14:37:23 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY,
|
2009-10-09 20:13:06 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_COMPLETED,
|
|
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_ERROR,
|
2015-03-06 16:30:14 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_CANCELLING,
|
2009-10-09 20:13:06 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_CANCELLED,
|
|
|
|
|
|
|
|
|
|
QEMU_MONITOR_MIGRATION_STATUS_LAST
|
2015-11-26 12:24:31 +00:00
|
|
|
} qemuMonitorMigrationStatus;
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2009-11-26 13:37:11 +00:00
|
|
|
VIR_ENUM_DECL(qemuMonitorMigrationStatus)
|
|
|
|
|
|
2015-11-26 12:23:08 +00:00
|
|
|
typedef struct _qemuMonitorMigrationStats qemuMonitorMigrationStats;
|
|
|
|
|
typedef qemuMonitorMigrationStats *qemuMonitorMigrationStatsPtr;
|
|
|
|
|
struct _qemuMonitorMigrationStats {
|
2015-11-26 12:24:31 +00:00
|
|
|
int status; /* qemuMonitorMigrationStatus */
|
2013-02-08 08:58:03 +00:00
|
|
|
unsigned long long total_time;
|
|
|
|
|
/* total or expected depending on status */
|
|
|
|
|
bool downtime_set;
|
|
|
|
|
unsigned long long downtime;
|
2014-01-13 06:28:10 +00:00
|
|
|
/*
|
|
|
|
|
* Duration of the QEMU 'setup' state.
|
|
|
|
|
* for RDMA, this may be on the order of several seconds
|
|
|
|
|
* if pinning support is requested before the migration begins.
|
|
|
|
|
*/
|
|
|
|
|
bool setup_time_set;
|
|
|
|
|
unsigned long long setup_time;
|
2013-02-08 08:58:03 +00:00
|
|
|
|
|
|
|
|
unsigned long long ram_transferred;
|
|
|
|
|
unsigned long long ram_remaining;
|
|
|
|
|
unsigned long long ram_total;
|
2014-01-13 06:28:10 +00:00
|
|
|
unsigned long long ram_bps;
|
2013-02-08 08:58:03 +00:00
|
|
|
bool ram_duplicate_set;
|
|
|
|
|
unsigned long long ram_duplicate;
|
|
|
|
|
unsigned long long ram_normal;
|
|
|
|
|
unsigned long long ram_normal_bytes;
|
2015-11-27 11:30:09 +00:00
|
|
|
unsigned long long ram_dirty_rate;
|
|
|
|
|
unsigned long long ram_iteration;
|
2013-02-08 08:58:03 +00:00
|
|
|
|
|
|
|
|
unsigned long long disk_transferred;
|
|
|
|
|
unsigned long long disk_remaining;
|
|
|
|
|
unsigned long long disk_total;
|
2014-01-13 06:28:10 +00:00
|
|
|
unsigned long long disk_bps;
|
2013-02-08 08:58:03 +00:00
|
|
|
|
|
|
|
|
bool xbzrle_set;
|
|
|
|
|
unsigned long long xbzrle_cache_size;
|
|
|
|
|
unsigned long long xbzrle_bytes;
|
|
|
|
|
unsigned long long xbzrle_pages;
|
|
|
|
|
unsigned long long xbzrle_cache_miss;
|
|
|
|
|
unsigned long long xbzrle_overflow;
|
|
|
|
|
};
|
|
|
|
|
|
2015-11-26 12:23:08 +00:00
|
|
|
int qemuMonitorGetMigrationStats(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMigrationStatsPtr stats);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2013-01-14 11:45:20 +00:00
|
|
|
typedef enum {
|
|
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_XBZRLE,
|
2014-02-06 23:44:36 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_AUTO_CONVERGE,
|
2014-09-11 12:11:54 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_RDMA_PIN_ALL,
|
2015-07-07 16:17:25 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_EVENTS,
|
2014-12-01 15:59:54 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_POSTCOPY,
|
2016-04-14 10:33:48 +00:00
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_COMPRESS,
|
2013-01-14 11:45:20 +00:00
|
|
|
|
|
|
|
|
QEMU_MONITOR_MIGRATION_CAPS_LAST
|
|
|
|
|
} qemuMonitorMigrationCaps;
|
|
|
|
|
|
|
|
|
|
VIR_ENUM_DECL(qemuMonitorMigrationCaps);
|
|
|
|
|
|
2014-09-11 12:11:54 +00:00
|
|
|
int qemuMonitorGetMigrationCapabilities(qemuMonitorPtr mon,
|
|
|
|
|
char ***capabilities);
|
2013-01-14 11:45:20 +00:00
|
|
|
int qemuMonitorGetMigrationCapability(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMigrationCaps capability);
|
|
|
|
|
int qemuMonitorSetMigrationCapability(qemuMonitorPtr mon,
|
2014-11-10 13:46:26 +00:00
|
|
|
qemuMonitorMigrationCaps capability,
|
|
|
|
|
bool state);
|
2013-01-14 11:45:20 +00:00
|
|
|
|
2016-03-08 17:24:18 +00:00
|
|
|
int qemuMonitorGetGICCapabilities(qemuMonitorPtr mon,
|
|
|
|
|
virGICCapability **capabilities);
|
|
|
|
|
|
2010-05-04 21:36:42 +00:00
|
|
|
typedef enum {
|
2010-12-21 15:58:03 +00:00
|
|
|
QEMU_MONITOR_MIGRATE_BACKGROUND = 1 << 0,
|
2010-05-04 21:36:42 +00:00
|
|
|
QEMU_MONITOR_MIGRATE_NON_SHARED_DISK = 1 << 1, /* migration with non-shared storage with full disk copy */
|
|
|
|
|
QEMU_MONITOR_MIGRATE_NON_SHARED_INC = 1 << 2, /* migration with non-shared storage with incremental copy */
|
|
|
|
|
QEMU_MONITOR_MIGRATION_FLAGS_LAST
|
|
|
|
|
} QEMU_MONITOR_MIGRATE;
|
|
|
|
|
|
2011-03-02 04:37:30 +00:00
|
|
|
int qemuMonitorMigrateToFd(qemuMonitorPtr mon,
|
|
|
|
|
unsigned int flags,
|
|
|
|
|
int fd);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
|
2010-06-24 18:58:36 +00:00
|
|
|
unsigned int flags,
|
2014-09-15 16:15:42 +00:00
|
|
|
const char *protocol,
|
2009-10-09 20:13:06 +00:00
|
|
|
const char *hostname,
|
|
|
|
|
int port);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
|
2010-06-24 18:58:36 +00:00
|
|
|
unsigned int flags,
|
2010-04-21 13:06:37 +00:00
|
|
|
const char * const *argv);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
|
2010-06-24 18:58:36 +00:00
|
|
|
unsigned int flags,
|
2009-10-09 20:13:06 +00:00
|
|
|
const char *unixfile);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorMigrateCancel(qemuMonitorPtr mon);
|
|
|
|
|
|
2014-03-23 03:51:13 +00:00
|
|
|
int qemuMonitorGetDumpGuestMemoryCapability(qemuMonitorPtr mon,
|
|
|
|
|
const char *capability);
|
|
|
|
|
|
2012-06-12 03:04:51 +00:00
|
|
|
int qemuMonitorDumpToFd(qemuMonitorPtr mon,
|
2014-03-23 03:51:14 +00:00
|
|
|
int fd,
|
|
|
|
|
const char *dumpformat);
|
2012-06-12 03:04:51 +00:00
|
|
|
|
2011-02-17 13:39:36 +00:00
|
|
|
int qemuMonitorGraphicsRelocate(qemuMonitorPtr mon,
|
|
|
|
|
int type,
|
|
|
|
|
const char *hostname,
|
|
|
|
|
int port,
|
|
|
|
|
int tlsPort,
|
|
|
|
|
const char *tlsSubject);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
|
|
|
|
|
const char *fdname,
|
|
|
|
|
int fd);
|
2013-01-31 00:18:44 +00:00
|
|
|
int qemuMonitorAddFd(qemuMonitorPtr mon, int fdset, int fd, const char *name);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2013-01-31 00:18:44 +00:00
|
|
|
/* These two functions preserve previous error and only set their own
|
|
|
|
|
* error if no error was set before.
|
2011-07-13 09:16:20 +00:00
|
|
|
*/
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
|
|
|
|
|
const char *fdname);
|
2013-01-31 00:18:44 +00:00
|
|
|
int qemuMonitorRemoveFd(qemuMonitorPtr mon, int fdset, int fd);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
/* XXX do we really want to hardcode 'netstr' as the
|
|
|
|
|
* sendable item here
|
|
|
|
|
*/
|
|
|
|
|
int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
|
2011-03-16 02:21:45 +00:00
|
|
|
const char *netstr,
|
2013-05-21 13:50:09 +00:00
|
|
|
int *tapfd, char **tapfdName, int tapfdSize,
|
|
|
|
|
int *vhostfd, char **vhostfdName, int vhostfdSize);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
|
|
|
|
|
int vlan,
|
|
|
|
|
const char *netname);
|
|
|
|
|
|
2010-04-15 13:52:03 +00:00
|
|
|
int qemuMonitorAddNetdev(qemuMonitorPtr mon,
|
2011-03-16 02:21:45 +00:00
|
|
|
const char *netdevstr,
|
2013-05-21 13:50:09 +00:00
|
|
|
int *tapfd, char **tapfdName, int tapfdSize,
|
|
|
|
|
int *vhostfd, char **vhostfdName, int vhostfdSize);
|
2010-04-15 13:52:03 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorRemoveNetdev(qemuMonitorPtr mon,
|
|
|
|
|
const char *alias);
|
|
|
|
|
|
qemu: qemuMonitorQueryRxFilter - retrieve guest netdev rx-filter
This function can be called at any time to get the current status of a
guest's network device rx-filter. In particular it is useful to call
after libvirt recieves a NIC_RX_FILTER_CHANGED event - this event only
tells you that something has changed in the rx-filter, the details are
retrieved with the query-rx-filter monitor command (only available in
the json monitor). The command sent to the qemu monitor looks like this:
{"execute":"query-rx-filter", "arguments": {"name":"net2"} }'
and the results will look something like this:
{
"return": [
{
"promiscuous": false,
"name": "net2",
"main-mac": "52:54:00:98:2d:e3",
"unicast": "normal",
"vlan": "normal",
"vlan-table": [
42,
0
],
"unicast-table": [
],
"multicast": "normal",
"multicast-overflow": false,
"unicast-overflow": false,
"multicast-table": [
"33:33:ff:98:2d:e3",
"01:80:c2:00:00:21",
"01:00:5e:00:00:fb",
"33:33:ff:98:2d:e2",
"01:00:5e:00:00:01",
"33:33:00:00:00:01"
],
"broadcast-allowed": false
}
],
"id": "libvirt-14"
}
This is all parsed from JSON into a virNetDevRxFilter object for
easier consumption. (unicast-table is usually empty, but is also an
array of mac addresses similar to multicast-table).
(NB: LIBNL_CFLAGS was added to tests/Makefile.am because virnetdev.h
now includes util/virnetlink.h, which includes netlink/msg.h when
appropriate. Without LIBNL_CFLAGS, gcc can't find that file (if
libnl/netlink isn't available, LIBNL_CFLAGS will be empty and
virnetlink.h won't try to include netlink/msg.h anyway).)
2014-09-22 16:19:41 +00:00
|
|
|
int qemuMonitorQueryRxFilter(qemuMonitorPtr mon, const char *alias,
|
|
|
|
|
virNetDevRxFilterPtr *filter);
|
|
|
|
|
|
2014-11-13 18:29:14 +00:00
|
|
|
typedef struct _qemuMonitorChardevInfo qemuMonitorChardevInfo;
|
|
|
|
|
typedef qemuMonitorChardevInfo *qemuMonitorChardevInfoPtr;
|
|
|
|
|
struct _qemuMonitorChardevInfo {
|
|
|
|
|
char *ptyPath;
|
|
|
|
|
virDomainChrDeviceState state;
|
|
|
|
|
};
|
2015-04-28 01:16:12 +00:00
|
|
|
void qemuMonitorChardevInfoFree(void *data, const void *name);
|
2014-11-13 15:17:21 +00:00
|
|
|
int qemuMonitorGetChardevInfo(qemuMonitorPtr mon,
|
|
|
|
|
virHashTablePtr *retinfo);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
|
|
|
|
|
const char *bus,
|
2016-04-03 18:16:51 +00:00
|
|
|
virPCIDeviceAddress *guestAddr);
|
2009-12-07 19:28:05 +00:00
|
|
|
|
Detect PCI addresses at QEMU startup
Hotunplug of devices requires that we know their PCI address. Even
hotplug of SCSI drives, required that we know the PCI address of
the SCSI controller to attach the drive to. We can find this out
by running 'info pci' and then correlating the vendor/product IDs
with the devices we booted with.
Although this approach is somewhat fragile, it is the only viable
option with QEMU < 0.12, since there is no way for libvirto set
explicit PCI addresses when creating devices in the first place.
For QEMU > 0.12, this code will not be used.
* src/qemu/qemu_driver.c: Assign all dynamic PCI addresses on
startup of QEMU VM, matching vendor/product IDs
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
API for fetching PCI device address mapping
2009-12-09 21:59:04 +00:00
|
|
|
typedef struct _qemuMonitorPCIAddress qemuMonitorPCIAddress;
|
|
|
|
|
struct _qemuMonitorPCIAddress {
|
|
|
|
|
unsigned int vendor;
|
|
|
|
|
unsigned int product;
|
2016-04-03 18:16:51 +00:00
|
|
|
virPCIDeviceAddress addr;
|
Detect PCI addresses at QEMU startup
Hotunplug of devices requires that we know their PCI address. Even
hotplug of SCSI drives, required that we know the PCI address of
the SCSI controller to attach the drive to. We can find this out
by running 'info pci' and then correlating the vendor/product IDs
with the devices we booted with.
Although this approach is somewhat fragile, it is the only viable
option with QEMU < 0.12, since there is no way for libvirto set
explicit PCI addresses when creating devices in the first place.
For QEMU > 0.12, this code will not be used.
* src/qemu/qemu_driver.c: Assign all dynamic PCI addresses on
startup of QEMU VM, matching vendor/product IDs
* src/qemu/qemu_monitor.c, src/qemu/qemu_monitor.h,
src/qemu/qemu_monitor_json.c, src/qemu/qemu_monitor_json.h,
src/qemu/qemu_monitor_text.c, src/qemu/qemu_monitor_text.h: Add
API for fetching PCI device address mapping
2009-12-09 21:59:04 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetAllPCIAddresses(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorPCIAddress **addrs);
|
|
|
|
|
|
2010-01-26 15:34:46 +00:00
|
|
|
int qemuMonitorAddDevice(qemuMonitorPtr mon,
|
|
|
|
|
const char *devicestr);
|
|
|
|
|
|
2011-03-15 23:10:16 +00:00
|
|
|
int qemuMonitorAddDeviceWithFd(qemuMonitorPtr mon,
|
|
|
|
|
const char *devicestr,
|
|
|
|
|
int fd,
|
|
|
|
|
const char *fdname);
|
|
|
|
|
|
2010-03-02 08:40:51 +00:00
|
|
|
int qemuMonitorDelDevice(qemuMonitorPtr mon,
|
2010-04-14 14:36:42 +00:00
|
|
|
const char *devalias);
|
2010-03-02 08:40:51 +00:00
|
|
|
|
2014-09-23 11:25:25 +00:00
|
|
|
int qemuMonitorAddObject(qemuMonitorPtr mon,
|
|
|
|
|
const char *type,
|
|
|
|
|
const char *objalias,
|
|
|
|
|
virJSONValuePtr props);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorDelObject(qemuMonitorPtr mon,
|
|
|
|
|
const char *objalias);
|
|
|
|
|
|
2010-01-26 15:34:46 +00:00
|
|
|
int qemuMonitorAddDrive(qemuMonitorPtr mon,
|
|
|
|
|
const char *drivestr);
|
|
|
|
|
|
2010-12-08 21:30:12 +00:00
|
|
|
int qemuMonitorDriveDel(qemuMonitorPtr mon,
|
2010-10-22 14:14:22 +00:00
|
|
|
const char *drivestr);
|
|
|
|
|
|
2010-02-11 14:28:16 +00:00
|
|
|
int qemuMonitorSetDrivePassphrase(qemuMonitorPtr mon,
|
|
|
|
|
const char *alias,
|
|
|
|
|
const char *passphrase);
|
|
|
|
|
|
2010-04-02 14:10:37 +00:00
|
|
|
int qemuMonitorCreateSnapshot(qemuMonitorPtr mon, const char *name);
|
|
|
|
|
int qemuMonitorLoadSnapshot(qemuMonitorPtr mon, const char *name);
|
|
|
|
|
int qemuMonitorDeleteSnapshot(qemuMonitorPtr mon, const char *name);
|
|
|
|
|
|
2011-08-15 23:25:54 +00:00
|
|
|
int qemuMonitorDiskSnapshot(qemuMonitorPtr mon,
|
2012-03-17 04:17:28 +00:00
|
|
|
virJSONValuePtr actions,
|
2011-08-15 23:25:54 +00:00
|
|
|
const char *device,
|
snapshot: improve qemu handling of reused snapshot targets
The oVirt developers have stated that the real reasons they want
to have qemu reuse existing volumes when creating a snapshot are:
1. the management framework is set up so that creation has to be
done from a central node for proper resource tracking, and having
libvirt and/or qemu create things violates the framework, and
2. qemu defaults to creating snapshots with an absolute path to
the backing file, but oVirt wants to manage a backing chain that
uses just relative names, to allow for easier migration of a chain
across storage locations.
When 0.9.10 added VIR_DOMAIN_SNAPSHOT_CREATE_REUSE_EXT (commit
4e9953a4), it only addressed point 1, but libvirt was still using
O_TRUNC which violates point 2. Meanwhile, the new qemu
'transaction' monitor command includes a new optional mode argument
that will force qemu to reuse the metadata of the file it just
opened (with the burden on the caller to have valid metadata there
in the first place). So, this tweaks the meaning of the flag to
cover both points as intended for use by oVirt. It is not strictly
backward-compatible to 0.9.10 behavior, but it can be argued that
the O_TRUNC of 0.9.10 was a bug.
Note that this flag is all-or-nothing, and only selects between
'existing' and the default 'absolute-paths'. A more flexible
approach that would allow per-disk selections, as well as adding
support for the 'no-backing-file' mode, would be possible by
extending the <domainsnapshot> xml to have a per-disk mode, but
until we have a management application expressing a need for that
additional complexity, it is not worth doing.
* src/libvirt.c (virDomainSnapshotCreateXML): Tweak documentation.
* src/qemu/qemu_monitor.h (qemuMonitorDiskSnapshot): Add
parameters.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDiskSnapshot):
Likewise.
* src/qemu/qemu_monitor.c (qemuMonitorDiskSnapshot): Pass them
through.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONDiskSnapshot): Use
new monitor command arguments.
* src/qemu/qemu_driver.c (qemuDomainSnapshotCreateDiskActive)
(qemuDomainSnapshotCreateSingleDiskActive): Adjust callers.
(qemuDomainSnapshotDiskPrepare): Allow qed, modify rules on reuse.
2012-03-20 21:03:45 +00:00
|
|
|
const char *file,
|
|
|
|
|
const char *format,
|
|
|
|
|
bool reuse);
|
2012-03-17 04:17:28 +00:00
|
|
|
int qemuMonitorTransaction(qemuMonitorPtr mon, virJSONValuePtr actions)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2);
|
blockjob: add qemu capabilities related to block jobs
Upstream qemu 1.3 is adding two new monitor commands, 'drive-mirror'
and 'block-job-complete'[1], which can drive live block copy and
storage migration. [Additionally, RHEL 6.3 had backported an earlier
version of most of the same functionality, but under the names
'__com.redhat_drive-mirror' and '__com.redhat_drive-reopen' and with
slightly different JSON arguments, and has been using patches similar
to these upstream patches for several months now.]
The libvirt API virDomainBlockRebase as already committed for 0.9.12
is flexible enough to expose the basics of block copy, but some
additional features in the 'drive-mirror' qemu command, such as
setting error policy, setting granularity, or using a persistent
bitmap, may later require a new libvirt API virDomainBlockCopy. I
will wait to add that API until we know more about what qemu 1.3
will finally provide.
This patch caters only to the upstream qemu 1.3 interface, although
I have proven that the changes for RHEL 6.3 can be isolated to
just qemu_monitor_json.c, and the rest of this series will
gracefully handle either interface once the JSON differences are
papered over in a downstream patch.
For consistency with other block job commands, libvirt must handle
the bandwidth argument as MiB/sec from the user, even though qemu
exposes the speed argument as bytes/sec; then again, qemu rounds
up to cluster size internally, so using MiB hides the worst effects
of that rounding if you pass small numbers.
[1]https://lists.gnu.org/archive/html/qemu-devel/2012-10/msg04123.html
* src/qemu/qemu_capabilities.h (QEMU_CAPS_DRIVE_MIRROR)
(QEMU_CAPS_DRIVE_REOPEN): New bits.
* src/qemu/qemu_capabilities.c (qemuCaps): Name them.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONCheckCommands): Set
them.
(qemuMonitorJSONDriveMirror, qemuMonitorDrivePivot): New functions.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDriveMirror)
(qemuMonitorDrivePivot): Declare them.
* src/qemu/qemu_monitor.c (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): New passthroughs.
* src/qemu/qemu_monitor.h (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): Declare them.
2012-09-28 23:29:53 +00:00
|
|
|
int qemuMonitorDriveMirror(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
const char *file,
|
|
|
|
|
const char *format,
|
blockjob: hoist bandwidth scaling out of monitor code
qemu treats blockjob bandwidth as a 64-bit number, in the units
of bytes/second. But we stupidly modeled block job bandwidth
after migration bandwidth, which in turn was an 'unsigned long'
and therefore subject to 32-bit vs. 64-bit interpretations, and
with a scale of MiB/s. Our code already has to convert between
the two scales, and report overflow as appropriate; although
this conversion currently lives in the monitor code. In fact,
our conversion code limited things to 63 bits, because we
checked against LLONG_MAX and reject what would be negative
bandwidth if treated as signed.
On the bright side, our use of MiB/s means that even with a
32-bit unsigned long, we still have no problem representing a
bandwidth of 2GiB/s, which is starting to be more feasible as
10-gigabit or even faster interfaces are used. And once you
get past the physical speeds of existing interfaces, any larger
bandwidth number behaves the same - effectively unlimited.
But on the low side, the granularity of 1MiB/s tuning is rather
coarse. So the new virDomainBlockJob API decided to go with
a direct 64-bit bytes/sec number instead of the scaled number
that prior blockjob APIs had used. But there is no point in
rounding this number to MiB/s just to scale it back to bytes/s
for handing to qemu.
In order to make future code sharing possible between the old
virDomainBlockRebase and the new virDomainBlockCopy, this patch
moves the scaling and overflow detection into the driver code.
Several of the block job calls that can set speed are fed
through a common interface, so it was easier to adjust all block
jobs at once, for consistency. This patch is just code motion;
there should be no user-visible change in behavior.
* src/qemu/qemu_monitor.h (qemuMonitorBlockJob)
(qemuMonitorBlockCommit, qemuMonitorDriveMirror): Change
parameter type and scale.
* src/qemu/qemu_monitor.c (qemuMonitorBlockJob)
(qemuMonitorBlockCommit, qemuMonitorDriveMirror): Move scaling
and overflow detection...
* src/qemu/qemu_driver.c (qemuDomainBlockJobImpl)
(qemuDomainBlockRebase, qemuDomainBlockCommit): ...here.
(qemuDomainBlockCopy): Use bytes/sec.
Signed-off-by: Eric Blake <eblake@redhat.com>
2014-08-29 19:58:45 +00:00
|
|
|
unsigned long long bandwidth,
|
blockcopy: add qemu implementation of new tunables
Upstream qemu 1.4 added some drive-mirror tunables not present
when it was first introduced in 1.3. Management apps may want
to set these in some cases (for example, without tuning
granularity down to sector size, a copy may end up occupying
more bytes than the original because an entire cluster is
copied even when only a sector within the cluster is dirty,
although tuning it down results in more CPU time to do the
copy). I haven't personally needed to use the parameters, but
since they exist, and since the new API supports virTypedParams,
we might as well expose them.
Since the tuning parameters aren't often used, and omitted from
the QMP command when unspecified, I think it is safe to rely on
qemu 1.3 to issue an error about them being unsupported, rather
than trying to create a new capability bit in libvirt.
Meanwhile, all versions of qemu from 1.4 to 2.1 have a bug where
a bad granularity (such as non-power-of-2) gives a poor message:
error: internal error: unable to execute QEMU command 'drive-mirror': Invalid parameter 'drive-virtio-disk0'
because of abuse of QERR_INVALID_PARAMETER (which is supposed to
name the parameter that was given a bad value, rather than the
value passed to some other parameter). I don't see that a
capability check will help, so we'll just live with it (and it
has since been improved in upstream qemu).
* src/qemu/qemu_monitor.h (qemuMonitorDriveMirror): Add
parameters.
* src/qemu/qemu_monitor.c (qemuMonitorDriveMirror): Likewise.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDriveMirror):
Likewise.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONDriveMirror):
Likewise.
* src/qemu/qemu_driver.c (qemuDomainBlockCopyCommon): Likewise.
(qemuDomainBlockRebase, qemuDomainBlockCopy): Adjust callers.
* src/qemu/qemu_migration.c (qemuMigrationDriveMirror): Likewise.
* tests/qemumonitorjsontest.c (qemuMonitorJSONDriveMirror): Likewise.
Signed-off-by: Eric Blake <eblake@redhat.com>
2014-09-08 20:53:12 +00:00
|
|
|
unsigned int granularity,
|
|
|
|
|
unsigned long long buf_size,
|
blockjob: add qemu capabilities related to block jobs
Upstream qemu 1.3 is adding two new monitor commands, 'drive-mirror'
and 'block-job-complete'[1], which can drive live block copy and
storage migration. [Additionally, RHEL 6.3 had backported an earlier
version of most of the same functionality, but under the names
'__com.redhat_drive-mirror' and '__com.redhat_drive-reopen' and with
slightly different JSON arguments, and has been using patches similar
to these upstream patches for several months now.]
The libvirt API virDomainBlockRebase as already committed for 0.9.12
is flexible enough to expose the basics of block copy, but some
additional features in the 'drive-mirror' qemu command, such as
setting error policy, setting granularity, or using a persistent
bitmap, may later require a new libvirt API virDomainBlockCopy. I
will wait to add that API until we know more about what qemu 1.3
will finally provide.
This patch caters only to the upstream qemu 1.3 interface, although
I have proven that the changes for RHEL 6.3 can be isolated to
just qemu_monitor_json.c, and the rest of this series will
gracefully handle either interface once the JSON differences are
papered over in a downstream patch.
For consistency with other block job commands, libvirt must handle
the bandwidth argument as MiB/sec from the user, even though qemu
exposes the speed argument as bytes/sec; then again, qemu rounds
up to cluster size internally, so using MiB hides the worst effects
of that rounding if you pass small numbers.
[1]https://lists.gnu.org/archive/html/qemu-devel/2012-10/msg04123.html
* src/qemu/qemu_capabilities.h (QEMU_CAPS_DRIVE_MIRROR)
(QEMU_CAPS_DRIVE_REOPEN): New bits.
* src/qemu/qemu_capabilities.c (qemuCaps): Name them.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONCheckCommands): Set
them.
(qemuMonitorJSONDriveMirror, qemuMonitorDrivePivot): New functions.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDriveMirror)
(qemuMonitorDrivePivot): Declare them.
* src/qemu/qemu_monitor.c (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): New passthroughs.
* src/qemu/qemu_monitor.h (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): Declare them.
2012-09-28 23:29:53 +00:00
|
|
|
unsigned int flags)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
blockjob: add qemu capabilities related to block jobs
Upstream qemu 1.3 is adding two new monitor commands, 'drive-mirror'
and 'block-job-complete'[1], which can drive live block copy and
storage migration. [Additionally, RHEL 6.3 had backported an earlier
version of most of the same functionality, but under the names
'__com.redhat_drive-mirror' and '__com.redhat_drive-reopen' and with
slightly different JSON arguments, and has been using patches similar
to these upstream patches for several months now.]
The libvirt API virDomainBlockRebase as already committed for 0.9.12
is flexible enough to expose the basics of block copy, but some
additional features in the 'drive-mirror' qemu command, such as
setting error policy, setting granularity, or using a persistent
bitmap, may later require a new libvirt API virDomainBlockCopy. I
will wait to add that API until we know more about what qemu 1.3
will finally provide.
This patch caters only to the upstream qemu 1.3 interface, although
I have proven that the changes for RHEL 6.3 can be isolated to
just qemu_monitor_json.c, and the rest of this series will
gracefully handle either interface once the JSON differences are
papered over in a downstream patch.
For consistency with other block job commands, libvirt must handle
the bandwidth argument as MiB/sec from the user, even though qemu
exposes the speed argument as bytes/sec; then again, qemu rounds
up to cluster size internally, so using MiB hides the worst effects
of that rounding if you pass small numbers.
[1]https://lists.gnu.org/archive/html/qemu-devel/2012-10/msg04123.html
* src/qemu/qemu_capabilities.h (QEMU_CAPS_DRIVE_MIRROR)
(QEMU_CAPS_DRIVE_REOPEN): New bits.
* src/qemu/qemu_capabilities.c (qemuCaps): Name them.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONCheckCommands): Set
them.
(qemuMonitorJSONDriveMirror, qemuMonitorDrivePivot): New functions.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDriveMirror)
(qemuMonitorDrivePivot): Declare them.
* src/qemu/qemu_monitor.c (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): New passthroughs.
* src/qemu/qemu_monitor.h (qemuMonitorDriveMirror)
(qemuMonitorDrivePivot): Declare them.
2012-09-28 23:29:53 +00:00
|
|
|
int qemuMonitorDrivePivot(qemuMonitorPtr mon,
|
2015-04-01 08:06:55 +00:00
|
|
|
const char *device)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2);
|
2011-08-15 23:25:54 +00:00
|
|
|
|
2012-10-03 21:13:21 +00:00
|
|
|
int qemuMonitorBlockCommit(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
const char *top,
|
|
|
|
|
const char *base,
|
2014-05-13 15:41:33 +00:00
|
|
|
const char *backingName,
|
blockjob: hoist bandwidth scaling out of monitor code
qemu treats blockjob bandwidth as a 64-bit number, in the units
of bytes/second. But we stupidly modeled block job bandwidth
after migration bandwidth, which in turn was an 'unsigned long'
and therefore subject to 32-bit vs. 64-bit interpretations, and
with a scale of MiB/s. Our code already has to convert between
the two scales, and report overflow as appropriate; although
this conversion currently lives in the monitor code. In fact,
our conversion code limited things to 63 bits, because we
checked against LLONG_MAX and reject what would be negative
bandwidth if treated as signed.
On the bright side, our use of MiB/s means that even with a
32-bit unsigned long, we still have no problem representing a
bandwidth of 2GiB/s, which is starting to be more feasible as
10-gigabit or even faster interfaces are used. And once you
get past the physical speeds of existing interfaces, any larger
bandwidth number behaves the same - effectively unlimited.
But on the low side, the granularity of 1MiB/s tuning is rather
coarse. So the new virDomainBlockJob API decided to go with
a direct 64-bit bytes/sec number instead of the scaled number
that prior blockjob APIs had used. But there is no point in
rounding this number to MiB/s just to scale it back to bytes/s
for handing to qemu.
In order to make future code sharing possible between the old
virDomainBlockRebase and the new virDomainBlockCopy, this patch
moves the scaling and overflow detection into the driver code.
Several of the block job calls that can set speed are fed
through a common interface, so it was easier to adjust all block
jobs at once, for consistency. This patch is just code motion;
there should be no user-visible change in behavior.
* src/qemu/qemu_monitor.h (qemuMonitorBlockJob)
(qemuMonitorBlockCommit, qemuMonitorDriveMirror): Change
parameter type and scale.
* src/qemu/qemu_monitor.c (qemuMonitorBlockJob)
(qemuMonitorBlockCommit, qemuMonitorDriveMirror): Move scaling
and overflow detection...
* src/qemu/qemu_driver.c (qemuDomainBlockJobImpl)
(qemuDomainBlockRebase, qemuDomainBlockCommit): ...here.
(qemuDomainBlockCopy): Use bytes/sec.
Signed-off-by: Eric Blake <eblake@redhat.com>
2014-08-29 19:58:45 +00:00
|
|
|
unsigned long long bandwidth)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
|
blockjob: allow omitted arguments to QMP block-commit
We are about to turn on support for active block commit. Although
qemu 2.0 was the first version to mostly support it, that version
mis-handles 0-length files, and doesn't have anything available for
easy probing. But qemu 2.1 fixed bugs, and made life simpler by
letting the 'top' argument be optional. Unless someone begs for
active commit with qemu 2.0, for now we are just going to enable
it only by probing for qemu 2.1 behavior (anyone backporting active
commit can also backport the optional argument behavior). This
requires qemu.git commit 7676e2c597000eff3a7233b40cca768b358f9bc9.
Although all our actual uses of block-commit supply arguments for
both base and top, we can omit both arguments and use a bogus
device string to trigger an interesting behavior in qemu. All QMP
commands first do argument validation, failing with GenericError
if a mandatory argument is missing. Once that passes, the code
in the specific command gets to do further checking, and the qemu
developers made sure that if device is the only supplied argument,
then the block-commit code will look up the device first, with a
failure of DeviceNotFound, before attempting any further argument
validation (most other validations fail with GenericError). Thus,
the category of error class can reliably be used to decipher
whether the top argument was optional, which in turn implies a
working active commit. Since we expect our bogus device string to
trigger an error either way, the code is written to return a
distinct return value without spamming the logs.
* src/qemu/qemu_monitor.h (qemuMonitorSupportsActiveCommit): New
prototype.
* src/qemu/qemu_monitor.c (qemuMonitorSupportsActiveCommit):
Implement it.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONBlockCommit):
Allow NULL for top and base, for probing purposes.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONBlockCommit):
Likewise, implementing the probe.
* tests/qemumonitorjsontest.c (mymain): Enable...
(testQemuMonitorJSONqemuMonitorSupportsActiveCommit): ...a new test.
Signed-off-by: Eric Blake <eblake@redhat.com>
2014-06-17 03:42:49 +00:00
|
|
|
bool qemuMonitorSupportsActiveCommit(qemuMonitorPtr mon);
|
qemu: read backing chain names from qemu
https://bugzilla.redhat.com/show_bug.cgi?id=1199182 documents that
after a series of disk snapshots into existing destination images,
followed by active commits of the top image, it is possible for
qemu 2.2 and earlier to end up tracking a different name for the
image than what it would have had when opening the chain afresh.
That is, when starting with the chain 'a <- b <- c', the name
associated with 'b' is how it was spelled in the metadata of 'c',
but when starting with 'a', taking two snapshots into 'a <- b <- c',
then committing 'c' back into 'b', the name associated with 'b' is
now the name used when taking the first snapshot.
Sadly, older qemu doesn't know how to treat different spellings of
the same filename as identical files (it uses strcmp() instead of
checking for the same inode), which means libvirt's attempt to
commit an image using solely the names learned from qcow2 metadata
fails with a cryptic:
error: internal error: unable to execute QEMU command 'block-commit': Top image file /tmp/images/c/../b/b not found
even though the file exists. Trying to teach libvirt the rules on
which name qemu will expect is not worth the effort (besides, we'd
have to remember it across libvirtd restarts, and track whether a
file was opened via metadata or via snapshot creation for a given
qemu process); it is easier to just always directly ask qemu what
string it expects to see in the first place.
As a safety valve, we validate that any name returned by qemu
still maps to the same local file as we have tracked it, so that
a compromised qemu cannot accidentally cause us to act on an
incorrect file.
* src/qemu/qemu_monitor.h (qemuMonitorDiskNameLookup): New
prototype.
* src/qemu/qemu_monitor_json.h (qemuMonitorJSONDiskNameLookup):
Likewise.
* src/qemu/qemu_monitor.c (qemuMonitorDiskNameLookup): New function.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONDiskNameLookup)
(qemuMonitorJSONDiskNameLookupOne): Likewise.
* src/qemu/qemu_driver.c (qemuDomainBlockCommit)
(qemuDomainBlockJobImpl): Use it.
Signed-off-by: Eric Blake <eblake@redhat.com>
2015-03-11 20:37:04 +00:00
|
|
|
char *qemuMonitorDiskNameLookup(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
virStorageSourcePtr top,
|
|
|
|
|
virStorageSourcePtr target)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
|
2012-10-03 21:13:21 +00:00
|
|
|
|
2011-02-02 15:37:10 +00:00
|
|
|
int qemuMonitorArbitraryCommand(qemuMonitorPtr mon,
|
|
|
|
|
const char *cmd,
|
|
|
|
|
char **reply,
|
|
|
|
|
bool hmp);
|
2010-04-17 02:12:45 +00:00
|
|
|
|
2011-05-10 08:26:06 +00:00
|
|
|
int qemuMonitorInjectNMI(qemuMonitorPtr mon);
|
|
|
|
|
|
2011-04-01 06:23:58 +00:00
|
|
|
int qemuMonitorScreendump(qemuMonitorPtr mon,
|
|
|
|
|
const char *file);
|
|
|
|
|
|
2011-07-21 07:55:56 +00:00
|
|
|
int qemuMonitorSendKey(qemuMonitorPtr mon,
|
|
|
|
|
unsigned int holdtime,
|
|
|
|
|
unsigned int *keycodes,
|
|
|
|
|
unsigned int nkeycodes);
|
|
|
|
|
|
2015-04-01 09:45:35 +00:00
|
|
|
int qemuMonitorBlockStream(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
const char *base,
|
|
|
|
|
const char *backingName,
|
|
|
|
|
unsigned long long bandwidth,
|
|
|
|
|
bool modern)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2);
|
2011-07-22 05:39:37 +00:00
|
|
|
|
2015-04-01 08:40:06 +00:00
|
|
|
int qemuMonitorBlockJobCancel(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
bool modern)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2);
|
2015-04-01 08:40:06 +00:00
|
|
|
|
2015-04-01 07:47:04 +00:00
|
|
|
int qemuMonitorBlockJobSetSpeed(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
unsigned long long bandwidth,
|
|
|
|
|
bool modern);
|
|
|
|
|
|
2015-05-22 11:33:49 +00:00
|
|
|
typedef struct _qemuMonitorBlockJobInfo qemuMonitorBlockJobInfo;
|
|
|
|
|
typedef qemuMonitorBlockJobInfo *qemuMonitorBlockJobInfoPtr;
|
|
|
|
|
struct _qemuMonitorBlockJobInfo {
|
|
|
|
|
int type; /* virDomainBlockJobType */
|
|
|
|
|
unsigned long long bandwidth; /* in bytes/s */
|
|
|
|
|
virDomainBlockJobCursor cur;
|
|
|
|
|
virDomainBlockJobCursor end;
|
2015-07-15 13:11:02 +00:00
|
|
|
int ready; /* -1 if unknown, 0 if not ready, 1 if ready */
|
2015-05-22 11:33:49 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
virHashTablePtr qemuMonitorGetAllBlockJobInfo(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorGetBlockJobInfo(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
qemuMonitorBlockJobInfoPtr info)
|
2015-04-14 15:52:48 +00:00
|
|
|
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3);
|
2014-08-27 19:29:14 +00:00
|
|
|
|
2011-10-21 08:00:13 +00:00
|
|
|
int qemuMonitorOpenGraphics(qemuMonitorPtr mon,
|
|
|
|
|
const char *protocol,
|
|
|
|
|
int fd,
|
|
|
|
|
const char *fdname,
|
|
|
|
|
bool skipauth);
|
|
|
|
|
|
2011-11-15 09:02:45 +00:00
|
|
|
int qemuMonitorSetBlockIoThrottle(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
2014-11-10 15:19:09 +00:00
|
|
|
virDomainBlockIoTuneInfoPtr info,
|
|
|
|
|
bool supportMaxOptions);
|
2011-11-15 09:02:45 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorGetBlockIoThrottle(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
2014-11-10 15:19:09 +00:00
|
|
|
virDomainBlockIoTuneInfoPtr reply,
|
|
|
|
|
bool supportMaxOptions);
|
2011-11-15 09:02:45 +00:00
|
|
|
|
2012-02-10 12:33:52 +00:00
|
|
|
int qemuMonitorSystemWakeup(qemuMonitorPtr mon);
|
|
|
|
|
|
2012-08-15 14:04:09 +00:00
|
|
|
int qemuMonitorGetVersion(qemuMonitorPtr mon,
|
|
|
|
|
int *major,
|
|
|
|
|
int *minor,
|
|
|
|
|
int *micro,
|
|
|
|
|
char **package)
|
|
|
|
|
ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3) ATTRIBUTE_NONNULL(4);
|
|
|
|
|
|
2012-08-15 15:18:41 +00:00
|
|
|
|
|
|
|
|
typedef struct _qemuMonitorMachineInfo qemuMonitorMachineInfo;
|
|
|
|
|
typedef qemuMonitorMachineInfo *qemuMonitorMachineInfoPtr;
|
|
|
|
|
|
|
|
|
|
struct _qemuMonitorMachineInfo {
|
|
|
|
|
char *name;
|
|
|
|
|
bool isDefault;
|
|
|
|
|
char *alias;
|
2013-06-26 15:46:35 +00:00
|
|
|
unsigned int maxCpus;
|
2012-08-15 15:18:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetMachines(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorMachineInfoPtr **machines);
|
|
|
|
|
|
|
|
|
|
void qemuMonitorMachineInfoFree(qemuMonitorMachineInfoPtr machine);
|
|
|
|
|
|
2012-08-20 14:58:20 +00:00
|
|
|
int qemuMonitorGetCPUDefinitions(qemuMonitorPtr mon,
|
|
|
|
|
char ***cpus);
|
|
|
|
|
|
2012-08-22 09:25:20 +00:00
|
|
|
int qemuMonitorGetCommands(qemuMonitorPtr mon,
|
|
|
|
|
char ***commands);
|
2012-08-22 09:48:41 +00:00
|
|
|
int qemuMonitorGetEvents(qemuMonitorPtr mon,
|
|
|
|
|
char ***events);
|
2013-04-26 17:13:45 +00:00
|
|
|
int qemuMonitorGetCommandLineOptionParameters(qemuMonitorPtr mon,
|
|
|
|
|
const char *option,
|
2014-06-17 11:41:16 +00:00
|
|
|
char ***params,
|
|
|
|
|
bool *found);
|
2012-08-22 09:25:20 +00:00
|
|
|
|
Make non-KVM machines work with QMP probing
When there is no 'qemu-kvm' binary and the emulator used for a machine
is, for example, 'qemu-system-x86_64' that, by default, runs without
kvm enabled, libvirt still supplies '-no-kvm' option to this process,
even though it does not recognize such option (making the start of a
domain fail in that case).
This patch fixes building a command-line for QEMU machines without KVM
acceleration and is based on following assumptions:
- QEMU_CAPS_KVM flag means that QEMU is running KVM accelerated
machines by default (without explicitly requesting that using a
command-line option). It is the closest to the truth according to
the code with the only exception being the comment next to the
flag, so it's fixed in this patch as well.
- QEMU_CAPS_ENABLE_KVM flag means that QEMU is, by default, running
without KVM acceleration and in case we need KVM acceleration it
needs to be explicitly instructed to do so. This is partially
true for the past (this option essentially means that QEMU
recognizes the '-enable-kvm' option, even though it's almost the
same).
2012-10-31 07:31:49 +00:00
|
|
|
int qemuMonitorGetKVMState(qemuMonitorPtr mon,
|
|
|
|
|
bool *enabled,
|
|
|
|
|
bool *present);
|
|
|
|
|
|
2012-08-22 09:48:41 +00:00
|
|
|
int qemuMonitorGetObjectTypes(qemuMonitorPtr mon,
|
|
|
|
|
char ***types);
|
2012-08-22 09:48:41 +00:00
|
|
|
int qemuMonitorGetObjectProps(qemuMonitorPtr mon,
|
|
|
|
|
const char *type,
|
|
|
|
|
char ***props);
|
2012-08-22 09:48:41 +00:00
|
|
|
char *qemuMonitorGetTargetArch(qemuMonitorPtr mon);
|
2012-08-20 14:58:20 +00:00
|
|
|
|
2012-11-22 15:08:52 +00:00
|
|
|
int qemuMonitorNBDServerStart(qemuMonitorPtr mon,
|
|
|
|
|
const char *host,
|
|
|
|
|
unsigned int port);
|
2012-11-22 15:17:13 +00:00
|
|
|
int qemuMonitorNBDServerAdd(qemuMonitorPtr mon,
|
|
|
|
|
const char *deviceID,
|
|
|
|
|
bool writable);
|
2013-01-31 13:47:49 +00:00
|
|
|
int qemuMonitorNBDServerStop(qemuMonitorPtr);
|
2013-04-12 20:55:45 +00:00
|
|
|
int qemuMonitorGetTPMModels(qemuMonitorPtr mon,
|
|
|
|
|
char ***tpmmodels);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
|
|
|
|
|
char ***tpmtypes);
|
|
|
|
|
|
2013-03-12 18:48:04 +00:00
|
|
|
int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
|
|
|
|
|
const char *chrID,
|
|
|
|
|
virDomainChrSourceDefPtr chr);
|
2013-03-12 18:57:48 +00:00
|
|
|
int qemuMonitorDetachCharDev(qemuMonitorPtr mon,
|
|
|
|
|
const char *chrID);
|
2013-07-19 13:01:38 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorGetDeviceAliases(qemuMonitorPtr mon,
|
|
|
|
|
char ***aliases);
|
|
|
|
|
|
2015-11-12 13:54:04 +00:00
|
|
|
typedef void (*qemuMonitorReportDomainLogError)(qemuMonitorPtr mon,
|
|
|
|
|
const char *msg,
|
|
|
|
|
void *opaque);
|
|
|
|
|
void qemuMonitorSetDomainLog(qemuMonitorPtr mon,
|
|
|
|
|
qemuMonitorReportDomainLogError func,
|
|
|
|
|
void *opaque,
|
|
|
|
|
virFreeCallback destroy);
|
2013-09-18 14:12:17 +00:00
|
|
|
|
2013-11-11 13:47:08 +00:00
|
|
|
int qemuMonitorGetGuestCPU(qemuMonitorPtr mon,
|
|
|
|
|
virArch arch,
|
|
|
|
|
virCPUDataPtr *data);
|
2013-07-22 11:07:23 +00:00
|
|
|
|
2014-08-13 12:28:24 +00:00
|
|
|
int qemuMonitorRTCResetReinjection(qemuMonitorPtr mon);
|
|
|
|
|
|
2015-03-25 15:59:37 +00:00
|
|
|
typedef struct _qemuMonitorIOThreadInfo qemuMonitorIOThreadInfo;
|
|
|
|
|
typedef qemuMonitorIOThreadInfo *qemuMonitorIOThreadInfoPtr;
|
2014-08-29 20:23:11 +00:00
|
|
|
|
2015-03-25 15:59:37 +00:00
|
|
|
struct _qemuMonitorIOThreadInfo {
|
2015-04-27 18:16:54 +00:00
|
|
|
unsigned int iothread_id;
|
2014-08-29 20:23:11 +00:00
|
|
|
int thread_id;
|
|
|
|
|
};
|
|
|
|
|
int qemuMonitorGetIOThreads(qemuMonitorPtr mon,
|
2015-03-25 15:59:37 +00:00
|
|
|
qemuMonitorIOThreadInfoPtr **iothreads);
|
2014-08-29 20:23:11 +00:00
|
|
|
|
2015-01-19 12:21:09 +00:00
|
|
|
typedef struct _qemuMonitorMemoryDeviceInfo qemuMonitorMemoryDeviceInfo;
|
|
|
|
|
typedef qemuMonitorMemoryDeviceInfo *qemuMonitorMemoryDeviceInfoPtr;
|
|
|
|
|
|
|
|
|
|
struct _qemuMonitorMemoryDeviceInfo {
|
|
|
|
|
unsigned long long address;
|
|
|
|
|
unsigned int slot;
|
|
|
|
|
bool hotplugged;
|
|
|
|
|
bool hotpluggable;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetMemoryDeviceInfo(qemuMonitorPtr mon,
|
|
|
|
|
virHashTablePtr *info)
|
|
|
|
|
ATTRIBUTE_NONNULL(2);
|
|
|
|
|
|
2015-10-20 20:51:48 +00:00
|
|
|
int qemuMonitorMigrateIncoming(qemuMonitorPtr mon,
|
|
|
|
|
const char *uri);
|
|
|
|
|
|
2014-12-01 15:59:54 +00:00
|
|
|
int qemuMonitorMigrateStartPostCopy(qemuMonitorPtr mon);
|
|
|
|
|
|
2016-04-29 14:01:47 +00:00
|
|
|
int qemuMonitorGetRTCTime(qemuMonitorPtr mon,
|
|
|
|
|
struct tm *tm);
|
|
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
#endif /* QEMU_MONITOR_H */
|
