struct _virObjectEventQueue {
unsigned int count;
- virDomainEventPtr *events;
+ virObjectEventPtr *events;
};
struct _virObjectEventState {
struct _virObjectEvent {
virObject parent;
int eventID;
+ virObjectMeta meta;
};
struct _virDomainEvent {
virObjectEvent parent;
- virObjectMeta meta;
+ /* Unused attribute to get virDomainEvent class being created */
+ bool dummy;
};
+typedef struct _virDomainEvent virDomainEvent;
+typedef virDomainEvent *virDomainEventPtr;
struct _virDomainEventLifecycle {
virDomainEvent parent;
virObjectEventPtr event = obj;
VIR_DEBUG("obj=%p", event);
+
+ VIR_FREE(event->meta.name);
}
static void virDomainEventDispose(void *obj)
virDomainEventPtr event = obj;
VIR_DEBUG("obj=%p", event);
-
- VIR_FREE(event->meta.name);
}
static void virDomainEventLifecycleDispose(void *obj)
}
static void *virObjectEventNew(virClassPtr klass,
- int eventID)
+ int eventID,
+ int id,
+ const char *name,
+ const unsigned char *uuid)
{
virObjectEventPtr event;
event->eventID = eventID;
+ if (VIR_STRDUP(event->meta.name, name) < 0) {
+ VIR_FREE(event);
+ return NULL;
+ }
+ event->meta.id = id;
+ memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN);
+
VIR_DEBUG("obj=%p", event);
return event;
}
return NULL;
}
- if (!(event = virObjectEventNew(klass, eventID)))
- return NULL;
-
- if (VIR_STRDUP(event->meta.name, name) < 0) {
- VIR_FREE(event);
+ if (!(event = virObjectEventNew(klass, eventID,
+ id, name, uuid)))
return NULL;
- }
- event->meta.id = id;
- memcpy(event->meta.uuid, uuid, VIR_UUID_BUFLEN);
- return event;
+ return (virObjectEventPtr)event;
}
-virDomainEventPtr virDomainEventLifecycleNew(int id, const char *name,
- const unsigned char *uuid,
- int type, int detail)
+virObjectEventPtr virDomainEventLifecycleNew(int id, const char *name,
+ const unsigned char *uuid,
+ int type, int detail)
{
virDomainEventLifecyclePtr event;
event->type = type;
event->detail = detail;
- return (virDomainEventPtr)event;
+ return (virObjectEventPtr)event;
}
-virDomainEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail)
+virObjectEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom, int type, int detail)
{
return virDomainEventLifecycleNew(dom->id, dom->name, dom->uuid,
type, detail);
}
-virDomainEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail)
+virObjectEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj, int type, int detail)
{
return virDomainEventLifecycleNewFromDef(obj->def, type, detail);
}
-virDomainEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail)
+virObjectEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def, int type, int detail)
{
return virDomainEventLifecycleNew(def->id, def->name, def->uuid,
type, detail);
}
-virDomainEventPtr virDomainEventRebootNew(int id, const char *name,
+virObjectEventPtr virDomainEventRebootNew(int id, const char *name,
const unsigned char *uuid)
{
if (virObjectEventInitialize() < 0)
id, name, uuid);
}
-virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom)
+virObjectEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom)
{
if (virObjectEventInitialize() < 0)
return NULL;
dom->id, dom->name, dom->uuid);
}
-virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj)
+virObjectEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj)
{
if (virObjectEventInitialize() < 0)
return NULL;
obj->def->id, obj->def->name, obj->def->uuid);
}
-virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom,
long long offset)
{
virDomainEventRTCChangePtr ev;
ev->offset = offset;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj,
long long offset)
{
virDomainEventRTCChangePtr ev;
ev->offset = offset;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action)
+virObjectEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action)
{
virDomainEventWatchdogPtr ev;
ev->action = action;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action)
+virObjectEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action)
{
virDomainEventWatchdogPtr ev;
ev->action = action;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-static virDomainEventPtr virDomainEventIOErrorNewFromDomImpl(int event,
+static virObjectEventPtr virDomainEventIOErrorNewFromDomImpl(int event,
virDomainPtr dom,
const char *srcPath,
const char *devAlias,
ev = NULL;
}
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-static virDomainEventPtr virDomainEventIOErrorNewFromObjImpl(int event,
+static virObjectEventPtr virDomainEventIOErrorNewFromObjImpl(int event,
virDomainObjPtr obj,
const char *srcPath,
const char *devAlias,
ev = NULL;
}
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action)
action, NULL);
}
-virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
const char *srcPath,
const char *devAlias,
int action)
action, NULL);
}
-virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
action, reason);
}
-virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
const char *srcPath,
const char *devAlias,
int action,
}
-virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
ev->remote = remote;
ev->subject = subject;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
ev->remote = remote;
ev->subject = subject;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
static
-virDomainEventPtr virDomainEventBlockJobNew(int id,
+virObjectEventPtr virDomainEventBlockJobNew(int id,
const char *name,
unsigned char *uuid,
const char *path,
ev->type = type;
ev->status = status;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
const char *path,
int type,
int status)
obj->def->uuid, path, type, status);
}
-virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
const char *path,
int type,
int status)
path, type, status);
}
-virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom)
+virObjectEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom)
{
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (virObjectEventInitialize() < 0)
return NULL;
}
-virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj)
+virObjectEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj)
{
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (virObjectEventInitialize() < 0)
return NULL;
}
static
-virDomainEventPtr virDomainEventDiskChangeNew(int id, const char *name,
+virObjectEventPtr virDomainEventDiskChangeNew(int id, const char *name,
unsigned char *uuid,
const char *oldSrcPath,
const char *newSrcPath,
ev->reason = reason;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
error:
virObjectUnref(ev);
return NULL;
}
-virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
newSrcPath, devAlias, reason);
}
-virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
devAlias, reason);
}
-static virDomainEventPtr
+static virObjectEventPtr
virDomainEventTrayChangeNew(int id, const char *name,
unsigned char *uuid,
const char *devAlias,
ev->reason = reason;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
error:
virObjectUnref(ev);
return NULL;
}
-virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
const char *devAlias,
int reason)
{
reason);
}
-virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
const char *devAlias,
int reason)
{
devAlias, reason);
}
-static virDomainEventPtr
+static virObjectEventPtr
virDomainEventPMWakeupNew(int id, const char *name,
unsigned char *uuid)
{
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (virObjectEventInitialize() < 0)
return NULL;
return ev;
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMWakeupNew(obj->def->id,
obj->def->uuid);
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMWakeupNewFromDom(virDomainPtr dom)
{
return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid);
}
-static virDomainEventPtr
+static virObjectEventPtr
virDomainEventPMSuspendNew(int id, const char *name,
unsigned char *uuid)
{
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (virObjectEventInitialize() < 0)
return NULL;
return ev;
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMSuspendNew(obj->def->id,
obj->def->uuid);
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMSuspendNewFromDom(virDomainPtr dom)
{
return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid);
}
-static virDomainEventPtr
+static virObjectEventPtr
virDomainEventPMSuspendDiskNew(int id, const char *name,
unsigned char *uuid)
{
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (virObjectEventInitialize() < 0)
return NULL;
return ev;
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMSuspendDiskNew(obj->def->id,
obj->def->uuid);
}
-virDomainEventPtr
+virObjectEventPtr
virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom)
{
return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid);
}
-virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
unsigned long long actual)
{
virDomainEventBalloonChangePtr ev;
ev->actual = actual;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
unsigned long long actual)
{
virDomainEventBalloonChangePtr ev;
ev->actual = actual;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
}
-static virDomainEventPtr virDomainEventDeviceRemovedNew(int id,
+static virObjectEventPtr virDomainEventDeviceRemovedNew(int id,
const char *name,
unsigned char *uuid,
const char *devAlias)
if (VIR_STRDUP(ev->devAlias, devAlias) < 0)
goto error;
- return (virDomainEventPtr)ev;
+ return (virObjectEventPtr)ev;
error:
virObjectUnref(ev);
return NULL;
}
-virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
const char *devAlias)
{
return virDomainEventDeviceRemovedNew(obj->def->id, obj->def->name,
obj->def->uuid, devAlias);
}
-virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
const char *devAlias)
{
return virDomainEventDeviceRemovedNew(dom->id, dom->name, dom->uuid,
*/
static int
virObjectEventQueuePush(virObjectEventQueuePtr evtQueue,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
if (!evtQueue) {
return -1;
typedef void (*virObjectEventDispatchFunc)(virConnectPtr conn,
- virDomainEventPtr event,
+ virObjectEventPtr event,
virConnectObjectEventGenericCallback cb,
void *cbopaque,
void *opaque);
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
- virDomainEventPtr event,
+ virObjectEventPtr event,
virConnectDomainEventGenericCallback cb,
void *cbopaque,
void *opaque ATTRIBUTE_UNUSED)
}
-static int virDomainEventDispatchMatchCallback(virDomainEventPtr event,
+static int virObjectEventDispatchMatchCallback(virObjectEventPtr event,
virObjectEventCallbackPtr cb)
{
if (!cb)
static void
-virDomainEventDispatch(virDomainEventPtr event,
+virObjectEventDispatch(virObjectEventPtr event,
virObjectEventCallbackListPtr callbacks,
virObjectEventDispatchFunc dispatch,
void *opaque)
int cbCount = callbacks->count;
for (i = 0; i < cbCount; i++) {
- if (!virDomainEventDispatchMatchCallback(event, callbacks->callbacks[i]))
+ if (!virObjectEventDispatchMatchCallback(event, callbacks->callbacks[i]))
continue;
(*dispatch)(callbacks->callbacks[i]->conn,
size_t i;
for (i = 0; i < queue->count; i++) {
- virDomainEventDispatch(queue->events[i], callbacks, dispatch, opaque);
+ virObjectEventDispatch(queue->events[i], callbacks, dispatch, opaque);
virObjectUnref(queue->events[i]);
}
VIR_FREE(queue->events);
void
virObjectEventStateQueue(virObjectEventStatePtr state,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
if (state->timer < 0) {
virObjectUnref(event);
static void
virObjectEventStateDispatchFunc(virConnectPtr conn,
- virDomainEventPtr event,
+ virObjectEventPtr event,
virConnectObjectEventGenericCallback cb,
void *cbopaque,
void *opaque)
typedef struct _virObjectEvent virObjectEvent;
typedef virObjectEvent *virObjectEventPtr;
-typedef struct _virDomainEvent virDomainEvent;
-typedef virDomainEvent *virDomainEventPtr;
-
typedef struct _virObjectEventState virObjectEventState;
typedef virObjectEventState *virObjectEventStatePtr;
-virDomainEventPtr virDomainEventLifecycleNew(int id,
+virObjectEventPtr virDomainEventLifecycleNew(int id,
const char *name,
const unsigned char *uuid,
int type,
int detail);
-virDomainEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventLifecycleNewFromDom(virDomainPtr dom,
int type,
int detail);
-virDomainEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventLifecycleNewFromObj(virDomainObjPtr obj,
int type,
int detail);
-virDomainEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def,
+virObjectEventPtr virDomainEventLifecycleNewFromDef(virDomainDefPtr def,
int type,
int detail);
-virDomainEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid);
-virDomainEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventRebootNew(int id, const char *name, const unsigned char *uuid);
+virObjectEventPtr virDomainEventRebootNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventRebootNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset);
-virDomainEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset);
+virObjectEventPtr virDomainEventRTCChangeNewFromDom(virDomainPtr dom, long long offset);
+virObjectEventPtr virDomainEventRTCChangeNewFromObj(virDomainObjPtr obj, long long offset);
-virDomainEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
-virDomainEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
+virObjectEventPtr virDomainEventWatchdogNewFromDom(virDomainPtr dom, int action);
+virObjectEventPtr virDomainEventWatchdogNewFromObj(virDomainObjPtr obj, int action);
-virDomainEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action);
-virDomainEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorNewFromObj(virDomainObjPtr obj,
const char *srcPath,
const char *devAlias,
int action);
-virDomainEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromDom(virDomainPtr dom,
const char *srcPath,
const char *devAlias,
int action,
const char *reason);
-virDomainEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventIOErrorReasonNewFromObj(virDomainObjPtr obj,
const char *srcPath,
const char *devAlias,
int action,
const char *reason);
-virDomainEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventGraphicsNewFromDom(virDomainPtr dom,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject);
-virDomainEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventGraphicsNewFromObj(virDomainObjPtr obj,
int phase,
virDomainEventGraphicsAddressPtr local,
virDomainEventGraphicsAddressPtr remote,
const char *authScheme,
virDomainEventGraphicsSubjectPtr subject);
-virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventControlErrorNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventBlockJobNewFromObj(virDomainObjPtr obj,
const char *path,
int type,
int status);
-virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
const char *path,
int type,
int status);
-virDomainEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDiskChangeNewFromObj(virDomainObjPtr obj,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
int reason);
-virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
const char *oldSrcPath,
const char *newSrcPath,
const char *devAlias,
int reason);
-virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj,
const char *devAlias,
int reason);
-virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
const char *devAlias,
int reason);
-virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual);
-virDomainEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual);
+virObjectEventPtr virDomainEventBalloonChangeNewFromDom(virDomainPtr dom, unsigned long long actual);
+virObjectEventPtr virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj, unsigned long long actual);
-virDomainEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
-virDomainEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom);
+virObjectEventPtr virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
+virObjectEventPtr virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom);
-virDomainEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
const char *devAlias);
-virDomainEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
+virObjectEventPtr virDomainEventDeviceRemovedNewFromDom(virDomainPtr dom,
const char *devAlias);
void virObjectEventStateFree(virObjectEventStatePtr state);
void
virObjectEventStateQueue(virObjectEventStatePtr state,
- virDomainEventPtr event)
+ virObjectEventPtr event)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int virDomainEventStateRegister(virConnectPtr conn,
virObjectEventStatePtr state,
}
static void
-libxlDomainEventQueue(libxlDriverPrivatePtr driver, virDomainEventPtr event)
+libxlDomainEventQueue(libxlDriverPrivatePtr driver, virObjectEventPtr event)
{
virObjectEventStateQueue(driver->domainEventState, event);
}
libxlDriverPrivatePtr driver = libxl_driver;
libxlDomainObjPrivatePtr priv = ((virDomainObjPtr)data)->privateData;
virDomainObjPtr vm = NULL;
- virDomainEventPtr dom_event = NULL;
+ virObjectEventPtr dom_event = NULL;
libxl_shutdown_reason xl_reason = event->u.domain_shutdown.shutdown_reason;
if (event->type == LIBXL_EVENT_TYPE_DOMAIN_SHUTDOWN) {
{
libxl_domain_config d_config;
virDomainDefPtr def = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
libxlSavefileHeader hdr;
int ret;
uint32_t domid = 0;
libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
virDomainObjPtr vm;
libxlDomainObjPrivatePtr priv;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
virDomainObjPtr vm;
libxlDomainObjPrivatePtr priv;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
if (!(vm = libxlDomObjFromDomain(dom)))
libxlDriverPrivatePtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virCheckFlags(0, -1);
{
libxlDomainObjPrivatePtr priv = vm->privateData;
libxlSavefileHeader hdr;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
char *xml = NULL;
uint32_t xml_len;
int fd = -1;
libxlDriverPrivatePtr driver = dom->conn->privateData;
libxlDomainObjPrivatePtr priv;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
bool paused = false;
int ret = -1;
virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainDefPtr oldDef = NULL;
/* Lock the driver until the virDomainObj is created and locked */
libxlDriverPrivatePtr driver = dom->conn->privateData;
libxlDriverConfigPtr cfg = libxlDriverConfigGet(driver);
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
char *name = NULL;
int ret = -1;
virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainDefPtr oldDef = NULL;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
virCapsPtr caps = NULL;
{
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
{
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
virDomainObjPtr vm = NULL;
virDomainDefPtr def = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
virCapsPtr caps = NULL;
{
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virLXCDomainObjPrivatePtr priv;
virLXCDriverPtr driver = opaque;
if (newVM) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
VIR_DOMAIN_EVENT_DEFINED_ADDED);
{
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
{
virLXCDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virLXCDomainObjPrivatePtr priv;
virLXCDriverConfigPtr cfg = virLXCDriverGetConfig(driver);
void *opaque)
{
virLXCDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virLXCDomainObjPrivatePtr priv;
VIR_DEBUG("driver=%p dom=%s conn=%p", driver, dom->def->name, conn);
virDomainObjPtr vm)
{
virLXCDriverPtr driver = lxc_driver;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virLXCDomainObjPrivatePtr priv;
VIR_DEBUG("mon=%p vm=%p", mon, vm);
vm->def->name,
err ? err->message : "");
} else {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
void qemuDomainEventQueue(virQEMUDriverPtr driver,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
virObjectEventStateQueue(driver->domainEventState, event);
}
virDomainDiskDefPtr disk)
{
char uuid[VIR_UUID_STRING_BUFLEN];
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainDiskDefPtr del_disk = NULL;
virUUIDFormat(vm->def->uuid, uuid);
void qemuDomainEventFlush(int timer, void *opaque);
void qemuDomainEventQueue(virQEMUDriverPtr driver,
- virDomainEventPtr event);
+ virObjectEventPtr event);
int qemuDomainObjBeginJob(virQEMUDriverPtr driver,
virDomainObjPtr obj,
virQEMUDriverPtr driver = opaque;
if (newVM) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
VIR_DOMAIN_EVENT_DEFINED_ADDED);
virDomainDefPtr def = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
- virDomainEventPtr event2 = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr event2 = NULL;
unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
virQEMUCapsPtr qemuCaps = NULL;
virCapsPtr caps = NULL;
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
qemuDomainObjPrivatePtr priv;
virDomainPausedReason reason;
int eventDetail;
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int state;
virQEMUDriverConfigPtr cfg = NULL;
virCapsPtr caps = NULL;
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret = -1;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
qemuDomainObjPrivatePtr priv;
virCheckFlags(VIR_DOMAIN_DESTROY_GRACEFUL, -1);
bool was_running = false;
int ret = -1;
int rc;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
qemuDomainObjPrivatePtr priv = vm->privateData;
virCapsPtr caps;
qemuDomainObjPrivatePtr priv;
bool resume = false, paused = false;
int ret = -1;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virCheckFlags(VIR_DUMP_LIVE | VIR_DUMP_CRASH |
VIR_DUMP_BYPASS_CACHE | VIR_DUMP_RESET |
int action)
{
qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
if (!virDomainObjIsActive(vm)) {
bool start_paused)
{
int ret = -1;
- virDomainEventPtr event;
+ virObjectEventPtr event;
int intermediatefd = -1;
virCommandPtr cmd = NULL;
char *errbuf = NULL;
VIR_NETDEV_VPORT_PROFILE_OP_CREATE, start_flags);
virDomainAuditStart(vm, "booted", ret >= 0);
if (ret >= 0) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
virDomainDefPtr oldDef = NULL;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUCapsPtr qemuCaps = NULL;
virQEMUDriverConfigPtr cfg;
virCapsPtr caps = NULL;
{
virQEMUDriverPtr driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
char *name = NULL;
int ret = -1;
int nsnapshots;
{
virDomainObjPtr vm = *vmptr;
qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
bool resume = false;
int ret = -1;
/* the snapshot is complete now */
if (flags & VIR_DOMAIN_SNAPSHOT_CREATE_HALT) {
- virDomainEventPtr event;
+ virObjectEventPtr event;
event = virDomainEventLifecycleNewFromObj(vm, VIR_DOMAIN_EVENT_STOPPED,
VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT);
/* qemu 1.3 is unable to save a domain in pm-suspended (S3)
* state; so we must emit an event stating that it was
* converted to paused. */
- virDomainEventPtr event;
+ virObjectEventPtr event;
virDomainObjSetState(vm, VIR_DOMAIN_PAUSED,
VIR_DOMAIN_PAUSED_FROM_SNAPSHOT);
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
QEMU_ASYNC_JOB_SNAPSHOT) < 0) {
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_SUSPENDED,
VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
virDomainObjPtr vm = NULL;
int ret = -1;
virDomainSnapshotObjPtr snap = NULL;
- virDomainEventPtr event = NULL;
- virDomainEventPtr event2 = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr event2 = NULL;
int detail;
qemuDomainObjPrivatePtr priv;
int rc;
qemuProcessStartCPUs(driver, vm, conn,
VIR_DOMAIN_RUNNING_UNPAUSED,
QEMU_ASYNC_JOB_NONE) < 0) {
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_SUSPENDED,
VIR_DOMAIN_EVENT_SUSPENDED_API_ERROR);
char *device = NULL;
int ret = -1;
bool async = false;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int idx;
virDomainDiskDefPtr disk;
virDomainDiskDefPtr disk)
{
virDomainDeviceDef dev;
- virDomainEventPtr event;
+ virObjectEventPtr event;
size_t i;
VIR_DEBUG("Removing disk %s from domain %p %s",
virDomainObjPtr vm,
virDomainControllerDefPtr controller)
{
- virDomainEventPtr event;
+ virObjectEventPtr event;
size_t i;
VIR_DEBUG("Removing controller %s from domain %p %s",
{
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virDomainNetDefPtr net = NULL;
- virDomainEventPtr event;
+ virObjectEventPtr event;
size_t i;
VIR_DEBUG("Removing host device %s from domain %p %s",
{
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virNetDevVPortProfilePtr vport;
- virDomainEventPtr event;
+ virObjectEventPtr event;
size_t i;
if (virDomainNetGetActualType(net) == VIR_DOMAIN_NET_TYPE_HOSTDEV) {
virDomainObjPtr vm,
virDomainChrDefPtr chr)
{
- virDomainEventPtr event;
+ virObjectEventPtr event;
VIR_DEBUG("Removing character device %s from domain %p %s",
chr->info.alias, vm, vm->def->name);
ret = qemuProcessStopCPUs(driver, vm, VIR_DOMAIN_PAUSED_MIGRATION,
QEMU_ASYNC_JOB_MIGRATION_OUT);
if (ret == 0) {
- virDomainEventPtr event;
+ virObjectEventPtr event;
event = virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_SUSPENDED,
unsigned long flags)
{
virDomainObjPtr vm = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
int dataFD[2] = { -1, -1 };
qemuDomainObjPrivatePtr priv = NULL;
int retcode)
{
qemuMigrationCookiePtr mig;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int rv = -1;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
unsigned long resource,
bool v3proto)
{
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
int resume = 0;
virErrorPtr orig_err = NULL;
unsigned long flags,
unsigned long resource)
{
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
bool resume;
bool hasrefs;
bool v3proto)
{
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
bool newVM = true;
qemuMigrationCookiePtr mig = NULL;
virErrorPtr orig_err = NULL;
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
qemuDomainObjPrivatePtr priv;
int eventReason = VIR_DOMAIN_EVENT_STOPPED_SHUTDOWN;
int stopReason = VIR_DOMAIN_SHUTOFF_SHUTDOWN;
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
VIR_DEBUG("Received error on %p '%s'", vm, vm->def->name);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event;
+ virObjectEventPtr event;
qemuDomainObjPrivatePtr priv;
virObjectLock(vm);
virQEMUDriverPtr driver = qemu_driver;
virDomainObjPtr vm = opaque;
qemuDomainObjPrivatePtr priv = vm->privateData;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virDomainRunningReason reason = VIR_DOMAIN_RUNNING_BOOTED;
int ret = -1;
{
virQEMUDriverPtr driver = opaque;
qemuDomainObjPrivatePtr priv;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
VIR_DEBUG("vm=%p", vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr watchdogEvent = NULL;
- virDomainEventPtr lifecycleEvent = NULL;
+ virObjectEventPtr watchdogEvent = NULL;
+ virObjectEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr ioErrorEvent = NULL;
- virDomainEventPtr ioErrorEvent2 = NULL;
- virDomainEventPtr lifecycleEvent = NULL;
+ virObjectEventPtr ioErrorEvent = NULL;
+ virObjectEventPtr ioErrorEvent2 = NULL;
+ virObjectEventPtr lifecycleEvent = NULL;
const char *srcPath;
const char *devAlias;
virDomainDiskDefPtr disk;
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
const char *path;
virDomainDiskDefPtr disk;
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event;
+ virObjectEventPtr event;
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
virDomainEventGraphicsSubjectPtr subject = NULL;
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainDiskDefPtr disk;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
- virDomainEventPtr lifecycleEvent = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
- virDomainEventPtr lifecycleEvent = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
void *opaque)
{
virQEMUDriverPtr driver = opaque;
- virDomainEventPtr event = NULL;
- virDomainEventPtr lifecycleEvent = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr lifecycleEvent = NULL;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
virObjectLock(vm);
{
virQEMUDriverPtr driver = opaque;
qemuDomainObjPrivatePtr priv = dom->privateData;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
VIR_DEBUG("vm=%s, conn=%p", dom->def->name, conn);
static void make_nonnull_secret(remote_nonnull_secret *secret_dst, virSecretPtr secret_src);
static void make_nonnull_nwfilter(remote_nonnull_nwfilter *nwfilter_dst, virNWFilterPtr nwfilter_src);
static void make_nonnull_domain_snapshot(remote_nonnull_domain_snapshot *snapshot_dst, virDomainSnapshotPtr snapshot_src);
-static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event);
+static void remoteDomainEventQueue(struct private_data *priv, virObjectEventPtr event);
/*----------------------------------------------------------------------*/
/* Helper functions for remoteOpen. */
struct private_data *priv = conn->privateData;
remote_domain_event_lifecycle_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_reboot_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_rtc_change_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_watchdog_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_io_error_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_io_error_reason_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_block_job_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_graphics_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainEventGraphicsAddressPtr localAddr = NULL;
virDomainEventGraphicsAddressPtr remoteAddr = NULL;
virDomainEventGraphicsSubjectPtr subject = NULL;
struct private_data *priv = conn->privateData;
remote_domain_event_control_error_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_disk_change_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_tray_change_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_pmwakeup_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_pmsuspend_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_balloon_change_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_pmsuspend_disk_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
struct private_data *priv = conn->privateData;
remote_domain_event_device_removed_msg *msg = evdata;
virDomainPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
dom = get_nonnull_domain(conn, msg->dom);
if (!dom)
}
static void
-remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event)
+remoteDomainEventQueue(struct private_data *priv, virObjectEventPtr event)
{
virObjectEventStateQueue(priv->domainEventState, event);
}
static int testConnectClose(virConnectPtr conn);
static void testDomainEventQueue(testConnPtr driver,
- virDomainEventPtr event);
+ virObjectEventPtr event);
static void testDriverLock(testConnPtr driver)
virDomainPtr ret = NULL;
virDomainDefPtr def;
virDomainObjPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virCheckFlags(0, NULL);
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
testDriverLock(privconn);
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
testDriverLock(privconn);
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
int state;
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(0, -1);
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
testDriverLock(privconn);
int fd = -1;
int len;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(0, -1);
int len;
virDomainDefPtr def = NULL;
virDomainObjPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(0, -1);
testConnPtr privconn = domain->conn->privateData;
int fd = -1;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(VIR_DUMP_CRASH, -1);
virDomainPtr ret = NULL;
virDomainDefPtr def;
virDomainObjPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virDomainDefPtr oldDef = NULL;
testDriverLock(privconn);
static int testDomainCreateWithFlags(virDomainPtr domain, unsigned int flags) {
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(0, -1);
{
testConnPtr privconn = domain->conn->privateData;
virDomainObjPtr privdom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int nsnapshots;
int ret = -1;
/* driver must be locked before calling */
static void testDomainEventQueue(testConnPtr driver,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
virObjectEventStateQueue(driver->domainEventState, event);
}
{
testConnPtr privconn = dom->conn->privateData;
virDomainObjPtr vm = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_SAVE_BYPASS_CACHE |
virDomainSnapshotDefPtr def = NULL;
virDomainSnapshotObjPtr snap = NULL;
virDomainSnapshotPtr snapshot = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
char *xml = NULL;
bool update_current = true;
bool redefine = flags & VIR_DOMAIN_SNAPSHOT_CREATE_REDEFINE;
testConnPtr privconn = snapshot->domain->conn->privateData;
virDomainObjPtr vm = NULL;
virDomainSnapshotObjPtr snap = NULL;
- virDomainEventPtr event = NULL;
- virDomainEventPtr event2 = NULL;
+ virObjectEventPtr event = NULL;
+ virObjectEventPtr event2 = NULL;
virDomainDefPtr config = NULL;
int ret = -1;
static int umlReadPidFile(struct uml_driver *driver,
virDomainObjPtr vm);
static void umlDomainEventQueue(struct uml_driver *driver,
- virDomainEventPtr event);
+ virObjectEventPtr event);
static int umlStartVMDaemon(virConnectPtr conn,
struct uml_driver *driver,
VIR_ERROR(_("Failed to autostart VM '%s': %s"),
vm->def->name, err ? err->message : _("unknown error"));
} else {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_STARTED,
VIR_DOMAIN_EVENT_STARTED_BOOTED);
char *tmp, *name;
struct uml_driver *driver = data;
virDomainObjPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
umlDriverLock(driver);
if (watch != driver->inotifyWatch)
struct uml_driver *driver = opaque;
if (newVM) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNewFromObj(vm,
VIR_DOMAIN_EVENT_DEFINED,
VIR_DOMAIN_EVENT_DEFINED_ADDED);
const char *uuidstr = name;
unsigned char uuid[VIR_UUID_BUFLEN];
virDomainObjPtr dom;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
VIR_DEBUG("conn=%p uuidstr=%s thisconn=%p", conn, uuidstr, data->conn);
virDomainDefPtr def;
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, NULL);
{
struct uml_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(0, -1);
static int umlDomainCreateWithFlags(virDomainPtr dom, unsigned int flags) {
struct uml_driver *driver = dom->conn->privateData;
virDomainObjPtr vm;
- virDomainEventPtr event = NULL;
+ virObjectEventPtr event = NULL;
int ret = -1;
virCheckFlags(VIR_DOMAIN_START_AUTODESTROY, -1);
/* driver must be locked before calling */
static void umlDomainEventQueue(struct uml_driver *driver,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
virObjectEventStateQueue(driver->domainEventState, event);
}
dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
if (dom) {
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
if (state == MachineState_Starting) {
event = VIR_DOMAIN_EVENT_STARTED;
dom = vboxDomainLookupByUUID(g_pVBoxGlobalData->conn, uuid);
if (dom) {
- virDomainEventPtr ev;
+ virObjectEventPtr ev;
/* CURRENT LIMITATION: we never get the VIR_DOMAIN_EVENT_UNDEFINED
* event because the when the machine is de-registered the call
*
*/
void xenUnifiedDomainEventDispatch(xenUnifiedPrivatePtr priv,
- virDomainEventPtr event)
+ virObjectEventPtr event)
{
if (!priv)
return;
int id, char *name,
unsigned char *uuid);
void xenUnifiedDomainEventDispatch (xenUnifiedPrivatePtr priv,
- virDomainEventPtr event);
+ virObjectEventPtr event);
unsigned long xenUnifiedVersion(void);
int xenUnifiedConnectGetMaxVcpus(virConnectPtr conn, const char *type);
return xenInotifyXendDomainsDirLookup(conn, filename, name, uuid);
}
-static virDomainEventPtr
+static virObjectEventPtr
xenInotifyDomainEventFromFile(virConnectPtr conn,
const char *filename,
int type,
int detail)
{
- virDomainEventPtr event;
+ virObjectEventPtr event;
char *name = NULL;
unsigned char uuid[VIR_UUID_BUFLEN];
priv->configDir, name);
if (e->mask & (IN_DELETE | IN_MOVED_FROM)) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
xenInotifyDomainEventFromFile(conn, fname,
VIR_DOMAIN_EVENT_UNDEFINED,
VIR_DOMAIN_EVENT_UNDEFINED_REMOVED);
goto cleanup;
}
} else if (e->mask & (IN_CREATE | IN_CLOSE_WRITE | IN_MOVED_TO)) {
- virDomainEventPtr event;
+ virObjectEventPtr event;
if (xenInotifyAddDomainConfigInfo(conn, fname) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("Error adding file to config cache"));
}
if (!found) {
- virDomainEventPtr event;
+ virObjectEventPtr event;
char *name;
unsigned char uuid[VIR_UUID_BUFLEN];
}
if (!found) {
- virDomainEventPtr event =
+ virObjectEventPtr event =
virDomainEventLifecycleNew(-1,
priv->activeDomainList->doms[j]->name,
priv->activeDomainList->doms[j]->uuid,
projects / people / dariof / libvirt.git / commitdiff