Move domain events helpers into dedicated file

This commit is contained in:
Daniel P. Berrange 2008-11-04 23:33:57 +00:00
parent 6ace5a39c3
commit 2ea1eceb75
10 changed files with 340 additions and 277 deletions

View File

@ -1,3 +1,17 @@
Tue Nov 4 23:33:31 UTC 2008 Daniel P. Berrange <berrange@redhat.com>
Move domain events helpers into domain_events.c
* qemud/event.c: Remove __ prefix on poll event
convertors
* qemud/event.h: Add virEventHandleTypeToPollEvent and
virPollEventToEventHandleType declarations
* src/Makefile.am, src/domain_event.c, src/domain_event.h:
Add dedicated file for internal domain events helpers
* src/internal.h, src/libvirt.c: Remove domain events
helpers
* src/qemu_conf.h, src/remote_internal.c: Add includs
of domain_event.h
Tue Nov 4 23:08:31 UTC 2008 Daniel P. Berrange <berrange@redhat.com> Tue Nov 4 23:08:31 UTC 2008 Daniel P. Berrange <berrange@redhat.com>
Move internal API declarations from generic internal.h file Move internal API declarations from generic internal.h file

View File

@ -489,7 +489,7 @@ int virEventRunOnce(void) {
} }
int int
__virEventHandleTypeToPollEvent(virEventHandleType events) virEventHandleTypeToPollEvent(int events)
{ {
int ret = 0; int ret = 0;
if(events & VIR_EVENT_HANDLE_READABLE) if(events & VIR_EVENT_HANDLE_READABLE)
@ -503,10 +503,10 @@ __virEventHandleTypeToPollEvent(virEventHandleType events)
return ret; return ret;
} }
virEventHandleType int
__virPollEventToEventHandleType(int events) virPollEventToEventHandleType(int events)
{ {
virEventHandleType ret = 0; int ret = 0;
if(events & POLLIN) if(events & POLLIN)
ret |= VIR_EVENT_HANDLE_READABLE; ret |= VIR_EVENT_HANDLE_READABLE;
if(events & POLLOUT) if(events & POLLOUT)

View File

@ -105,4 +105,11 @@ int virEventRemoveTimeoutImpl(int timer);
*/ */
int virEventRunOnce(void); int virEventRunOnce(void);
int
virEventHandleTypeToPollEvent(int events);
int
virPollEventToEventHandleType(int events);
#endif /* __VIRTD_EVENT_H__ */ #endif /* __VIRTD_EVENT_H__ */

View File

@ -150,6 +150,7 @@ libvirt_la_SOURCES = \
driver.h \ driver.h \
internal.h \ internal.h \
datatypes.c datatypes.h \ datatypes.c datatypes.h \
domain_event.c domain_event.h \
libvirt.c libvirt_internal.h \ libvirt.c libvirt_internal.h \
$(GENERIC_LIB_SOURCES) \ $(GENERIC_LIB_SOURCES) \
$(DOMAIN_CONF_SOURCES) \ $(DOMAIN_CONF_SOURCES) \

229
src/domain_event.c Normal file
View File

@ -0,0 +1,229 @@
/*
* domain_event.c: domain event queue processing helpers
*
* Copyright (C) 2008 VirtualIron
*
* 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: Ben Guthro
*/
#include <config.h>
#include "domain_event.h"
#include "datatypes.h"
#include "memory.h"
/**
* virDomainEventCallbackListFree:
* @list: event callback list head
*
* Free the memory in the domain event callback list
*/
void
virDomainEventCallbackListFree(virDomainEventCallbackListPtr list)
{
int i;
for (i=0; i<list->count; i++) {
VIR_FREE(list->callbacks[i]);
}
VIR_FREE(list);
}
/**
* virDomainEventCallbackListRemove:
* @conn: pointer to the connection
* @cbList: the list
* @callback: the callback to remove
*
* Internal function to remove a callback from a virDomainEventCallbackListPtr
*/
int
virDomainEventCallbackListRemove(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback)
{
int i;
for (i = 0 ; i < cbList->count ; i++) {
if(cbList->callbacks[i]->cb == callback &&
cbList->callbacks[i]->conn == conn) {
virUnrefConnect(cbList->callbacks[i]->conn);
VIR_FREE(cbList->callbacks[i]);
if (i < (cbList->count - 1))
memmove(cbList->callbacks + i,
cbList->callbacks + i + 1,
sizeof(*(cbList->callbacks)) *
(cbList->count - (i + 1)));
if (VIR_REALLOC_N(cbList->callbacks,
cbList->count - 1) < 0) {
; /* Failure to reduce memory allocation isn't fatal */
}
cbList->count--;
return 0;
}
}
return -1;
}
/**
* virDomainEventCallbackListAdd:
* @conn: pointer to the connection
* @cbList: the list
* @callback: the callback to add
* @opaque: opaque data tio pass to callback
*
* Internal function to add a callback from a virDomainEventCallbackListPtr
*/
int
virDomainEventCallbackListAdd(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback,
void *opaque)
{
virDomainEventCallbackPtr event;
int n;
/* Check incoming */
if ( !cbList ) {
return -1;
}
/* check if we already have this callback on our list */
for (n=0; n < cbList->count; n++) {
if(cbList->callbacks[n]->cb == callback &&
conn == cbList->callbacks[n]->conn) {
DEBUG0("WARNING: Callback already tracked");
return -1;
}
}
/* Allocate new event */
if (VIR_ALLOC(event) < 0) {
DEBUG0("Error allocating event");
return -1;
}
event->conn = conn;
event->cb = callback;
event->opaque = opaque;
/* Make space on list */
n = cbList->count;
if (VIR_REALLOC_N(cbList->callbacks, n + 1) < 0) {
DEBUG0("Error reallocating list");
VIR_FREE(event);
return -1;
}
event->conn->refs++;
cbList->callbacks[n] = event;
cbList->count++;
return 0;
}
/**
* virDomainEventQueueFree:
* @queue: pointer to the queue
*
* Free the memory in the queue. We process this like a list here
*/
void
virDomainEventQueueFree(virDomainEventQueuePtr queue)
{
int i;
for ( i=0 ; i<queue->count ; i++ ) {
VIR_FREE(queue->events[i]);
}
VIR_FREE(queue);
}
/**
* virDomainEventCallbackQueuePop:
* @evtQueue: the queue of events
*
* Internal function to pop off, and return the front of the queue
* NOTE: The caller is responsible for freeing the returned object
*
* Returns: virDomainEventPtr on success NULL on failure.
*/
virDomainEventPtr
virDomainEventCallbackQueuePop(virDomainEventQueuePtr evtQueue)
{
virDomainEventPtr ret;
if(!evtQueue || evtQueue->count == 0 )
return NULL;
ret = evtQueue->events[0];
memmove(evtQueue->events,
evtQueue->events + 1,
sizeof(*(evtQueue->events)) *
(evtQueue->count - 1));
if (VIR_REALLOC_N(evtQueue->events,
evtQueue->count - 1) < 0) {
; /* Failure to reduce memory allocation isn't fatal */
}
evtQueue->count--;
return ret;
}
/**
* virDomainEventCallbackQueuePush:
* @evtQueue: the dom event queue
* @dom: the domain to add
* @event: the event to add
*
* Internal function to push onto the back of an virDomainEventQueue
*
* Returns: 0 on success, -1 on failure
*/
int
virDomainEventCallbackQueuePush(virDomainEventQueuePtr evtQueue,
virDomainPtr dom,
virDomainEventType event)
{
virDomainEventPtr domEvent;
/* Check incoming */
if ( !evtQueue ) {
return -1;
}
/* Allocate new event */
if (VIR_ALLOC(domEvent) < 0) {
DEBUG0("Error allocating event");
return -1;
}
domEvent->dom = dom;
domEvent->event = event;
/* Make space on queue */
if (VIR_REALLOC_N(evtQueue->events,
evtQueue->count + 1) < 0) {
DEBUG0("Error reallocating queue");
VIR_FREE(domEvent);
return -1;
}
evtQueue->events[evtQueue->count] = domEvent;
evtQueue->count++;
return 0;
}

83
src/domain_event.h Normal file
View File

@ -0,0 +1,83 @@
/*
* domain_event.h: domain event queue processing helpers
*
* Copyright (C) 2008 VirtualIron
*
* 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: Ben Guthro
*/
#include "internal.h"
#ifndef __DOMAIN_EVENT_H__
#define __DOMAIN_EVENT_H__
struct _virDomainEventCallback {
virConnectPtr conn;
virConnectDomainEventCallback cb;
void *opaque;
};
typedef struct _virDomainEventCallback virDomainEventCallback;
typedef virDomainEventCallback *virDomainEventCallbackPtr;
struct _virDomainEventCallbackList {
unsigned int count;
virDomainEventCallbackPtr *callbacks;
};
typedef struct _virDomainEventCallbackList virDomainEventCallbackList;
typedef virDomainEventCallbackList *virDomainEventCallbackListPtr;
void virDomainEventCallbackListFree(virDomainEventCallbackListPtr list);
int virDomainEventCallbackListAdd(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback,
void *opaque);
int virDomainEventCallbackListRemove(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback);
/**
* Dispatching domain events that come in while
* in a call / response rpc
*/
struct _virDomainEvent {
virDomainPtr dom;
virDomainEventType event;
};
typedef struct _virDomainEvent virDomainEvent;
typedef virDomainEvent *virDomainEventPtr;
struct _virDomainEventQueue {
unsigned int count;
virDomainEventPtr *events;
};
typedef struct _virDomainEventQueue virDomainEventQueue;
typedef virDomainEventQueue *virDomainEventQueuePtr;
int virDomainEventCallbackQueuePush(virDomainEventQueuePtr evtQueue,
virDomainPtr dom,
virDomainEventType event);
virDomainEventPtr
virDomainEventCallbackQueuePop(virDomainEventQueuePtr evtQueue);
void virDomainEventQueueFree(virDomainEventQueuePtr queue);
#endif

View File

@ -139,76 +139,4 @@ extern int debugFlag;
fprintf(stderr, "Unimplemented block at %s:%d\n", \ fprintf(stderr, "Unimplemented block at %s:%d\n", \
__FILE__, __LINE__); __FILE__, __LINE__);
/**
* Domain Event Notification
*/
struct _virDomainEventCallback {
virConnectPtr conn;
virConnectDomainEventCallback cb;
void *opaque;
};
typedef struct _virDomainEventCallback virDomainEventCallback;
typedef virDomainEventCallback *virDomainEventCallbackPtr;
struct _virDomainEventCallbackList {
unsigned int count;
virDomainEventCallbackPtr *callbacks;
};
typedef struct _virDomainEventCallbackList virDomainEventCallbackList;
typedef virDomainEventCallbackList *virDomainEventCallbackListPtr;
void __virDomainEventCallbackListFree(virDomainEventCallbackListPtr list);
#define virDomainEventCallbackListFree(x) __virDomainEventCallbackListFree(x)
int __virDomainEventCallbackListAdd(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback,
void *opaque);
#define virDomainEventCallbackListAdd(a,b,c,d) \
__virDomainEventCallbackListAdd((a),(b),(c),(d))
int __virDomainEventCallbackListRemove(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback);
#define virDomainEventCallbackListRemove(a,b,c) \
__virDomainEventCallbackListRemove((a),(b),(c))
int __virEventHandleTypeToPollEvent(virEventHandleType events);
#define virEventHandleTypeToPollEvent(x) __virEventHandleTypeToPollEvent(x)
virEventHandleType __virPollEventToEventHandleType(int events);
#define virPollEventToEventHandleType(x) __virPollEventToEventHandleType(x)
/**
* Dispatching domain events that come in while
* in a call / response rpc
*/
struct _virDomainEvent {
virDomainPtr dom;
virDomainEventType event;
};
typedef struct _virDomainEvent virDomainEvent;
typedef virDomainEvent *virDomainEventPtr;
struct _virDomainEventQueue {
unsigned int count;
virDomainEventPtr *events;
};
typedef struct _virDomainEventQueue virDomainEventQueue;
typedef virDomainEventQueue *virDomainEventQueuePtr;
int __virDomainEventCallbackQueuePush(virDomainEventQueuePtr evtQueue,
virDomainPtr dom,
virDomainEventType event);
#define virDomainEventCallbackQueuePush(a,b,c) \
__virDomainEventCallbackQueuePush((a),(b),(c))
virDomainEventPtr
__virDomainEventCallbackQueuePop(virDomainEventQueuePtr evtQueue);
#define virDomainEventCallbackQueuePop(x) __virDomainEventCallbackQueuePop(x)
void __virDomainEventQueueFree(virDomainEventQueuePtr queue);
#define virDomainEventQueueFree(x) __virDomainEventQueueFree(x)
#endif /* __VIR_INTERNAL_H__ */ #endif /* __VIR_INTERNAL_H__ */

View File

@ -5364,205 +5364,4 @@ virConnectDomainEventDeregister(virConnectPtr conn,
return -1; return -1;
} }
/**
* __virDomainEventCallbackListFree:
* @list: event callback list head
*
* Free the memory in the domain event callback list
*/
void
__virDomainEventCallbackListFree(virDomainEventCallbackListPtr list)
{
int i;
for (i=0; i<list->count; i++) {
VIR_FREE(list->callbacks[i]);
}
VIR_FREE(list);
}
/**
* __virDomainEventCallbackListRemove:
* @conn: pointer to the connection
* @cbList: the list
* @callback: the callback to remove
*
* Internal function to remove a callback from a virDomainEventCallbackListPtr
*/
int
__virDomainEventCallbackListRemove(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback)
{
int i;
for (i = 0 ; i < cbList->count ; i++) {
if(cbList->callbacks[i]->cb == callback &&
cbList->callbacks[i]->conn == conn) {
virUnrefConnect(cbList->callbacks[i]->conn);
VIR_FREE(cbList->callbacks[i]);
if (i < (cbList->count - 1))
memmove(cbList->callbacks + i,
cbList->callbacks + i + 1,
sizeof(*(cbList->callbacks)) *
(cbList->count - (i + 1)));
if (VIR_REALLOC_N(cbList->callbacks,
cbList->count - 1) < 0) {
; /* Failure to reduce memory allocation isn't fatal */
}
cbList->count--;
return 0;
}
}
return -1;
}
/**
* __virDomainEventCallbackListAdd:
* @conn: pointer to the connection
* @cbList: the list
* @callback: the callback to add
* @opaque: opaque data tio pass to callback
*
* Internal function to add a callback from a virDomainEventCallbackListPtr
*/
int
__virDomainEventCallbackListAdd(virConnectPtr conn,
virDomainEventCallbackListPtr cbList,
virConnectDomainEventCallback callback,
void *opaque)
{
virDomainEventCallbackPtr event;
int n;
/* Check incoming */
if ( !cbList ) {
return -1;
}
/* check if we already have this callback on our list */
for (n=0; n < cbList->count; n++) {
if(cbList->callbacks[n]->cb == callback &&
conn == cbList->callbacks[n]->conn) {
DEBUG0("WARNING: Callback already tracked");
return -1;
}
}
/* Allocate new event */
if (VIR_ALLOC(event) < 0) {
DEBUG0("Error allocating event");
return -1;
}
event->conn = conn;
event->cb = callback;
event->opaque = opaque;
/* Make space on list */
n = cbList->count;
if (VIR_REALLOC_N(cbList->callbacks, n + 1) < 0) {
DEBUG0("Error reallocating list");
VIR_FREE(event);
return -1;
}
event->conn->refs++;
cbList->callbacks[n] = event;
cbList->count++;
return 0;
}
/**
* __virDomainEventQueueFree:
* @queue: pointer to the queue
*
* Free the memory in the queue. We process this like a list here
*/
void
__virDomainEventQueueFree(virDomainEventQueuePtr queue)
{
int i;
for ( i=0 ; i<queue->count ; i++ ) {
VIR_FREE(queue->events[i]);
}
VIR_FREE(queue);
}
/**
* __virDomainEventCallbackQueuePop:
* @evtQueue: the queue of events
*
* Internal function to pop off, and return the front of the queue
* NOTE: The caller is responsible for freeing the returned object
*
* Returns: virDomainEventPtr on success NULL on failure.
*/
virDomainEventPtr
__virDomainEventCallbackQueuePop(virDomainEventQueuePtr evtQueue)
{
virDomainEventPtr ret;
if(!evtQueue || evtQueue->count == 0 )
return NULL;
ret = evtQueue->events[0];
memmove(evtQueue->events,
evtQueue->events + 1,
sizeof(*(evtQueue->events)) *
(evtQueue->count - 1));
if (VIR_REALLOC_N(evtQueue->events,
evtQueue->count - 1) < 0) {
; /* Failure to reduce memory allocation isn't fatal */
}
evtQueue->count--;
return ret;
}
/**
* __virDomainEventCallbackQueuePush:
* @evtQueue: the dom event queue
* @dom: the domain to add
* @event: the event to add
*
* Internal function to push onto the back of an virDomainEventQueue
*
* Returns: 0 on success, -1 on failure
*/
int
__virDomainEventCallbackQueuePush(virDomainEventQueuePtr evtQueue,
virDomainPtr dom,
virDomainEventType event)
{
virDomainEventPtr domEvent;
/* Check incoming */
if ( !evtQueue ) {
return -1;
}
/* Allocate new event */
if (VIR_ALLOC(domEvent) < 0) {
DEBUG0("Error allocating event");
return -1;
}
domEvent->dom = dom;
domEvent->event = event;
/* Make space on queue */
if (VIR_REALLOC_N(evtQueue->events,
evtQueue->count + 1) < 0) {
DEBUG0("Error reallocating queue");
VIR_FREE(domEvent);
return -1;
}
evtQueue->events[evtQueue->count] = domEvent;
evtQueue->count++;
return 0;
}

View File

@ -31,6 +31,7 @@
#include "capabilities.h" #include "capabilities.h"
#include "network_conf.h" #include "network_conf.h"
#include "domain_conf.h" #include "domain_conf.h"
#include "domain_event.h"
#define qemudDebug(fmt, ...) do {} while(0) #define qemudDebug(fmt, ...) do {} while(0)

View File

@ -75,6 +75,7 @@
#include "virterror_internal.h" #include "virterror_internal.h"
#include "datatypes.h" #include "datatypes.h"
#include "domain_event.h"
#include "driver.h" #include "driver.h"
#include "buf.h" #include "buf.h"
#include "qparams.h" #include "qparams.h"