}
+static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action,
+ void *opaque)
+{
+ struct qemud_client *client = opaque;
+ remote_domain_event_io_error_msg data;
+
+ if (!client)
+ return -1;
+
+ REMOTE_DEBUG("Relaying domain io error %s %d %s %s %d", dom->name, dom->id, srcPath, devAlias, action);
+
+ virMutexLock(&client->lock);
+
+ /* build return data */
+ memset(&data, 0, sizeof data);
+ make_nonnull_domain (&data.dom, dom);
+ data.srcPath = (char*)srcPath;
+ data.devAlias = (char*)devAlias;
+ data.action = action;
+
+ remoteDispatchDomainEventSend (client,
+ REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
+ (xdrproc_t)xdr_remote_domain_event_io_error_msg, &data);
+
+ virMutexUnlock(&client->lock);
+
+ return 0;
+}
+
+
static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventRTCChange),
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventWatchdog),
+ VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventIOError),
};
verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
.args_filter = (xdrproc_t) xdr_void,
.ret_filter = (xdrproc_t) xdr_void,
},
+{ /* Async event DomainEventIoError => 172 */
+ .fn = NULL,
+ .args_filter = (xdrproc_t) xdr_void,
+ .ret_filter = (xdrproc_t) xdr_void,
+},
return 0;
}
+static int myDomainEventIOErrorCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action,
+ void *opaque ATTRIBUTE_UNUSED)
+{
+ printf("%s EVENT: Domain %s(%d) io error path=%s alias=%s action=%d\n", __func__, virDomainGetName(dom),
+ virDomainGetID(dom), srcPath, devAlias, action);
+
+ return 0;
+}
+
static void myFreeFunc(void *opaque)
{
char *str = opaque;
int callback3ret = -1;
int callback4ret = -1;
int callback5ret = -1;
+ int callback6ret = -1;
struct sigaction action_stop = {
.sa_handler = stop
VIR_DOMAIN_EVENT_ID_WATCHDOG,
VIR_DOMAIN_EVENT_CALLBACK(myDomainEventWatchdogCallback),
strdup("callback watchdog"), myFreeFunc);
+ callback6ret = virConnectDomainEventRegisterAny(dconn,
+ NULL,
+ VIR_DOMAIN_EVENT_ID_IO_ERROR,
+ VIR_DOMAIN_EVENT_CALLBACK(myDomainEventIOErrorCallback),
+ strdup("callback io error"), myFreeFunc);
if ((callback1ret != -1) &&
(callback2ret != -1) &&
(callback3ret != -1) &&
(callback4ret != -1) &&
- (callback5ret != -1)) {
+ (callback5ret != -1) &&
+ (callback6ret != -1)) {
while(run) {
struct pollfd pfd = { .fd = h_fd,
.events = h_event,
virConnectDomainEventDeregisterAny(dconn, callback3ret);
virConnectDomainEventDeregisterAny(dconn, callback4ret);
virConnectDomainEventDeregisterAny(dconn, callback5ret);
+ virConnectDomainEventDeregisterAny(dconn, callback6ret);
}
DEBUG0("Closing connection");
int action,
void *opaque);
+/**
+ * virDomainEventIOErrorAction:
+ *
+ * The action that is to be taken due to an IO error occuring
+ */
+typedef enum {
+ VIR_DOMAIN_EVENT_IO_ERROR_NONE = 0, /* No action, IO error ignored */
+ VIR_DOMAIN_EVENT_IO_ERROR_PAUSE, /* Guest CPUs are pausde */
+ VIR_DOMAIN_EVENT_IO_ERROR_REPORT, /* IO error reported to guest OS */
+} virDomainEventIOErrorAction;
+
+
+/**
+ * virConnectDomainEventWatchdogCallback:
+ * @conn: connection object
+ * @dom: domain on which the event occurred
+ * @srcPath: The host file on which the IO error occurred
+ * @devAlias: The guest device alias associated with the path
+ * @action: action that is to be taken due to the IO error
+ * @opaque: application specified data
+ *
+ * The callback signature to use when registering for an event of type
+ * VIR_DOMAIN_EVENT_ID_IO_ERROR with virConnectDomainEventRegisterAny()
+ *
+ */
+typedef void (*virConnectDomainEventIOErrorCallback)(virConnectPtr conn,
+ virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action,
+ void *opaque);
+
/**
* VIR_DOMAIN_EVENT_CALLBACK:
*
VIR_DOMAIN_EVENT_ID_REBOOT = 1, /* virConnectDomainEventGenericCallback */
VIR_DOMAIN_EVENT_ID_RTC_CHANGE = 2, /* virConnectDomainEventRTCChangeCallback */
VIR_DOMAIN_EVENT_ID_WATCHDOG = 3, /* virConnectDomainEventWatchdogCallback */
+ VIR_DOMAIN_EVENT_ID_IO_ERROR = 4, /* virConnectDomainEventIOErrorCallback */
/*
* NB: this enum value will increase over time as new events are
'virConnectDomainEventGenericCallback': "No function types in python",
'virConnectDomainEventRTCChangeCallback': "No function types in python",
'virConnectDomainEventWatchdogCallback': "No function types in python",
+ 'virConnectDomainEventIOErrorCallback': "No function types in python",
'virEventAddHandleFunc': "No function types in python",
}
struct {
int action;
} watchdog;
+ struct {
+ char *srcPath;
+ char *devAlias;
+ int action;
+ } ioError;
} data;
};
if (!event)
return;
+ if (event->eventID == VIR_DOMAIN_EVENT_ID_IO_ERROR) {
+ VIR_FREE(event->data.ioError.srcPath);
+ VIR_FREE(event->data.ioError.devAlias);
+ }
+
VIR_FREE(event->dom.name);
VIR_FREE(event);
}
return ev;
}
+virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action)
+{
+ virDomainEventPtr ev =
+ virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_IO_ERROR,
+ dom->id, dom->name, dom->uuid);
+
+ if (ev) {
+ ev->data.ioError.action = action;
+ if (!(ev->data.ioError.srcPath = strdup(srcPath)) ||
+ !(ev->data.ioError.devAlias = strdup(devAlias))) {
+ virDomainEventFree(ev);
+ ev = NULL;
+ }
+ }
+
+ return ev;
+}
+virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+ const char *srcPath,
+ const char *devAlias,
+ int action)
+{
+ virDomainEventPtr ev =
+ virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_IO_ERROR,
+ obj->def->id, obj->def->name, obj->def->uuid);
+
+ if (ev) {
+ ev->data.watchdog.action = action;
+ if (!(ev->data.ioError.srcPath = strdup(srcPath)) ||
+ !(ev->data.ioError.devAlias = strdup(devAlias))) {
+ virDomainEventFree(ev);
+ ev = NULL;
+ }
+ }
+
+ return ev;
+}
+
/**
* virDomainEventQueueFree:
* @queue: pointer to the queue
cbopaque);
break;
+ case VIR_DOMAIN_EVENT_ID_IO_ERROR:
+ ((virConnectDomainEventIOErrorCallback)cb)(conn, dom,
+ event->data.ioError.srcPath,
+ event->data.ioError.devAlias,
+ event->data.ioError.action,
+ cbopaque);
+ break;
+
default:
VIR_WARN("Unexpected event ID %d", event->eventID);
break;
virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
+virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action);
+virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+ const char *srcPath,
+ const char *devAlias,
+ int action);
+
int virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
virDomainEventPtr event);
virDomainEventRTCChangeNewFromObj;
virDomainEventWatchdogNewFromDom;
virDomainEventWatchdogNewFromObj;
+virDomainEventIOErrorNewFromDom;
+virDomainEventIOErrorNewFromObj;
virDomainEventFree;
virDomainEventDispatchDefaultFunc;
virDomainEventDispatch;
return NULL;
}
+static virDomainDiskDefPtr
+findDomainDiskByAlias(virDomainObjPtr vm,
+ const char *alias)
+{
+ int i;
+
+ for (i = 0; i < vm->def->ndisks; i++) {
+ virDomainDiskDefPtr disk;
+
+ disk = vm->def->disks[i];
+ if (disk->info.alias != NULL && STREQ(disk->info.alias, alias))
+ return disk;
+ }
+
+ qemuReportError(VIR_ERR_INTERNAL_ERROR,
+ _("no disk found with alias %s"),
+ alias);
+ return NULL;
+}
+
static int
getVolumeQcowPassphrase(virConnectPtr conn,
virDomainDiskDefPtr disk,
}
+static int
+qemuHandleDomainIOError(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+ virDomainObjPtr vm,
+ const char *diskAlias,
+ int action)
+{
+ struct qemud_driver *driver = qemu_driver;
+ virDomainEventPtr event;
+ const char *srcPath;
+ const char *devAlias;
+ virDomainDiskDefPtr disk;
+
+ virDomainObjLock(vm);
+ disk = findDomainDiskByAlias(vm, diskAlias);
+
+ if (disk) {
+ srcPath = disk->src;
+ devAlias = disk->info.alias;
+ } else {
+ srcPath = "";
+ devAlias = "";
+ }
+
+ event = virDomainEventIOErrorNewFromObj(vm, srcPath, devAlias, action);
+ virDomainObjUnlock(vm);
+
+ if (event) {
+ qemuDriverLock(driver);
+ qemuDomainEventQueue(driver, event);
+ qemuDriverUnlock(driver);
+ }
+
+ return 0;
+}
+
+
static qemuMonitorCallbacks monitorCallbacks = {
.eofNotify = qemuHandleMonitorEOF,
.diskSecretLookup = findVolumeQcowPassphrase,
.domainReset = qemuHandleDomainReset,
.domainRTCChange = qemuHandleDomainRTCChange,
.domainWatchdog = qemuHandleDomainWatchdog,
+ .domainIOError = qemuHandleDomainIOError,
};
static int
}
+int qemuMonitorEmitIOError(qemuMonitorPtr mon,
+ const char *diskAlias,
+ int action)
+{
+ int ret = -1;
+ VIR_DEBUG("mon=%p", mon);
+
+ qemuMonitorRef(mon);
+ qemuMonitorUnlock(mon);
+ if (mon->cb && mon->cb->domainIOError)
+ ret = mon->cb->domainIOError(mon, mon->vm, diskAlias, action);
+ qemuMonitorLock(mon);
+ qemuMonitorUnref(mon);
+ return ret;
+}
+
+
int qemuMonitorSetCapabilities(qemuMonitorPtr mon)
{
int ret;
int (*domainWatchdog)(qemuMonitorPtr mon,
virDomainObjPtr vm,
int action);
+ int (*domainIOError)(qemuMonitorPtr mon,
+ virDomainObjPtr vm,
+ const char *diskAlias,
+ int action);
};
int qemuMonitorEmitStop(qemuMonitorPtr mon);
int qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset);
int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action);
+int qemuMonitorEmitIOError(qemuMonitorPtr mon,
+ const char *diskAlias,
+ int action);
int qemuMonitorStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn);
static void qemuMonitorJSONHandleStop(qemuMonitorPtr mon, virJSONValuePtr data);
static void qemuMonitorJSONHandleRTCChange(qemuMonitorPtr mon, virJSONValuePtr data);
static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data);
+static void qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data);
struct {
const char *type;
{ "STOP", qemuMonitorJSONHandleStop, },
{ "RTC_CHANGE", qemuMonitorJSONHandleRTCChange, },
{ "WATCHDOG", qemuMonitorJSONHandleWatchdog, },
+ { "DISK_IO_ERROR", qemuMonitorJSONHandleIOError, },
};
}
VIR_ENUM_DECL(qemuMonitorWatchdogAction)
-VIR_ENUM_IMPL(qemuMonitorWatchdogAction, VIR_DOMAIN_EVENT_WATCHDOG_DEBUG,
- "none", "pause", "reset", "poweroff" "shutdown", "debug");
+VIR_ENUM_IMPL(qemuMonitorWatchdogAction, VIR_DOMAIN_EVENT_WATCHDOG_DEBUG + 1,
+ "none", "pause", "reset", "poweroff", "shutdown", "debug");
static void qemuMonitorJSONHandleWatchdog(qemuMonitorPtr mon, virJSONValuePtr data)
{
qemuMonitorEmitRTCChange(mon, actionID);
}
+VIR_ENUM_DECL(qemuMonitorIOErrorAction)
+VIR_ENUM_IMPL(qemuMonitorIOErrorAction, VIR_DOMAIN_EVENT_IO_ERROR_REPORT + 1,
+ "ignore", "stop", "report");
+
+
+static void qemuMonitorJSONHandleIOError(qemuMonitorPtr mon, virJSONValuePtr data)
+{
+ const char *device;
+ const char *action;
+ int actionID;
+
+ /* Throughout here we try our best to carry on upon errors,
+ since it's imporatant to get as much info as possible out
+ to the application */
+
+ if ((action = virJSONValueObjectGetString(data, "action")) == NULL) {
+ VIR_WARN0("Missing action in disk io error event");
+ action = "ignore";
+ }
+
+ if ((device = virJSONValueObjectGetString(data, "device")) == NULL) {
+ VIR_WARN0("missing device in disk io error event");
+ }
+
+ if ((actionID = qemuMonitorIOErrorActionTypeFromString(action)) < 0) {
+ VIR_WARN("unknown disk io error action '%s'", action);
+ actionID = VIR_DOMAIN_EVENT_IO_ERROR_NONE;
+ }
+
+ qemuMonitorEmitIOError(mon, device, actionID);
+}
+
int
qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon)
}
+static virDomainEventPtr
+remoteDomainReadEventIOError(virConnectPtr conn, XDR *xdr)
+{
+ remote_domain_event_io_error_msg msg;
+ virDomainPtr dom;
+ virDomainEventPtr event = NULL;
+ memset (&msg, 0, sizeof msg);
+
+ /* unmarshall parameters, and process it*/
+ if (! xdr_remote_domain_event_io_error_msg(xdr, &msg) ) {
+ error (conn, VIR_ERR_RPC,
+ _("unable to demarshall reboot event"));
+ return NULL;
+ }
+
+ dom = get_nonnull_domain(conn,msg.dom);
+ if (!dom)
+ return NULL;
+
+ event = virDomainEventIOErrorNewFromDom(dom,
+ msg.srcPath,
+ msg.devAlias,
+ msg.action);
+ xdr_free ((xdrproc_t) &xdr_remote_domain_event_io_error_msg, (char *) &msg);
+
+ virDomainFree(dom);
+ return event;
+}
+
+
static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
remoteSecretOpen (virConnectPtr conn,
virConnectAuthPtr auth,
event = remoteDomainReadEventWatchdog(conn, xdr);
break;
+ case REMOTE_PROC_DOMAIN_EVENT_IO_ERROR:
+ event = remoteDomainReadEventIOError(conn, xdr);
+ break;
+
default:
DEBUG("Unexpected event proc %d", hdr->proc);
break;
return TRUE;
}
+bool_t
+xdr_remote_domain_event_io_error_msg (XDR *xdrs, remote_domain_event_io_error_msg *objp)
+{
+
+ if (!xdr_remote_nonnull_domain (xdrs, &objp->dom))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->srcPath))
+ return FALSE;
+ if (!xdr_remote_nonnull_string (xdrs, &objp->devAlias))
+ return FALSE;
+ if (!xdr_int (xdrs, &objp->action))
+ return FALSE;
+ return TRUE;
+}
+
bool_t
xdr_remote_procedure (XDR *xdrs, remote_procedure *objp)
{
int action;
};
typedef struct remote_domain_event_watchdog_msg remote_domain_event_watchdog_msg;
+
+struct remote_domain_event_io_error_msg {
+ remote_nonnull_domain dom;
+ remote_nonnull_string srcPath;
+ remote_nonnull_string devAlias;
+ int action;
+};
+typedef struct remote_domain_event_io_error_msg remote_domain_event_io_error_msg;
#define REMOTE_PROGRAM 0x20008086
#define REMOTE_PROTOCOL_VERSION 1
REMOTE_PROC_DOMAIN_EVENT_REBOOT = 169,
REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE = 170,
REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171,
+ REMOTE_PROC_DOMAIN_EVENT_IO_ERROR = 172,
};
typedef enum remote_procedure remote_procedure;
extern bool_t xdr_remote_domain_event_reboot_msg (XDR *, remote_domain_event_reboot_msg*);
extern bool_t xdr_remote_domain_event_rtc_change_msg (XDR *, remote_domain_event_rtc_change_msg*);
extern bool_t xdr_remote_domain_event_watchdog_msg (XDR *, remote_domain_event_watchdog_msg*);
+extern bool_t xdr_remote_domain_event_io_error_msg (XDR *, remote_domain_event_io_error_msg*);
extern bool_t xdr_remote_procedure (XDR *, remote_procedure*);
extern bool_t xdr_remote_message_type (XDR *, remote_message_type*);
extern bool_t xdr_remote_message_status (XDR *, remote_message_status*);
extern bool_t xdr_remote_domain_event_reboot_msg ();
extern bool_t xdr_remote_domain_event_rtc_change_msg ();
extern bool_t xdr_remote_domain_event_watchdog_msg ();
+extern bool_t xdr_remote_domain_event_io_error_msg ();
extern bool_t xdr_remote_procedure ();
extern bool_t xdr_remote_message_type ();
extern bool_t xdr_remote_message_status ();
int action;
};
+struct remote_domain_event_io_error_msg {
+ remote_nonnull_domain dom;
+ remote_nonnull_string srcPath;
+ remote_nonnull_string devAlias;
+ int action;
+};
+
/*----- Protocol. -----*/
/* Define the program number, protocol version and procedure numbers here. */
REMOTE_PROC_DOMAIN_EVENT_REBOOT = 169,
REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE = 170,
- REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171
+ REMOTE_PROC_DOMAIN_EVENT_WATCHDOG = 171,
+ REMOTE_PROC_DOMAIN_EVENT_IO_ERROR = 172
/*
* Notice how the entries are grouped in sets of 10 ?