2009-10-09 18:07:55 +00:00
|
|
|
/*
|
|
|
|
|
* qemu_monitor.h: interaction with QEMU monitor console
|
|
|
|
|
*
|
2012-02-18 16:20:01 +00:00
|
|
|
* Copyright (C) 2006-2012 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
|
|
|
|
|
* License along with this library; if not, write to the Free Software
|
|
|
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
|
|
|
*
|
|
|
|
|
* 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"
|
2011-09-13 13:49:50 +00:00
|
|
|
# include "qemu_conf.h"
|
2012-02-13 11:19:24 +00:00
|
|
|
# include "bitmap.h"
|
2012-01-25 16:13:59 +00:00
|
|
|
# include "virhash.h"
|
2012-03-17 04:17:28 +00:00
|
|
|
# include "json.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;
|
|
|
|
|
};
|
|
|
|
|
|
2009-10-15 17:56:52 +00:00
|
|
|
typedef struct _qemuMonitorCallbacks qemuMonitorCallbacks;
|
|
|
|
|
typedef qemuMonitorCallbacks *qemuMonitorCallbacksPtr;
|
|
|
|
|
struct _qemuMonitorCallbacks {
|
2010-06-10 14:11:30 +00:00
|
|
|
void (*destroy)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
|
2009-10-15 17:56:52 +00:00
|
|
|
void (*eofNotify)(qemuMonitorPtr mon,
|
2011-05-29 12:37:29 +00:00
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
void (*errorNotify)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
/* XXX we'd really like to avoid virConnectPtr here
|
2009-10-15 17:56:52 +00:00
|
|
|
* 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
|
|
|
|
|
*/
|
|
|
|
|
int (*diskSecretLookup)(qemuMonitorPtr mon,
|
|
|
|
|
virConnectPtr conn,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *path,
|
|
|
|
|
char **secret,
|
|
|
|
|
size_t *secretLen);
|
2009-11-26 13:05:24 +00:00
|
|
|
|
|
|
|
|
int (*domainShutdown)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
int (*domainReset)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
int (*domainPowerdown)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
|
|
|
|
int (*domainStop)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
2010-03-18 18:28:15 +00:00
|
|
|
int (*domainRTCChange)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
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 (*domainWatchdog)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
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 (*domainIOError)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
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 (*domainGraphics)(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,
|
|
|
|
|
const char *saslUsername);
|
2011-07-22 05:57:42 +00:00
|
|
|
int (*domainBlockJob)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *diskAlias,
|
|
|
|
|
int type,
|
|
|
|
|
int status);
|
2012-03-23 13:44:50 +00:00
|
|
|
int (*domainTrayChange)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
|
const char *devAlias,
|
|
|
|
|
int reason);
|
2012-03-23 14:43:14 +00:00
|
|
|
int (*domainPMWakeup)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
2012-03-23 14:50:36 +00:00
|
|
|
int (*domainPMSuspend)(qemuMonitorPtr mon,
|
|
|
|
|
virDomainObjPtr vm);
|
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,
|
2009-11-03 18:59:18 +00:00
|
|
|
int json,
|
2009-10-15 17:56:52 +00:00
|
|
|
qemuMonitorCallbacksPtr cb);
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2010-06-10 14:11:30 +00:00
|
|
|
void qemuMonitorClose(qemuMonitorPtr mon);
|
2009-10-09 19:13:29 +00:00
|
|
|
|
2012-02-13 11:19:24 +00:00
|
|
|
int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
|
|
|
|
|
virBitmapPtr qemuCaps);
|
2010-02-12 13:45:20 +00:00
|
|
|
|
2011-03-16 19:34:01 +00:00
|
|
|
int qemuMonitorCheckHMP(qemuMonitorPtr mon, const char *cmd);
|
|
|
|
|
|
2009-10-13 14:27:58 +00:00
|
|
|
void qemuMonitorLock(qemuMonitorPtr mon);
|
|
|
|
|
void qemuMonitorUnlock(qemuMonitorPtr mon);
|
|
|
|
|
|
2009-11-26 13:29:29 +00:00
|
|
|
int qemuMonitorRef(qemuMonitorPtr mon);
|
2011-03-18 17:32:35 +00:00
|
|
|
int qemuMonitorUnref(qemuMonitorPtr mon) ATTRIBUTE_RETURN_CHECK;
|
2009-11-26 13:29:29 +00:00
|
|
|
|
2011-09-06 08:18:57 +00:00
|
|
|
int qemuMonitorSetLink(qemuMonitorPtr mon,
|
|
|
|
|
const char *name,
|
|
|
|
|
enum virDomainNetInterfaceLinkState state) ;
|
|
|
|
|
|
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);
|
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
|
|
|
|
2009-11-26 13:05:24 +00:00
|
|
|
int qemuMonitorEmitShutdown(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitReset(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitPowerdown(qemuMonitorPtr mon);
|
|
|
|
|
int qemuMonitorEmitStop(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);
|
|
|
|
|
|
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,
|
|
|
|
|
|
|
|
|
|
QEMU_MONITOR_VM_STATUS_LAST
|
|
|
|
|
} qemuMonitorVMStatus;
|
|
|
|
|
VIR_ENUM_DECL(qemuMonitorVMStatus)
|
|
|
|
|
int qemuMonitorVMStatusToPausedReason(const char *status);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetStatus(qemuMonitorPtr mon,
|
|
|
|
|
bool *running,
|
|
|
|
|
virDomainPausedReason *reason);
|
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,
|
|
|
|
|
int *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);
|
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,
|
|
|
|
|
const char *devname);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
|
2011-09-16 12:05:58 +00:00
|
|
|
const char *dev_name,
|
2009-10-09 20:13:06 +00:00
|
|
|
long long *rd_req,
|
|
|
|
|
long long *rd_bytes,
|
2011-09-05 08:22:17 +00:00
|
|
|
long long *rd_total_times,
|
2009-10-09 20:13:06 +00:00
|
|
|
long long *wr_req,
|
|
|
|
|
long long *wr_bytes,
|
2011-09-05 08:22:17 +00:00
|
|
|
long long *wr_total_times,
|
|
|
|
|
long long *flush_req,
|
|
|
|
|
long long *flush_total_times,
|
2009-10-09 20:13:06 +00:00
|
|
|
long long *errs);
|
2011-09-05 08:22:17 +00:00
|
|
|
int qemuMonitorGetBlockStatsParamsNumber(qemuMonitorPtr mon,
|
|
|
|
|
int *nparams);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2010-05-14 13:10:01 +00:00
|
|
|
int qemuMonitorGetBlockExtent(qemuMonitorPtr mon,
|
2011-09-16 12:05:58 +00:00
|
|
|
const char *dev_name,
|
2010-05-14 13:10:01 +00:00
|
|
|
unsigned long long *extent);
|
2011-11-29 07:34:53 +00:00
|
|
|
int qemuMonitorBlockResize(qemuMonitorPtr mon,
|
|
|
|
|
const char *devname,
|
|
|
|
|
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,
|
|
|
|
|
unsigned long newmem);
|
2010-02-08 16:37:17 +00:00
|
|
|
int qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, int online);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
/* XXX should we pass the virDomainDiskDefPtr instead
|
|
|
|
|
* and hide devname details inside monitor. Reconsider
|
|
|
|
|
* 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);
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
2009-11-26 13:37:11 +00:00
|
|
|
VIR_ENUM_DECL(qemuMonitorMigrationStatus)
|
|
|
|
|
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
|
|
|
|
|
int *status,
|
|
|
|
|
unsigned long long *transferred,
|
|
|
|
|
unsigned long long *remaining,
|
|
|
|
|
unsigned long long *total);
|
|
|
|
|
|
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,
|
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);
|
|
|
|
|
|
2010-06-10 02:23:51 +00:00
|
|
|
/* In general, BS is the smallest fundamental block size we can use to
|
|
|
|
|
* access a block device; everything must be aligned to a multiple of
|
|
|
|
|
* this. Linux generally supports a BS as small as 512, but with
|
|
|
|
|
* newer disks with 4k sectors, performance is better if we guarantee
|
|
|
|
|
* alignment to the sector size. However, operating on BS-sized
|
|
|
|
|
* blocks is painfully slow, so we also have a transfer size that is
|
|
|
|
|
* larger but only aligned to the smaller block size.
|
2010-06-04 03:36:00 +00:00
|
|
|
*/
|
2010-06-10 02:23:51 +00:00
|
|
|
# define QEMU_MONITOR_MIGRATE_TO_FILE_BS (1024llu * 4)
|
|
|
|
|
# define QEMU_MONITOR_MIGRATE_TO_FILE_TRANSFER_SIZE (1024llu * 1024)
|
2010-04-21 13:06:37 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorMigrateToFile(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,
|
|
|
|
|
const char *target,
|
|
|
|
|
unsigned long long offset);
|
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);
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
/* 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,
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress *hostAddr,
|
|
|
|
|
virDomainDevicePCIAddress *guestAddr);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
/* XXX disk driver type eg, qcow/etc.
|
|
|
|
|
* XXX cache mode
|
|
|
|
|
*/
|
|
|
|
|
int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
|
|
|
|
|
const char *path,
|
|
|
|
|
const char *bus,
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress *guestAddr);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
/* XXX do we really want to hardcode 'nicstr' as the
|
|
|
|
|
* sendable item here
|
|
|
|
|
*/
|
|
|
|
|
int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
|
|
|
|
|
const char *nicstr,
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress *guestAddr);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
|
2009-12-07 19:07:39 +00:00
|
|
|
virDomainDevicePCIAddress *guestAddr);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
|
|
|
|
|
const char *fdname,
|
|
|
|
|
int fd);
|
|
|
|
|
|
2011-07-13 09:16:20 +00:00
|
|
|
/* The function preserves previous error and only sets it's own error if no
|
|
|
|
|
* error was set before.
|
|
|
|
|
*/
|
2009-10-09 20:13:06 +00:00
|
|
|
int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
|
|
|
|
|
const char *fdname);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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,
|
|
|
|
|
int tapfd, const char *tapfd_name,
|
|
|
|
|
int vhostfd, const char *vhostfd_name);
|
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,
|
|
|
|
|
int tapfd, const char *tapfd_name,
|
|
|
|
|
int vhostfd, const char *vhostfd_name);
|
2010-04-15 13:52:03 +00:00
|
|
|
|
|
|
|
|
int qemuMonitorRemoveNetdev(qemuMonitorPtr mon,
|
|
|
|
|
const char *alias);
|
|
|
|
|
|
2009-12-14 09:50:01 +00:00
|
|
|
int qemuMonitorGetPtyPaths(qemuMonitorPtr mon,
|
|
|
|
|
virHashTablePtr paths);
|
2009-10-09 20:13:06 +00:00
|
|
|
|
2009-12-07 19:28:05 +00:00
|
|
|
int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
|
|
|
|
|
const char *bus,
|
|
|
|
|
virDomainDevicePCIAddress *guestAddr);
|
|
|
|
|
|
Properly support SCSI drive hotplug
The current SCSI hotplug support attaches a brand new SCSI controller
for every disk. This is broken because the semantics differ from those
used when starting the VM initially. In the latter case, each SCSI
controller is filled before a new one is added.
If the user specifies an high drive index (sdazz) then at initial
startup, many intermediate SCSI controllers may be added with no
drives.
This patch changes SCSI hotplug so that it exactly matches the
behaviour of initial startup. First the SCSI controller number is
determined for the drive to be hotplugged. If any controller upto
and including that controller number is not yet present, it is
attached. Then finally the drive is attached to the last controller.
NB, this breaks SCSI hotunplug, because there is no 'drive_del'
command in current QEMU. Previous SCSI hotunplug was broken in
any case because it was unplugging the entire controller, not
just the drive in question.
A future QEMU will allow proper SCSI hotunplug of a drive.
This patch is derived from work done by Wolfgang Mauerer on disk
controllers.
* src/qemu/qemu_driver.c: Fix SCSI hotplug to add a drive to
the correct controller, instead of just attaching a new
controller.
* 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
support for 'drive_add' command
2009-12-09 17:57:09 +00:00
|
|
|
int qemuMonitorAttachDrive(qemuMonitorPtr mon,
|
|
|
|
|
const char *drivestr,
|
|
|
|
|
virDomainDevicePCIAddress *controllerAddr,
|
|
|
|
|
virDomainDeviceDriveAddress *driveAddr);
|
|
|
|
|
|
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;
|
|
|
|
|
virDomainDevicePCIAddress addr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
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)
|
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
|
2011-08-15 23:25:54 +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);
|
|
|
|
|
|
2011-07-22 05:39:37 +00:00
|
|
|
typedef enum {
|
|
|
|
|
BLOCK_JOB_ABORT = 0,
|
|
|
|
|
BLOCK_JOB_INFO = 1,
|
|
|
|
|
BLOCK_JOB_SPEED = 2,
|
blockjob: allow for fast-finishing job
In my testing, I was able to provoke an odd block pull failure:
$ virsh blockpull dom vda --bandwidth 10000
error: Requested operation is not valid: No active operation on device: drive-virtio-disk0
merely by using gdb to artifically wait to do the block job set speed
until after the pull had already finished. But in reality, that should
be a success, since the pull finished before we had a chance to set
speed. Furthermore, using a double job lock is not only annoying, but
a bug in itself - if you do parallel virDomainBlockRebase, and hit
the race window just right, the first call grabs the VM job to start
a fast block job, then the second call grabs the VM job to start
a long-running job with unspecified speed, then the first call finally
regrabs the VM job and sets the speed, which ends up running the
second job under the speed from the first call. By consolidating
things into a single job, we avoid opening that race, as well as reduce
the time between starting the job and changing the speed, for less
likelihood of the speed change happening after block job completion
in the first place.
* src/qemu/qemu_monitor.h (BLOCK_JOB_CMD): Add new mode.
* src/qemu/qemu_driver.c (qemuDomainBlockRebase): Move secondary
job call...
(qemuDomainBlockJobImpl): ...here, for fewer locks.
* src/qemu/qemu_monitor_json.c (qemuMonitorJSONBlockJob): Change
return value on new internal mode.
2012-04-11 22:28:35 +00:00
|
|
|
BLOCK_JOB_SPEED_INTERNAL = 3,
|
|
|
|
|
BLOCK_JOB_PULL = 4,
|
2011-07-22 05:39:37 +00:00
|
|
|
} BLOCK_JOB_CMD;
|
|
|
|
|
|
|
|
|
|
int qemuMonitorBlockJob(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
2012-02-18 16:20:01 +00:00
|
|
|
const char *back,
|
2011-07-22 05:39:37 +00:00
|
|
|
unsigned long bandwidth,
|
|
|
|
|
virDomainBlockJobInfoPtr info,
|
2012-04-11 21:40:16 +00:00
|
|
|
int mode,
|
|
|
|
|
bool async)
|
|
|
|
|
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
|
2011-07-22 05:39:37 +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,
|
|
|
|
|
virDomainBlockIoTuneInfoPtr info);
|
|
|
|
|
|
|
|
|
|
int qemuMonitorGetBlockIoThrottle(qemuMonitorPtr mon,
|
|
|
|
|
const char *device,
|
|
|
|
|
virDomainBlockIoTuneInfoPtr reply);
|
|
|
|
|
|
2012-02-10 12:33:52 +00:00
|
|
|
int qemuMonitorSystemWakeup(qemuMonitorPtr mon);
|
|
|
|
|
|
2010-10-22 23:26:08 +00:00
|
|
|
/**
|
|
|
|
|
* When running two dd process and using <> redirection, we need a
|
|
|
|
|
* shell that will not truncate files. These two strings serve that
|
|
|
|
|
* purpose.
|
|
|
|
|
*/
|
|
|
|
|
# ifdef VIR_WRAPPER_SHELL
|
|
|
|
|
# define VIR_WRAPPER_SHELL_PREFIX VIR_WRAPPER_SHELL " -c '"
|
|
|
|
|
# define VIR_WRAPPER_SHELL_SUFFIX "'"
|
|
|
|
|
# else
|
|
|
|
|
# define VIR_WRAPPER_SHELL_PREFIX /* nothing */
|
|
|
|
|
# define VIR_WRAPPER_SHELL_SUFFIX /* nothing */
|
|
|
|
|
# endif
|
|
|
|
|
|
2009-10-09 18:07:55 +00:00
|
|
|
#endif /* QEMU_MONITOR_H */
|
