Add #defines needed by OpenSolaris, fix breakage by the #defines

[qemu] / aio.c

diff --git a/aio.c b/aio.c
index 70d3cdc..da18443 100644 (file)
--- a/aio.c
+++ b/aio.c
@@ -13,13 +13,13 @@
 
 #include "qemu-common.h"
 #include "block.h"
-#include "sys-queue.h"
+#include "qemu-queue.h"
 #include "qemu_socket.h"
 
 typedef struct AioHandler AioHandler;
 
 /* The list of registered AIO handlers */
-static LIST_HEAD(, AioHandler) aio_handlers;
+static QLIST_HEAD(, AioHandler) aio_handlers;
 
 /* This is a simple lock used to protect the aio_handlers list.  Specifically,
  * it's used to ensure that no callbacks are removed while we're walking and
@@ -35,16 +35,17 @@ struct AioHandler
     AioFlushHandler *io_flush;
     int deleted;
     void *opaque;
-    LIST_ENTRY(AioHandler) node;
+    QLIST_ENTRY(AioHandler) node;
 };
 
 static AioHandler *find_aio_handler(int fd)
 {
     AioHandler *node;
 
-    LIST_FOREACH(node, &aio_handlers, node) {
+    QLIST_FOREACH(node, &aio_handlers, node) {
         if (node->fd == fd)
-            return node;
+            if (!node->deleted)
+                return node;
     }
 
     return NULL;
@@ -71,7 +72,7 @@ int qemu_aio_set_fd_handler(int fd,
                  * deleted because deleted nodes are only cleaned up after
                  * releasing the walking_handlers lock.
                  */
-                LIST_REMOVE(node, node);
+                QLIST_REMOVE(node, node);
                 qemu_free(node);
             }
         }
@@ -79,10 +80,8 @@ int qemu_aio_set_fd_handler(int fd,
         if (node == NULL) {
             /* Alloc and insert if it's not already there */
             node = qemu_mallocz(sizeof(AioHandler));
-            if (node == NULL)
-                return -ENOMEM;
             node->fd = fd;
-            LIST_INSERT_HEAD(&aio_handlers, node, node);
+            QLIST_INSERT_HEAD(&aio_handlers, node, node);
         }
         /* Update handler with latest information */
         node->io_read = io_read;
@@ -104,12 +103,16 @@ void qemu_aio_flush(void)
     do {
         ret = 0;
 
-        LIST_FOREACH(node, &aio_handlers, node) {
+       /*
+        * If there are pending emulated aio start them now so flush
+        * will be able to return 1.
+        */
+        qemu_aio_wait();
+
+        QLIST_FOREACH(node, &aio_handlers, node) {
             ret |= node->io_flush(node->opaque);
         }
-
-        qemu_aio_wait();
-    } while (ret > 0);
+    } while (qemu_bh_poll() || ret > 0);
 }
 
 void qemu_aio_wait(void)
@@ -130,7 +133,7 @@ void qemu_aio_wait(void)
         FD_ZERO(&wrfds);
 
         /* fill fd sets */
-        LIST_FOREACH(node, &aio_handlers, node) {
+        QLIST_FOREACH(node, &aio_handlers, node) {
             /* If there aren't pending AIO operations, don't invoke callbacks.
              * Otherwise, if there are no AIO requests, qemu_aio_wait() would
              * wait indefinitely.
@@ -165,7 +168,7 @@ void qemu_aio_wait(void)
 
             /* we have to walk very carefully in case
              * qemu_aio_set_fd_handler is called while we're walking */
-            node = LIST_FIRST(&aio_handlers);
+            node = QLIST_FIRST(&aio_handlers);
             while (node) {
                 AioHandler *tmp;
 
@@ -181,10 +184,10 @@ void qemu_aio_wait(void)
                 }
 
                 tmp = node;
-                node = LIST_NEXT(node, node);
+                node = QLIST_NEXT(node, node);
 
                 if (tmp->deleted) {
-                    LIST_REMOVE(tmp, node);
+                    QLIST_REMOVE(tmp, node);
                     qemu_free(tmp);
                 }
             }