[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] PATCH: Move domain event helpers out of internal.h/libvirt.c



There are a bunch of helper functions relating to domain events, which
are only used internally by hypervisor drivers. Following the principle
that libvirt.c should only contain functions exported in the API, and
internal.h should not define any function signatures, these helpers
need to move.

So I'm inventing a domain_events.c, and domain_events.h file to contain
the domain events helper code, in much same way as domain_conf.c and
domain_conf.h contain the domain XML helper code.

Again no functional change here. With this patch applied, the cleanup
of internal.h is basically complete - at least more than good enough
for now. It'd be nice to move the struct definitions of virDomainPtr,
etc elsewhere, perhaps to src/libvirt.h because they're public API,
but not exported publically.

 b/src/domain_event.c  |  229 ++++++++++++++++++++++++++++++++++++++++++++++++++
 b/src/domain_event.h  |   83 ++++++++++++++++++
 qemud/event.c         |    8 -
 qemud/event.h         |    7 +
 src/Makefile.am       |    1 
 src/internal.h        |   73 ---------------
 src/libvirt.c         |  201 -------------------------------------------
 src/qemu_conf.h       |    1 
 src/remote_internal.c |    1 
 9 files changed, 326 insertions(+), 278 deletions(-)

Daniel

diff -r 0325a25d1762 qemud/event.c
--- a/qemud/event.c	Wed Oct 29 11:48:08 2008 +0000
+++ b/qemud/event.c	Wed Oct 29 12:03:29 2008 +0000
@@ -489,7 +489,7 @@
 }
 
 int
-__virEventHandleTypeToPollEvent(virEventHandleType events)
+virEventHandleTypeToPollEvent(int events)
 {
     int ret = 0;
     if(events & VIR_EVENT_HANDLE_READABLE)
@@ -503,10 +503,10 @@
     return ret;
 }
 
-virEventHandleType
-__virPollEventToEventHandleType(int events)
+int
+virPollEventToEventHandleType(int events)
 {
-    virEventHandleType ret = 0;
+    int ret = 0;
     if(events & POLLIN)
         ret |= VIR_EVENT_HANDLE_READABLE;
     if(events & POLLOUT)
diff -r 0325a25d1762 qemud/event.h
--- a/qemud/event.h	Wed Oct 29 11:48:08 2008 +0000
+++ b/qemud/event.h	Wed Oct 29 12:03:29 2008 +0000
@@ -105,4 +105,11 @@
  */
 int virEventRunOnce(void);
 
+int
+virEventHandleTypeToPollEvent(int events);
+int
+virPollEventToEventHandleType(int events);
+
+
+
 #endif /* __VIRTD_EVENT_H__ */
diff -r 0325a25d1762 src/Makefile.am
--- a/src/Makefile.am	Wed Oct 29 11:48:08 2008 +0000
+++ b/src/Makefile.am	Wed Oct 29 12:03:29 2008 +0000
@@ -150,6 +150,7 @@
 		hash.c hash.h					\
 		internal.h					\
 		libvirt.c					\
+		domain_event.c domain_event.h 			\
 		$(GENERIC_LIB_SOURCES)				\
 		$(DOMAIN_CONF_SOURCES)				\
 		$(NETWORK_CONF_SOURCES)				\
diff -r 0325a25d1762 src/domain_event.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/domain_event.c	Wed Oct 29 12:03:29 2008 +0000
@@ -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 "libvirt.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;
+}
+
diff -r 0325a25d1762 src/domain_event.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/domain_event.h	Wed Oct 29 12:03:29 2008 +0000
@@ -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
diff -r 0325a25d1762 src/internal.h
--- a/src/internal.h	Wed Oct 29 11:48:08 2008 +0000
+++ b/src/internal.h	Wed Oct 29 12:03:29 2008 +0000
@@ -294,77 +294,4 @@
     char key[PATH_MAX];                  /* unique key for storage vol */
 };
 
-
-/**
- * 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__ */
diff -r 0325a25d1762 src/libvirt.c
--- a/src/libvirt.c	Wed Oct 29 11:48:08 2008 +0000
+++ b/src/libvirt.c	Wed Oct 29 12:03:29 2008 +0000
@@ -5371,207 +5371,6 @@
     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;
-}
-
-
 
 /************************************************************************
  *									*
diff -r 0325a25d1762 src/qemu_conf.h
--- a/src/qemu_conf.h	Wed Oct 29 11:48:08 2008 +0000
+++ b/src/qemu_conf.h	Wed Oct 29 12:03:29 2008 +0000
@@ -31,6 +31,7 @@
 #include "capabilities.h"
 #include "network_conf.h"
 #include "domain_conf.h"
+#include "domain_event.h"
 
 #define qemudDebug(fmt, ...) do {} while(0)
 
diff -r 0325a25d1762 src/remote_internal.c
--- a/src/remote_internal.c	Wed Oct 29 11:48:08 2008 +0000
+++ b/src/remote_internal.c	Wed Oct 29 12:03:29 2008 +0000
@@ -75,6 +75,7 @@
 
 #include "virterror.h"
 #include "libvirt.h"
+#include "domain_event.h"
 #include "driver.h"
 #include "buf.h"
 #include "qparams.h"


-- 
|: Red Hat, Engineering, London   -o-   http://people.redhat.com/berrange/ :|
|: http://libvirt.org  -o-  http://virt-manager.org  -o-  http://ovirt.org :|
|: http://autobuild.org       -o-         http://search.cpan.org/~danberr/ :|
|: GnuPG: 7D3B9505  -o-  F3C9 553F A1DA 4AC2 5648 23C1 B3DF F742 7D3B 9505 :|


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]