From patchwork Thu Nov 6 15:09:59 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ming Lei X-Patchwork-Id: 407576 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 018811400A6 for ; Fri, 7 Nov 2014 02:11:23 +1100 (AEDT) Received: from localhost ([::1]:54208 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XmOiW-00081Y-P1 for incoming@patchwork.ozlabs.org; Thu, 06 Nov 2014 10:11:20 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:51225) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XmOhZ-0006o7-5e for qemu-devel@nongnu.org; Thu, 06 Nov 2014 10:10:28 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1XmOhT-0004JZ-2A for qemu-devel@nongnu.org; Thu, 06 Nov 2014 10:10:21 -0500 Received: from mail-pa0-f42.google.com ([209.85.220.42]:58094) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1XmOhS-0004JP-R5 for qemu-devel@nongnu.org; Thu, 06 Nov 2014 10:10:15 -0500 Received: by mail-pa0-f42.google.com with SMTP id bj1so1440423pad.1 for ; Thu, 06 Nov 2014 07:10:14 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=QshzelZhexwz9pCi+z2SVZlDsH/DqHPYw1MsiPZCF5M=; b=ZSBjb78uemaSXDzDq5vbAcDFmia/FjrxbzA/1BBcJRkMRFF+3t76E0x+99URqOHKCq Zkcn1VSIHiz6ulhzIELMcEvxQdp4o2Cx9iff8JnBU9fcHJQWHZpXC/2pIev/l/rJ1ckz dCf/AGS7OsE1NcthTtZ3910KIzrzILZaAWUEbPjM3nKVjc5HwVRQ67D4Z6QZCzCe5wfL iiR8+rC2iAmxb885lc+BU09lbFs/QLM19mjun6IrajRjTDVMZBhkjewn140GfpzVMvR3 3hkHd+rURJXEqhJPJ6pEeVX//UQaSePX5xdJD37o4IAGo7edUdpWwvVu4Gcu6Pt7AysO g1vw== X-Received: by 10.70.109.169 with SMTP id ht9mr4949662pdb.152.1415286614267; Thu, 06 Nov 2014 07:10:14 -0800 (PST) Received: from localhost ([183.13.123.177]) by mx.google.com with ESMTPSA id rb2sm6274294pab.5.2014.11.06.07.10.12 for (version=TLSv1.2 cipher=RC4-SHA bits=128/128); Thu, 06 Nov 2014 07:10:13 -0800 (PST) From: Ming Lei To: qemu-devel@nongnu.org, Peter Maydell , Paolo Bonzini , Stefan Hajnoczi , Kevin Wolf Date: Thu, 6 Nov 2014 23:09:59 +0800 Message-Id: <1415286601-30715-2-git-send-email-ming.lei@canonical.com> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1415286601-30715-1-git-send-email-ming.lei@canonical.com> References: <1415286601-30715-1-git-send-email-ming.lei@canonical.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x [generic] [fuzzy] X-Received-From: 209.85.220.42 Cc: =?UTF-8?q?Beno=C3=AEt=20Canet?= , Ming Lei Subject: [Qemu-devel] [PATCH v3 1/3] linux-aio: fix submit aio as a batch 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 In the enqueue path, we can't complete request, otherwise "Co-routine re-entered recursively" may be caused, so this patch fixes the issue with below ideas: - for -EAGAIN or partial completion, retry the submision by schedule an BH in following completion cb - for part of completion, also update the io queue - for other failure, return the failure if in enqueue path, otherwise, abort all queued I/O Signed-off-by: Ming Lei --- block/linux-aio.c | 101 +++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 79 insertions(+), 22 deletions(-) diff --git a/block/linux-aio.c b/block/linux-aio.c index d92513b..f66e8ad 100644 --- a/block/linux-aio.c +++ b/block/linux-aio.c @@ -38,11 +38,19 @@ struct qemu_laiocb { QLIST_ENTRY(qemu_laiocb) node; }; +/* + * TODO: support to batch I/O from multiple bs in one same + * AIO context, one important use case is multi-lun scsi, + * so in future the IO queue should be per AIO context. + */ typedef struct { struct iocb *iocbs[MAX_QUEUED_IO]; int plugged; unsigned int size; unsigned int idx; + + /* handle -EAGAIN and partial completion */ + QEMUBH *retry; } LaioQueue; struct qemu_laio_state { @@ -137,6 +145,12 @@ static void qemu_laio_completion_bh(void *opaque) } } +static void qemu_laio_start_retry(struct qemu_laio_state *s) +{ + if (s->io_q.idx) + qemu_bh_schedule(s->io_q.retry); +} + static void qemu_laio_completion_cb(EventNotifier *e) { struct qemu_laio_state *s = container_of(e, struct qemu_laio_state, e); @@ -144,6 +158,7 @@ static void qemu_laio_completion_cb(EventNotifier *e) if (event_notifier_test_and_clear(&s->e)) { qemu_bh_schedule(s->completion_bh); } + qemu_laio_start_retry(s); } static void laio_cancel(BlockAIOCB *blockacb) @@ -163,6 +178,9 @@ static void laio_cancel(BlockAIOCB *blockacb) } laiocb->common.cb(laiocb->common.opaque, laiocb->ret); + + /* check if there are requests in io queue */ + qemu_laio_start_retry(laiocb->ctx); } static const AIOCBInfo laio_aiocb_info = { @@ -177,45 +195,80 @@ static void ioq_init(LaioQueue *io_q) io_q->plugged = 0; } -static int ioq_submit(struct qemu_laio_state *s) +static void abort_queue(struct qemu_laio_state *s) +{ + int i; + for (i = 0; i < s->io_q.idx; i++) { + struct qemu_laiocb *laiocb = container_of(s->io_q.iocbs[i], + struct qemu_laiocb, + iocb); + laiocb->ret = -EIO; + qemu_laio_process_completion(s, laiocb); + } +} + +static int ioq_submit(struct qemu_laio_state *s, bool enqueue) { int ret, i = 0; int len = s->io_q.idx; + int j = 0; - do { - ret = io_submit(s->ctx, len, s->io_q.iocbs); - } while (i++ < 3 && ret == -EAGAIN); + if (!len) { + return 0; + } - /* empty io queue */ - s->io_q.idx = 0; + ret = io_submit(s->ctx, len, s->io_q.iocbs); + if (ret == -EAGAIN) { /* retry in following completion cb */ + return 0; + } else if (ret < 0) { + if (enqueue) { + return ret; + } - if (ret < 0) { - i = 0; - } else { - i = ret; + /* in non-queue path, all IOs have to be completed */ + abort_queue(s); + ret = len; + } else if (ret == 0) { + goto out; } - for (; i < len; i++) { - struct qemu_laiocb *laiocb = - container_of(s->io_q.iocbs[i], struct qemu_laiocb, iocb); - - laiocb->ret = (ret < 0) ? ret : -EIO; - qemu_laio_process_completion(s, laiocb); + for (i = ret; i < len; i++) { + s->io_q.iocbs[j++] = s->io_q.iocbs[i]; } + + out: + /* + * update io queue, for partial completion, retry will be + * started automatically in following completion cb. + */ + s->io_q.idx -= ret; + return ret; } -static void ioq_enqueue(struct qemu_laio_state *s, struct iocb *iocb) +static void ioq_submit_retry(void *opaque) +{ + struct qemu_laio_state *s = opaque; + ioq_submit(s, false); +} + +static int ioq_enqueue(struct qemu_laio_state *s, struct iocb *iocb) { unsigned int idx = s->io_q.idx; + if (unlikely(idx == s->io_q.size)) { + return -1; + } + s->io_q.iocbs[idx++] = iocb; s->io_q.idx = idx; - /* submit immediately if queue is full */ - if (idx == s->io_q.size) { - ioq_submit(s); + /* submit immediately if queue depth is above 2/3 */ + if (idx > s->io_q.size * 2 / 3) { + return ioq_submit(s, true); } + + return 0; } void laio_io_plug(BlockDriverState *bs, void *aio_ctx) @@ -237,7 +290,7 @@ int laio_io_unplug(BlockDriverState *bs, void *aio_ctx, bool unplug) } if (s->io_q.idx > 0) { - ret = ioq_submit(s); + ret = ioq_submit(s, false); } return ret; @@ -281,7 +334,9 @@ BlockAIOCB *laio_submit(BlockDriverState *bs, void *aio_ctx, int fd, goto out_free_aiocb; } } else { - ioq_enqueue(s, iocbs); + if (ioq_enqueue(s, iocbs) < 0) { + goto out_free_aiocb; + } } return &laiocb->common; @@ -296,12 +351,14 @@ void laio_detach_aio_context(void *s_, AioContext *old_context) aio_set_event_notifier(old_context, &s->e, NULL); qemu_bh_delete(s->completion_bh); + qemu_bh_delete(s->io_q.retry); } void laio_attach_aio_context(void *s_, AioContext *new_context) { struct qemu_laio_state *s = s_; + s->io_q.retry = aio_bh_new(new_context, ioq_submit_retry, s); s->completion_bh = aio_bh_new(new_context, qemu_laio_completion_bh, s); aio_set_event_notifier(new_context, &s->e, qemu_laio_completion_cb); }