From patchwork Tue Aug 7 11:17:20 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Paolo Bonzini X-Patchwork-Id: 175607 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 400402C007C for ; Tue, 7 Aug 2012 21:58:08 +1000 (EST) Received: from localhost ([::1]:37801 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SyhoA-0003Ut-O3 for incoming@patchwork.ozlabs.org; Tue, 07 Aug 2012 07:18:42 -0400 Received: from eggs.gnu.org ([208.118.235.92]:56374) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SyhnY-0001kZ-Ft for qemu-devel@nongnu.org; Tue, 07 Aug 2012 07:18:05 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1SyhnX-0006d6-2G for qemu-devel@nongnu.org; Tue, 07 Aug 2012 07:18:04 -0400 Received: from mail-pb0-f45.google.com ([209.85.160.45]:37528) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1SyhnW-0006Zk-SL for qemu-devel@nongnu.org; Tue, 07 Aug 2012 07:18:02 -0400 Received: by mail-pb0-f45.google.com with SMTP id ro12so6760377pbb.4 for ; Tue, 07 Aug 2012 04:18:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references; bh=utSD2qvJyXwhbS5+hjrBdxeSiqLWFIaf+vQ39RtD/H4=; b=xv8LJlQqqhMi/oVfXg46RIJZ+btSrZQjJuU4TCThYplgaYS9QHn+HVg7ltTlyn23Mf t/Vua84yoZvnyEd2ASv9zeh4qQsOBsHCsGkSCJAcrgBPkI92iBv643qaADs258L92tzW Oynez6Mp4CJpwV9KE8e5cMbLNQeTcBSWrZAJWZx7QJlHcC8Y2nPb2zwqAtDUgw+NmEC0 AAQErfOMYMNmT4Hl1oqW7ezPAXrMJCYLIbd4JJib6KZ1LHdCoe4s61tiiK0fOVZyJAA2 awJXG4Jdl69slzZ99mZV6kojbuzWcY2Kb9BhTeRHH45E31BaIu+nmHDQ36j0ku57G3y5 TIDw== Received: by 10.66.89.234 with SMTP id br10mr25386813pab.25.1344338282387; Tue, 07 Aug 2012 04:18:02 -0700 (PDT) Received: from yakj.usersys.redhat.com (93-34-169-1.ip50.fastwebnet.it. [93.34.169.1]) by mx.google.com with ESMTPS id pq1sm11008602pbb.3.2012.08.07.04.17.58 (version=TLSv1/SSLv3 cipher=OTHER); Tue, 07 Aug 2012 04:18:00 -0700 (PDT) From: Paolo Bonzini To: qemu-devel@nongnu.org Date: Tue, 7 Aug 2012 13:17:20 +0200 Message-Id: <1344338247-17567-6-git-send-email-pbonzini@redhat.com> X-Mailer: git-send-email 1.7.11.2 In-Reply-To: <1344338247-17567-1-git-send-email-pbonzini@redhat.com> References: <1344338247-17567-1-git-send-email-pbonzini@redhat.com> X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 209.85.160.45 Cc: aliguori@linux.vnet.ibm.com, stefanha@linux.vnet.ibm.com, sw@weilnetz.de Subject: [Qemu-devel] [PATCH v2 05/12] aio: add Win32 implementation X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org The Win32 implementation only accepts EventNotifiers, thus a few drivers are disabled under Windows. Signed-off-by: Paolo Bonzini --- Makefile.objs | 6 +- aio.c => aio-posix.c | 0 aio-win32.c | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++ block/Makefile.objs | 6 +- 4 file modificati, 185 inserzioni(+), 4 rimozioni(-) rename aio.c => aio-posix.c (100%) create mode 100644 aio-win32.c diff --git a/Makefile.objs b/Makefile.objs index e6d40da..b24972d 100644 --- a/Makefile.objs +++ b/Makefile.objs @@ -42,11 +42,11 @@ coroutine-obj-$(CONFIG_WIN32) += coroutine-win32.o # block-obj-y is code used by both qemu system emulation and qemu-img block-obj-y = cutils.o iov.o cache-utils.o qemu-option.o module.o async.o -block-obj-y += nbd.o block.o aio.o aes.o qemu-config.o qemu-progress.o qemu-sockets.o +block-obj-y += nbd.o block.o aes.o qemu-config.o qemu-progress.o qemu-sockets.o block-obj-y += $(coroutine-obj-y) $(qobject-obj-y) $(version-obj-y) block-obj-$(CONFIG_POSIX) += posix-aio-compat.o -block-obj-$(CONFIG_POSIX) += event_notifier-posix.o -block-obj-$(CONFIG_WIN32) += event_notifier-win32.o +block-obj-$(CONFIG_POSIX) += event_notifier-posix.o aio-posix.o +block-obj-$(CONFIG_WIN32) += event_notifier-win32.o aio-win32.o block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o block-obj-y += block/ diff --git a/aio.c b/aio-posix.c similarity index 100% rename from aio.c rename to aio-posix.c diff --git a/aio-win32.c b/aio-win32.c new file mode 100644 index 0000000..0936f7f --- /dev/null +++ b/aio-win32.c @@ -0,0 +1,176 @@ +/* + * QEMU aio implementation + * + * Copyright IBM Corp., 2008 + * Copyright Red Hat Inc., 2012 + * + * Authors: + * Anthony Liguori + * Paolo Bonzini + * + * This work is licensed under the terms of the GNU GPL, version 2. See + * the COPYING file in the top-level directory. + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +#include "qemu-common.h" +#include "block.h" +#include "qemu-queue.h" +#include "qemu_socket.h" + +typedef struct AioHandler AioHandler; + +/* The list of registered 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 + * dispatching callbacks. + */ +static int walking_handlers; + +struct AioHandler { + EventNotifier *e; + EventNotifierHandler *io_notify; + AioFlushEventNotifierHandler *io_flush; + int deleted; + QLIST_ENTRY(AioHandler) node; +}; + +void qemu_aio_set_event_notifier(EventNotifier *e, + EventNotifierHandler *io_notify, + AioFlushEventNotifierHandler *io_flush) +{ + AioHandler *node; + + QLIST_FOREACH(node, &aio_handlers, node) { + if (node->e == e && !node->deleted) { + break; + } + } + + /* Are we deleting the fd handler? */ + if (!io_notify) { + if (node) { + qemu_del_wait_object(event_notifier_get_handle(e), + (WaitObjectFunc *) node->io_notify, e); + + /* If the lock is held, just mark the node as deleted */ + if (walking_handlers) { + node->deleted = 1; + } else { + /* Otherwise, delete it for real. We can't just mark it as + * deleted because deleted nodes are only cleaned up after + * releasing the walking_handlers lock. + */ + QLIST_REMOVE(node, node); + g_free(node); + } + } + } else { + if (node == NULL) { + /* Alloc and insert if it's not already there */ + node = g_malloc0(sizeof(AioHandler)); + node->e = e; + QLIST_INSERT_HEAD(&aio_handlers, node, node); + } + /* Update handler with latest information */ + node->io_notify = io_notify; + node->io_flush = io_flush; + qemu_add_wait_object(event_notifier_get_handle(e), + (WaitObjectFunc *) io_notify, e); + } +} + +void qemu_aio_flush(void) +{ + while (qemu_aio_wait()); +} + +bool qemu_aio_wait(void) +{ + AioHandler *node; + HANDLE events[MAXIMUM_WAIT_OBJECTS + 1]; + bool busy; + int count; + int ret; + int timeout; + + /* + * If there are callbacks left that have been queued, we need to call then. + * Do not call select in this case, because it is possible that the caller + * does not need a complete flush (as is the case for qemu_aio_wait loops). + */ + if (qemu_bh_poll()) { + return true; + } + + walking_handlers = 1; + + /* fill fd sets */ + busy = false; + count = 0; + 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. + */ + if (node->io_flush) { + if (node->io_flush(node->e) == 0) { + continue; + } + busy = true; + } + if (!node->deleted && node->io_notify) { + events[count++] = event_notifier_get_handle(node->e); + } + } + + walking_handlers = 0; + + /* No AIO operations? Get us out of here */ + if (!busy) { + return false; + } + + /* wait until next event */ + timeout = INFINITE; + for (;;) { + ret = WaitForMultipleObjects(count, events, FALSE, timeout); + if ((DWORD) (ret - WAIT_OBJECT_0) >= count) { + break; + } + + timeout = 0; + + /* if we have any signaled events, dispatch event */ + walking_handlers = 1; + + /* we have to walk very carefully in case + * qemu_aio_set_fd_handler is called while we're walking */ + node = QLIST_FIRST(&aio_handlers); + while (node) { + AioHandler *tmp; + + if (!node->deleted && + event_notifier_get_handle(node->e) == events[ret - WAIT_OBJECT_0] && + node->io_notify) { + node->io_notify(node->e); + } + + tmp = node; + node = QLIST_NEXT(node, node); + + if (tmp->deleted) { + QLIST_REMOVE(tmp, node); + g_free(tmp); + } + } + + walking_handlers = 0; + } + + return true; +} diff --git a/block/Makefile.objs b/block/Makefile.objs index b5754d3..65d4dc6 100644 --- a/block/Makefile.objs +++ b/block/Makefile.objs @@ -2,10 +2,14 @@ block-obj-y += raw.o cow.o qcow.o vdi.o vmdk.o cloop.o dmg.o bochs.o vpc.o vvfat block-obj-y += qcow2.o qcow2-refcount.o qcow2-cluster.o qcow2-snapshot.o qcow2-cache.o block-obj-y += qed.o qed-gencb.o qed-l2-cache.o qed-table.o qed-cluster.o block-obj-y += qed-check.o -block-obj-y += parallels.o nbd.o blkdebug.o sheepdog.o blkverify.o +block-obj-y += parallels.o blkdebug.o blkverify.o block-obj-y += stream.o block-obj-$(CONFIG_WIN32) += raw-win32.o block-obj-$(CONFIG_POSIX) += raw-posix.o + +ifeq ($(CONFIG_POSIX),y) +block-obj-y += nbd.o sheepdog.o block-obj-$(CONFIG_LIBISCSI) += iscsi.o block-obj-$(CONFIG_CURL) += curl.o block-obj-$(CONFIG_RBD) += rbd.o +endif