All of lore.kernel.org
 help / color / mirror / Atom feed
* [Qemu-devel] [PATCH v6 00/14] Add support for io_uring
@ 2019-07-19 13:35 Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 01/14] configure: permit use of io_uring Aarushi Mehta
                   ` (15 more replies)
  0 siblings, 16 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

This patch series adds support for the newly developed io_uring Linux AIO
interface. Linux io_uring is faster than Linux's AIO asynchronous I/O code,
offers efficient buffered asynchronous I/O support, the ability to do I/O
without performing a system call via polled I/O, and other efficiency enhancements.

Testing it requires a host kernel (5.1+) and the liburing library.
Use the option -drive aio=io_uring to enable it.

Benchmarks for the system at https://github.com/rooshm/benchmarks
io_uring has similar performance as libaio but supports cache=writeback.
Further performance enhancement will be implemented

There is currently an -EIO output when guests are booted from io_uring
disks for the second time with clean shutdowns that is being investigated.

v6:
- add slow path for short-read
- hooks up fsync
- enables qemu-iotests with aio options
- adds bdrv_parse_aio

v5:
- Adds completion polling
- Extends qemu-io
- Adds qemu-iotest

v4:
- Add error handling
- Add trace events
- Remove aio submission based code

Aarushi Mehta (14):
  configure: permit use of io_uring
  qapi/block-core: add option for io_uring
  block/block: add BDRV flag for io_uring
  block/io_uring: implements interfaces for io_uring
  stubs: add stubs for io_uring interface
  util/async: add aio interfaces for io_uring
  blockdev: accept io_uring as option
  block/file-posix.c: extend to use io_uring
  block: add trace events for io_uring
  block/io_uring: adds userspace completion polling
  qemu-io: adds option to use aio engine
  qemu-img: adds option to use aio engine
  qemu-nbd: adds option for aio engines
  tests/qemu-iotest: enable testing with qemu-io aio options

 MAINTAINERS                  |   8 +
 block.c                      |  22 ++
 block/Makefile.objs          |   3 +
 block/file-posix.c           |  99 ++++++--
 block/io_uring.c             | 439 +++++++++++++++++++++++++++++++++++
 block/trace-events           |  12 +
 blockdev.c                   |  12 +-
 configure                    |  27 +++
 include/block/aio.h          |  16 +-
 include/block/block.h        |   2 +
 include/block/raw-aio.h      |  12 +
 qapi/block-core.json         |   4 +-
 qemu-img.c                   |  11 +-
 qemu-io.c                    |  25 +-
 qemu-nbd.c                   |  12 +-
 stubs/Makefile.objs          |   1 +
 stubs/io_uring.c             |  32 +++
 tests/qemu-iotests/check     |  14 +-
 tests/qemu-iotests/common.rc |  10 +
 util/async.c                 |  36 +++
 20 files changed, 746 insertions(+), 51 deletions(-)
 create mode 100644 block/io_uring.c
 create mode 100644 stubs/io_uring.c

-- 
2.21.0



^ permalink raw reply	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 01/14] configure: permit use of io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring Aarushi Mehta
                   ` (14 subsequent siblings)
  15 siblings, 0 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta, Maxim Levitsky

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
---
 configure | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/configure b/configure
index eb635c3b9a..b0e2e2158e 100755
--- a/configure
+++ b/configure
@@ -370,6 +370,7 @@ xen=""
 xen_ctrl_version=""
 xen_pci_passthrough=""
 linux_aio=""
+linux_io_uring=""
 cap_ng=""
 attr=""
 libattr=""
@@ -1271,6 +1272,10 @@ for opt do
   ;;
   --enable-linux-aio) linux_aio="yes"
   ;;
+  --disable-linux-io-uring) linux_io_uring="no"
+  ;;
+  --enable-linux-io-uring) linux_io_uring="yes"
+  ;;
   --disable-attr) attr="no"
   ;;
   --enable-attr) attr="yes"
@@ -1789,6 +1794,7 @@ disabled with --disable-FEATURE, default is enabled if available:
   vde             support for vde network
   netmap          support for netmap network
   linux-aio       Linux AIO support
+  linux-io-uring  Linux io_uring support
   cap-ng          libcap-ng support
   attr            attr and xattr support
   vhost-net       vhost-net kernel acceleration support
@@ -3969,6 +3975,21 @@ EOF
     linux_aio=no
   fi
 fi
+##########################################
+# linux-io-uring probe
+
+if test "$linux_io_uring" != "no" ; then
+  if $pkg_config liburing; then
+    linux_io_uring_cflags=$($pkg_config --cflags liburing)
+    linux_io_uring_libs=$($pkg_config --libs liburing)
+    linux_io_uring=yes
+  else
+    if test "$linux_io_uring" = "yes" ; then
+      feature_not_found "linux io_uring" "Install liburing devel"
+    fi
+    linux_io_uring=no
+  fi
+fi
 
 ##########################################
 # TPM emulation is only on POSIX
@@ -6392,6 +6413,7 @@ echo "PIE               $pie"
 echo "vde support       $vde"
 echo "netmap support    $netmap"
 echo "Linux AIO support $linux_aio"
+echo "Linux io_uring support $linux_io_uring"
 echo "ATTR/XATTR support $attr"
 echo "Install blobs     $blobs"
 echo "KVM support       $kvm"
@@ -6878,6 +6900,11 @@ fi
 if test "$linux_aio" = "yes" ; then
   echo "CONFIG_LINUX_AIO=y" >> $config_host_mak
 fi
+if test "$linux_io_uring" = "yes" ; then
+  echo "CONFIG_LINUX_IO_URING=y" >> $config_host_mak
+  echo "LINUX_IO_URING_CFLAGS=$linux_io_uring_cflags" >> $config_host_mak
+  echo "LINUX_IO_URING_LIBS=$linux_io_uring_libs" >> $config_host_mak
+fi
 if test "$attr" = "yes" ; then
   echo "CONFIG_ATTR=y" >> $config_host_mak
 fi
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 01/14] configure: permit use of io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:20   ` Stefan Hajnoczi
  2019-07-19 15:49   ` Eric Blake
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 03/14] block/block: add BDRV flag " Aarushi Mehta
                   ` (13 subsequent siblings)
  15 siblings, 2 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Only enumerates option for devices that support it

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-core.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index 0d43d4f37c..0a3d4ae7d2 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -2792,11 +2792,13 @@
 #
 # @threads:     Use qemu's thread pool
 # @native:      Use native AIO backend (only Linux and Windows)
+# @io_uring:    Use linux io_uring (since 4.1)
 #
 # Since: 2.9
 ##
 { 'enum': 'BlockdevAioOptions',
-  'data': [ 'threads', 'native' ] }
+  'data': [ 'threads', 'native',
+            { 'name': 'io_uring', 'if': 'defined(CONFIG_LINUX_IO_URING)' } ] }
 
 ##
 # @BlockdevCacheOptions:
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 03/14] block/block: add BDRV flag for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 01/14] configure: permit use of io_uring Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces " Aarushi Mehta
                   ` (12 subsequent siblings)
  15 siblings, 0 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta, Maxim Levitsky

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
---
 include/block/block.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/block/block.h b/include/block/block.h
index 734c9d2f76..40bd93cd0f 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -121,6 +121,7 @@ typedef struct HDGeometry {
                                       ignoring the format layer */
 #define BDRV_O_NO_IO       0x10000 /* don't initialize for I/O */
 #define BDRV_O_AUTO_RDONLY 0x20000 /* degrade to read-only if opening read-write fails */
+#define BDRV_O_IO_URING    0x40000 /* use io_uring instead of the thread pool */
 
 #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
 
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (2 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 03/14] block/block: add BDRV flag " Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:34   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 05/14] stubs: add stubs for io_uring interface Aarushi Mehta
                   ` (11 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Aborts when sqe fails to be set as sqes cannot be returned to the
ring. Adds slow path for short reads for older kernels

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS             |   7 +
 block.c                 |  22 +++
 block/Makefile.objs     |   3 +
 block/io_uring.c        | 408 ++++++++++++++++++++++++++++++++++++++++
 include/block/aio.h     |  16 +-
 include/block/block.h   |   1 +
 include/block/raw-aio.h |  12 ++
 7 files changed, 468 insertions(+), 1 deletion(-)
 create mode 100644 block/io_uring.c

diff --git a/MAINTAINERS b/MAINTAINERS
index cc9636b43a..651f417f4b 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2531,6 +2531,13 @@ F: block/file-posix.c
 F: block/file-win32.c
 F: block/win32-aio.c
 
+Linux io_uring
+M: Aarushi Mehta <mehta.aaru20@gmail.com>
+R: Stefan Hajnoczi <stefan@redhat.com>
+L: qemu-block@nongnu.org
+S: Maintained
+F: block/io_uring.c
+
 qcow2
 M: Kevin Wolf <kwolf@redhat.com>
 M: Max Reitz <mreitz@redhat.com>
diff --git a/block.c b/block.c
index 29e931e217..4aa3500ad8 100644
--- a/block.c
+++ b/block.c
@@ -844,6 +844,28 @@ static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
     return detect_zeroes;
 }
 
+/**
+ * Set flags for aio engine
+ *
+ * Return 0 on success, -1 if the engine specifies is invalid
+ */
+int bdrv_parse_aio(const char *mode, int *flags)
+{
+    if (!strcmp(mode, "threads")) {
+        /* do nothing, default */
+    } else if (!strcmp(mode, "native")) {
+        *flags |= BDRV_O_NATIVE_AIO;
+#ifdef CONFIG_LINUX_IO_URING
+    } else if (!strcmp(mode, "io_uring")) {
+        *flags |= BDRV_O_IO_URING;
+#endif
+    } else {
+        return -1;
+    }
+
+    return 0;
+}
+
 /**
  * Set open flags for a given discard mode
  *
diff --git a/block/Makefile.objs b/block/Makefile.objs
index 35f3bca4d9..6a548af8ed 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -18,6 +18,7 @@ block-obj-y += block-backend.o snapshot.o qapi.o
 block-obj-$(CONFIG_WIN32) += file-win32.o win32-aio.o
 block-obj-$(CONFIG_POSIX) += file-posix.o
 block-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
+block-obj-$(CONFIG_LINUX_IO_URING) += io_uring.o
 block-obj-y += null.o mirror.o commit.o io.o create.o
 block-obj-y += throttle-groups.o
 block-obj-$(CONFIG_LINUX) += nvme.o
@@ -61,5 +62,7 @@ block-obj-$(if $(CONFIG_LZFSE),m,n) += dmg-lzfse.o
 dmg-lzfse.o-libs   := $(LZFSE_LIBS)
 qcow.o-libs        := -lz
 linux-aio.o-libs   := -laio
+io_uring.o-cflags  := $(LINUX_IO_URING_CFLAGS)
+io_uring.o-libs    := $(LINUX_IO_URING_LIBS)
 parallels.o-cflags := $(LIBXML2_CFLAGS)
 parallels.o-libs   := $(LIBXML2_LIBS)
diff --git a/block/io_uring.c b/block/io_uring.c
new file mode 100644
index 0000000000..e8dbc388a6
--- /dev/null
+++ b/block/io_uring.c
@@ -0,0 +1,408 @@
+/*
+ * Linux io_uring support.
+ *
+ * Copyright (C) 2009 IBM, Corp.
+ * Copyright (C) 2009 Red Hat, Inc.
+ * Copyright (C) 2019 Aarushi Mehta
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+#include "qemu/osdep.h"
+#include <liburing.h>
+#include "qemu-common.h"
+#include "block/aio.h"
+#include "qemu/queue.h"
+#include "block/block.h"
+#include "block/raw-aio.h"
+#include "qemu/coroutine.h"
+#include "qapi/error.h"
+
+#define MAX_EVENTS 128
+
+typedef struct LuringAIOCB {
+    Coroutine *co;
+    struct io_uring_sqe sqeq;
+    ssize_t ret;
+    QEMUIOVector *qiov;
+    bool is_read;
+    QSIMPLEQ_ENTRY(LuringAIOCB) next;
+
+    /*
+     * Buffered reads may require resubmission, see
+     * luring_resubmit_short_read().
+     */
+    int total_read;
+    QEMUIOVector resubmit_qiov;
+} LuringAIOCB;
+
+typedef struct LuringQueue {
+    int plugged;
+    unsigned int in_queue;
+    unsigned int in_flight;
+    bool blocked;
+    QSIMPLEQ_HEAD(, LuringAIOCB) sq_overflow;
+} LuringQueue;
+
+typedef struct LuringState {
+    AioContext *aio_context;
+
+    struct io_uring ring;
+
+    /* io queue for submit at batch.  Protected by AioContext lock. */
+    LuringQueue io_q;
+
+    /* I/O completion processing.  Only runs in I/O thread.  */
+    QEMUBH *completion_bh;
+} LuringState;
+
+/**
+ * ioq_submit:
+ * @s: AIO state
+ *
+ * Queues pending sqes and submits them
+ *
+ */
+static int ioq_submit(LuringState *s);
+
+/**
+ * luring_resubmit:
+ *
+ * Resubmit a request by appending it to sq_overflow.  The caller must ensure
+ * that ioq_submit() is called later so that sq_overflow requests are started.
+ */
+static void luring_resubmit(LuringState *s, LuringAIOCB *luringcb)
+{
+    QSIMPLEQ_INSERT_TAIL(&s->io_q.sq_overflow, luringcb, next);
+    s->io_q.in_queue++;
+}
+
+/**
+ * luring_resubmit_short_read:
+ *
+ * Before Linux commit 9d93a3f5a0c ("io_uring: punt short reads to async
+ * context") a buffered I/O request with the start of the file range in the
+ * page cache could result in a short read.  Applications need to resubmit the
+ * remaining read request.
+ *
+ * This is a slow path but recent kernels never take it.
+ */
+static void luring_resubmit_short_read(LuringState *s, LuringAIOCB *luringcb,
+                                       int nread)
+{
+    QEMUIOVector *resubmit_qiov;
+    size_t remaining;
+
+    /* Update read position */
+    luringcb->total_read = nread;
+    remaining = luringcb->qiov->size - luringcb->total_read;
+
+    /* Shorten qiov */
+    resubmit_qiov = &luringcb->resubmit_qiov;
+    if (resubmit_qiov->iov == NULL) {
+        qemu_iovec_init(resubmit_qiov, luringcb->qiov->niov);
+    } else {
+        qemu_iovec_reset(resubmit_qiov);
+    }
+    qemu_iovec_concat(resubmit_qiov, luringcb->qiov, luringcb->total_read,
+                      remaining);
+
+    /* Update sqe */
+    luringcb->sqeq.off = nread;
+    luringcb->sqeq.addr = (__u64)(uintptr_t)luringcb->resubmit_qiov.iov;
+    luringcb->sqeq.len = luringcb->resubmit_qiov.niov;
+
+    luring_resubmit(s, luringcb);
+}
+
+/**
+ * luring_process_completions:
+ * @s: AIO state
+ *
+ * Fetches completed I/O requests, consumes cqes and invokes their callbacks
+ * The function is somewhat tricky because it supports nested event loops, for
+ * example when a request callback invokes aio_poll().  In order to do this,
+ * indices are kept in LuringState.  Function schedules BH completion so it
+ * can be called again in a nested event loop.  When there are no events left
+ * to complete the BH is being canceled.
+ *
+ */
+static void luring_process_completions(LuringState *s)
+{
+    struct io_uring_cqe *cqes;
+    int total_bytes;
+    /*
+     * Request completion callbacks can run the nested event loop.
+     * Schedule ourselves so the nested event loop will "see" remaining
+     * completed requests and process them.  Without this, completion
+     * callbacks that wait for other requests using a nested event loop
+     * would hang forever.
+     *
+     * This workaround is needed because io_uring uses poll_wait, which
+     * is woken up when new events are added to the uring, thus polling on
+     * the same uring fd will block unless more events are received.
+     *
+     * Other leaf block drivers (drivers that access the data themselves)
+     * are networking based, so they poll sockets for data and run the
+     * correct coroutine.
+     */
+    qemu_bh_schedule(s->completion_bh);
+
+    while (io_uring_peek_cqe(&s->ring, &cqes) == 0) {
+        LuringAIOCB *luringcb;
+        int ret;
+
+        if (!cqes) {
+            break;
+        }
+
+        luringcb = io_uring_cqe_get_data(cqes);
+        ret = cqes->res;
+        io_uring_cqe_seen(&s->ring, cqes);
+        cqes = NULL;
+
+        /* Change counters one-by-one because we can be nested. */
+        s->io_q.in_flight--;
+
+        /* total_read is non-zero only for resubmitted read requests */
+        total_bytes = ret + luringcb->total_read;
+
+        if (ret < 0) {
+            if (ret == -EINTR) {
+                luring_resubmit(s, luringcb);
+                continue;
+            }
+        } else if (!luringcb->qiov) {
+            goto end;
+        } else if (total_bytes == luringcb->qiov->size) {
+                ret = 0;
+        /* Only read/write */
+        } else {
+            /* Short Read/Write */
+            if (luringcb->is_read) {
+                if (ret > 0) {
+                    luring_resubmit_short_read(s, luringcb, ret);
+                    continue;
+                } else {
+                    /* Pad with zeroes */
+                    qemu_iovec_memset(luringcb->qiov, total_bytes, 0,
+                                      luringcb->qiov->size - total_bytes);
+                    ret = 0;
+                }
+            } else {
+                ret = -ENOSPC;;
+            }
+        }
+end:
+        luringcb->ret = ret;
+        qemu_iovec_destroy(&luringcb->resubmit_qiov);
+
+        /*
+         * If the coroutine is already entered it must be in ioq_submit()
+         * and will notice luringcb->ret has been filled in when it
+         * eventually runs later. Coroutines cannot be entered recursively
+         * so avoid doing that!
+         */
+        if (!qemu_coroutine_entered(luringcb->co)) {
+            aio_co_wake(luringcb->co);
+        }
+    }
+    qemu_bh_cancel(s->completion_bh);
+}
+
+static void luring_process_completions_and_submit(LuringState *s)
+{
+    aio_context_acquire(s->aio_context);
+    luring_process_completions(s);
+
+    if (!s->io_q.plugged && s->io_q.in_queue > 0) {
+        ioq_submit(s);
+    }
+    aio_context_release(s->aio_context);
+}
+
+static void qemu_luring_completion_bh(void *opaque)
+{
+    LuringState *s = opaque;
+    luring_process_completions_and_submit(s);
+}
+
+static void qemu_luring_completion_cb(void *opaque)
+{
+    LuringState *s = opaque;
+    luring_process_completions_and_submit(s);
+}
+
+static void ioq_init(LuringQueue *io_q)
+{
+    QSIMPLEQ_INIT(&io_q->sq_overflow);
+    io_q->plugged = 0;
+    io_q->in_queue = 0;
+    io_q->in_flight = 0;
+    io_q->blocked = false;
+}
+
+static int ioq_submit(LuringState *s)
+{
+    int ret = 0;
+    LuringAIOCB *luringcb, *luringcb_next;
+
+    while (s->io_q.in_queue > 0) {
+        /*
+         * Try to fetch sqes from the ring for requests waiting in
+         * the overflow queue
+         */
+        QSIMPLEQ_FOREACH_SAFE(luringcb, &s->io_q.sq_overflow, next,
+                              luringcb_next) {
+            struct io_uring_sqe *sqes = io_uring_get_sqe(&s->ring);
+            if (!sqes) {
+                break;
+            }
+            /* Prep sqe for submission */
+            *sqes = luringcb->sqeq;
+            QSIMPLEQ_REMOVE_HEAD(&s->io_q.sq_overflow, next);
+        }
+        ret = io_uring_submit(&s->ring);
+        /* Prevent infinite loop if submission is refused */
+        if (ret <= 0) {
+            if (ret == -EAGAIN) {
+                continue;
+            }
+            break;
+        }
+        s->io_q.in_flight += ret;
+        s->io_q.in_queue  -= ret;
+    }
+    s->io_q.blocked = (s->io_q.in_queue > 0);
+
+    if (s->io_q.in_flight) {
+        /*
+         * We can try to complete something just right away if there are
+         * still requests in-flight.
+         */
+        luring_process_completions(s);
+    }
+    return ret;
+}
+
+void luring_io_plug(BlockDriverState *bs, LuringState *s)
+{
+    s->io_q.plugged++;
+}
+
+void luring_io_unplug(BlockDriverState *bs, LuringState *s)
+{
+    assert(s->io_q.plugged);
+    if (--s->io_q.plugged == 0 &&
+        !s->io_q.blocked && s->io_q.in_queue > 0) {
+        ioq_submit(s);
+    }
+}
+
+/**
+ * luring_do_submit:
+ * @fd: file descriptor for I/O
+ * @luringcb: AIO control block
+ * @s: AIO state
+ * @offset: offset for request
+ * @type: type of request
+ *
+ * Fetches sqes from ring, adds to pending queue and preps them
+ *
+ */
+static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
+                            uint64_t offset, int type)
+{
+    struct io_uring_sqe *sqes = &luringcb->sqeq;
+
+    switch (type) {
+    case QEMU_AIO_WRITE:
+        io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
+                             luringcb->qiov->niov, offset);
+        break;
+    case QEMU_AIO_READ:
+        io_uring_prep_readv(sqes, fd, luringcb->qiov->iov,
+                            luringcb->qiov->niov, offset);
+        break;
+    case QEMU_AIO_FLUSH:
+        io_uring_prep_fsync(sqes, fd, 0);
+        break;
+    default:
+        fprintf(stderr, "%s: invalid AIO request type, aborting 0x%x.\n",
+                        __func__, type);
+        abort();
+    }
+    io_uring_sqe_set_data(sqes, luringcb);
+
+    QSIMPLEQ_INSERT_TAIL(&s->io_q.sq_overflow, luringcb, next);
+    s->io_q.in_queue++;
+
+    if (!s->io_q.blocked &&
+        (!s->io_q.plugged ||
+         s->io_q.in_flight + s->io_q.in_queue >= MAX_EVENTS)) {
+        return ioq_submit(s);
+    }
+    return 0;
+}
+
+int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
+                                uint64_t offset, QEMUIOVector *qiov, int type)
+{
+    int ret;
+    LuringAIOCB luringcb = {
+        .co         = qemu_coroutine_self(),
+        .ret        = -EINPROGRESS,
+        .qiov       = qiov,
+        .is_read    = (type == QEMU_AIO_READ),
+    };
+
+    ret = luring_do_submit(fd, &luringcb, s, offset, type);
+    if (ret < 0) {
+        return ret;
+    }
+
+    if (luringcb.ret == -EINPROGRESS) {
+        qemu_coroutine_yield();
+    }
+    return luringcb.ret;
+}
+
+void luring_detach_aio_context(LuringState *s, AioContext *old_context)
+{
+    aio_set_fd_handler(old_context, s->ring.ring_fd, false, NULL, NULL, NULL,
+                       s);
+    qemu_bh_delete(s->completion_bh);
+    s->aio_context = NULL;
+}
+
+void luring_attach_aio_context(LuringState *s, AioContext *new_context)
+{
+    s->aio_context = new_context;
+    s->completion_bh = aio_bh_new(new_context, qemu_luring_completion_bh, s);
+    aio_set_fd_handler(s->aio_context, s->ring.ring_fd, false,
+                       qemu_luring_completion_cb, NULL, NULL, s);
+}
+
+LuringState *luring_init(Error **errp)
+{
+    int rc;
+    LuringState *s;
+    s = g_new0(LuringState, 1);
+    struct io_uring *ring = &s->ring;
+    rc = io_uring_queue_init(MAX_EVENTS, ring, 0);
+    if (rc < 0) {
+        error_setg_errno(errp, errno, "failed to init linux io_uring ring");
+        g_free(s);
+        return NULL;
+    }
+
+    ioq_init(&s->io_q);
+    return s;
+
+}
+
+void luring_cleanup(LuringState *s)
+{
+    io_uring_queue_exit(&s->ring);
+    g_free(s);
+}
diff --git a/include/block/aio.h b/include/block/aio.h
index 6b0d52f732..7ba9bd7874 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -49,6 +49,7 @@ typedef void IOHandler(void *opaque);
 struct Coroutine;
 struct ThreadPool;
 struct LinuxAioState;
+struct LuringState;
 
 struct AioContext {
     GSource source;
@@ -117,11 +118,19 @@ struct AioContext {
     struct ThreadPool *thread_pool;
 
 #ifdef CONFIG_LINUX_AIO
-    /* State for native Linux AIO.  Uses aio_context_acquire/release for
+    /*
+     * State for native Linux AIO.  Uses aio_context_acquire/release for
      * locking.
      */
     struct LinuxAioState *linux_aio;
 #endif
+#ifdef CONFIG_LINUX_IO_URING
+    /*
+     * State for Linux io_uring.  Uses aio_context_acquire/release for
+     * locking.
+     */
+    struct LuringState *linux_io_uring;
+#endif
 
     /* TimerLists for calling timers - one per clock type.  Has its own
      * locking.
@@ -386,6 +395,11 @@ struct LinuxAioState *aio_setup_linux_aio(AioContext *ctx, Error **errp);
 /* Return the LinuxAioState bound to this AioContext */
 struct LinuxAioState *aio_get_linux_aio(AioContext *ctx);
 
+/* Setup the LuringState bound to this AioContext */
+struct LuringState *aio_setup_linux_io_uring(AioContext *ctx, Error **errp);
+
+/* Return the LuringState bound to this AioContext */
+struct LuringState *aio_get_linux_io_uring(AioContext *ctx);
 /**
  * aio_timer_new_with_attrs:
  * @ctx: the aio context
diff --git a/include/block/block.h b/include/block/block.h
index 40bd93cd0f..bd1ac0b93c 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -297,6 +297,7 @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
 void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
                        Error **errp);
 
+int bdrv_parse_aio(const char *mode, int *flags);
 int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
 int bdrv_parse_discard_flags(const char *mode, int *flags);
 BdrvChild *bdrv_open_child(const char *filename,
diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
index 0cb7cc74a2..71d7d1395f 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -55,6 +55,18 @@ void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context);
 void laio_io_plug(BlockDriverState *bs, LinuxAioState *s);
 void laio_io_unplug(BlockDriverState *bs, LinuxAioState *s);
 #endif
+/* io_uring.c - Linux io_uring implementation */
+#ifdef CONFIG_LINUX_IO_URING
+typedef struct LuringState LuringState;
+LuringState *luring_init(Error **errp);
+void luring_cleanup(LuringState *s);
+int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
+                                uint64_t offset, QEMUIOVector *qiov, int type);
+void luring_detach_aio_context(LuringState *s, AioContext *old_context);
+void luring_attach_aio_context(LuringState *s, AioContext *new_context);
+void luring_io_plug(BlockDriverState *bs, LuringState *s);
+void luring_io_unplug(BlockDriverState *bs, LuringState *s);
+#endif
 
 #ifdef _WIN32
 typedef struct QEMUWin32AIOState QEMUWin32AIOState;
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 05/14] stubs: add stubs for io_uring interface
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (3 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces " Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 06/14] util/async: add aio interfaces for io_uring Aarushi Mehta
                   ` (10 subsequent siblings)
  15 siblings, 0 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS         |  1 +
 stubs/Makefile.objs |  1 +
 stubs/io_uring.c    | 32 ++++++++++++++++++++++++++++++++
 3 files changed, 34 insertions(+)
 create mode 100644 stubs/io_uring.c

diff --git a/MAINTAINERS b/MAINTAINERS
index 651f417f4b..b996bc3abd 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -2537,6 +2537,7 @@ R: Stefan Hajnoczi <stefan@redhat.com>
 L: qemu-block@nongnu.org
 S: Maintained
 F: block/io_uring.c
+F: stubs/io_uring.c
 
 qcow2
 M: Kevin Wolf <kwolf@redhat.com>
diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs
index 9c7393b08c..5cf160a9c8 100644
--- a/stubs/Makefile.objs
+++ b/stubs/Makefile.objs
@@ -13,6 +13,7 @@ stub-obj-y += iothread.o
 stub-obj-y += iothread-lock.o
 stub-obj-y += is-daemonized.o
 stub-obj-$(CONFIG_LINUX_AIO) += linux-aio.o
+stub-obj-$(CONFIG_LINUX_IO_URING) += io_uring.o
 stub-obj-y += machine-init-done.o
 stub-obj-y += migr-blocker.o
 stub-obj-y += change-state-handler.o
diff --git a/stubs/io_uring.c b/stubs/io_uring.c
new file mode 100644
index 0000000000..622d1e4648
--- /dev/null
+++ b/stubs/io_uring.c
@@ -0,0 +1,32 @@
+/*
+ * Linux io_uring support.
+ *
+ * Copyright (C) 2009 IBM, Corp.
+ * Copyright (C) 2009 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+#include "qemu/osdep.h"
+#include "block/aio.h"
+#include "block/raw-aio.h"
+
+void luring_detach_aio_context(LuringState *s, AioContext *old_context)
+{
+    abort();
+}
+
+void luring_attach_aio_context(LuringState *s, AioContext *new_context)
+{
+    abort();
+}
+
+LuringState *luring_init(Error **errp)
+{
+    abort();
+}
+
+void luring_cleanup(LuringState *s)
+{
+    abort();
+}
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 06/14] util/async: add aio interfaces for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (4 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 05/14] stubs: add stubs for io_uring interface Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option Aarushi Mehta
                   ` (9 subsequent siblings)
  15 siblings, 0 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/async.c | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/util/async.c b/util/async.c
index 8d2105729c..2e0a5e20ac 100644
--- a/util/async.c
+++ b/util/async.c
@@ -276,6 +276,14 @@ aio_ctx_finalize(GSource     *source)
     }
 #endif
 
+#ifdef CONFIG_LINUX_IO_URING
+    if (ctx->linux_io_uring) {
+        luring_detach_aio_context(ctx->linux_io_uring, ctx);
+        luring_cleanup(ctx->linux_io_uring);
+        ctx->linux_io_uring = NULL;
+    }
+#endif
+
     assert(QSLIST_EMPTY(&ctx->scheduled_coroutines));
     qemu_bh_delete(ctx->co_schedule_bh);
 
@@ -340,6 +348,29 @@ LinuxAioState *aio_get_linux_aio(AioContext *ctx)
 }
 #endif
 
+#ifdef CONFIG_LINUX_IO_URING
+LuringState *aio_setup_linux_io_uring(AioContext *ctx, Error **errp)
+{
+    if (ctx->linux_io_uring) {
+        return ctx->linux_io_uring;
+    }
+
+    ctx->linux_io_uring = luring_init(errp);
+    if (!ctx->linux_io_uring) {
+        return NULL;
+    }
+
+    luring_attach_aio_context(ctx->linux_io_uring, ctx);
+    return ctx->linux_io_uring;
+}
+
+LuringState *aio_get_linux_io_uring(AioContext *ctx)
+{
+    assert(ctx->linux_io_uring);
+    return ctx->linux_io_uring;
+}
+#endif
+
 void aio_notify(AioContext *ctx)
 {
     /* Write e.g. bh->scheduled before reading ctx->notify_me.  Pairs
@@ -431,6 +462,11 @@ AioContext *aio_context_new(Error **errp)
 #ifdef CONFIG_LINUX_AIO
     ctx->linux_aio = NULL;
 #endif
+
+#ifdef CONFIG_LINUX_IO_URING
+    ctx->linux_io_uring = NULL;
+#endif
+
     ctx->thread_pool = NULL;
     qemu_rec_mutex_init(&ctx->lock);
     timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (5 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 06/14] util/async: add aio interfaces for io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:36   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring Aarushi Mehta
                   ` (8 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 blockdev.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index 4d141e9a1f..695b3a803b 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -383,13 +383,9 @@ static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
         }
 
         if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
-            if (!strcmp(aio, "native")) {
-                *bdrv_flags |= BDRV_O_NATIVE_AIO;
-            } else if (!strcmp(aio, "threads")) {
-                /* this is the default */
-            } else {
-               error_setg(errp, "invalid aio option");
-               return;
+            if (bdrv_parse_aio(aio, bdrv_flags) < 0) {
+                error_setg(errp, "invalid aio option");
+                return;
             }
         }
     }
@@ -4574,7 +4570,7 @@ QemuOptsList qemu_common_drive_opts = {
         },{
             .name = "aio",
             .type = QEMU_OPT_STRING,
-            .help = "host AIO implementation (threads, native)",
+            .help = "host AIO implementation (threads, native, io_uring)",
         },{
             .name = BDRV_OPT_CACHE_WB,
             .type = QEMU_OPT_BOOL,
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (6 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:36   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring Aarushi Mehta
                   ` (7 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta, Maxim Levitsky

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
---
 block/file-posix.c | 99 ++++++++++++++++++++++++++++++++++++----------
 1 file changed, 79 insertions(+), 20 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index 4479cc7ab4..4aa42f826f 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -156,6 +156,7 @@ typedef struct BDRVRawState {
     bool has_write_zeroes:1;
     bool discard_zeroes:1;
     bool use_linux_aio:1;
+    bool use_linux_io_uring:1;
     bool page_cache_inconsistent:1;
     bool has_fallocate;
     bool needs_alignment;
@@ -425,7 +426,7 @@ static QemuOptsList raw_runtime_opts = {
         {
             .name = "aio",
             .type = QEMU_OPT_STRING,
-            .help = "host AIO implementation (threads, native)",
+            .help = "host AIO implementation (threads, native, io_uring)",
         },
         {
             .name = "locking",
@@ -484,9 +485,15 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
         goto fail;
     }
 
-    aio_default = (bdrv_flags & BDRV_O_NATIVE_AIO)
-                  ? BLOCKDEV_AIO_OPTIONS_NATIVE
-                  : BLOCKDEV_AIO_OPTIONS_THREADS;
+    if (bdrv_flags & BDRV_O_NATIVE_AIO) {
+        aio_default = BLOCKDEV_AIO_OPTIONS_NATIVE;
+#ifdef CONFIG_LINUX_IO_URING
+    } else if (bdrv_flags & BDRV_O_IO_URING) {
+        aio_default = BLOCKDEV_AIO_OPTIONS_IO_URING;
+#endif
+    } else {
+        aio_default = BLOCKDEV_AIO_OPTIONS_THREADS;
+    }
     aio = qapi_enum_parse(&BlockdevAioOptions_lookup,
                           qemu_opt_get(opts, "aio"),
                           aio_default, &local_err);
@@ -495,7 +502,11 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
         ret = -EINVAL;
         goto fail;
     }
+
     s->use_linux_aio = (aio == BLOCKDEV_AIO_OPTIONS_NATIVE);
+#ifdef CONFIG_LINUX_IO_URING
+    s->use_linux_io_uring = (aio == BLOCKDEV_AIO_OPTIONS_IO_URING);
+#endif
 
     locking = qapi_enum_parse(&OnOffAuto_lookup,
                               qemu_opt_get(opts, "locking"),
@@ -559,7 +570,7 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
     s->shared_perm = BLK_PERM_ALL;
 
 #ifdef CONFIG_LINUX_AIO
-     /* Currently Linux does AIO only for files opened with O_DIRECT */
+    /* Currently Linux does AIO only for files opened with O_DIRECT */
     if (s->use_linux_aio) {
         if (!(s->open_flags & O_DIRECT)) {
             error_setg(errp, "aio=native was specified, but it requires "
@@ -581,6 +592,22 @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
     }
 #endif /* !defined(CONFIG_LINUX_AIO) */
 
+#ifdef CONFIG_LINUX_IO_URING
+    if (s->use_linux_io_uring) {
+        if (!aio_setup_linux_io_uring(bdrv_get_aio_context(bs), errp)) {
+            error_prepend(errp, "Unable to use io_uring: ");
+            goto fail;
+        }
+    }
+#else
+    if (s->use_linux_io_uring) {
+        error_setg(errp, "aio=io_uring was specified, but is not supported "
+                         "in this build.");
+        ret = -EINVAL;
+        goto fail;
+    }
+#endif /* !defined(CONFIG_LINUX_IO_URING) */
+
     s->has_discard = true;
     s->has_write_zeroes = true;
     if ((bs->open_flags & BDRV_O_NOCACHE) != 0) {
@@ -1874,21 +1901,25 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
         return -EIO;
 
     /*
-     * Check if the underlying device requires requests to be aligned,
-     * and if the request we are trying to submit is aligned or not.
-     * If this is the case tell the low-level driver that it needs
-     * to copy the buffer.
+     * When using O_DIRECT, the request must be aligned to be able to use
+     * either libaio or io_uring interface. If not fail back to regular thread
+     * pool read/write code which emulates this for us if we
+     * set QEMU_AIO_MISALIGNED.
      */
-    if (s->needs_alignment) {
-        if (!bdrv_qiov_is_aligned(bs, qiov)) {
-            type |= QEMU_AIO_MISALIGNED;
+    if (s->needs_alignment && !bdrv_qiov_is_aligned(bs, qiov)) {
+        type |= QEMU_AIO_MISALIGNED;
+#ifdef CONFIG_LINUX_IO_URING
+    } else if (s->use_linux_io_uring) {
+        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
+        assert(qiov->size == bytes);
+        return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+#endif
 #ifdef CONFIG_LINUX_AIO
-        } else if (s->use_linux_aio) {
-            LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
-            assert(qiov->size == bytes);
-            return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
+    } else if (s->use_linux_aio) {
+        LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
+        assert(qiov->size == bytes);
+        return laio_co_submit(bs, aio, s->fd, offset, qiov, type);
 #endif
-        }
     }
 
     acb = (RawPosixAIOData) {
@@ -1924,24 +1955,36 @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
 
 static void raw_aio_plug(BlockDriverState *bs)
 {
+    BDRVRawState __attribute__((unused)) *s = bs->opaque;
 #ifdef CONFIG_LINUX_AIO
-    BDRVRawState *s = bs->opaque;
     if (s->use_linux_aio) {
         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
         laio_io_plug(bs, aio);
     }
 #endif
+#ifdef CONFIG_LINUX_IO_URING
+    if (s->use_linux_io_uring) {
+        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
+        luring_io_plug(bs, aio);
+    }
+#endif
 }
 
 static void raw_aio_unplug(BlockDriverState *bs)
 {
+    BDRVRawState __attribute__((unused)) *s = bs->opaque;
 #ifdef CONFIG_LINUX_AIO
-    BDRVRawState *s = bs->opaque;
     if (s->use_linux_aio) {
         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
         laio_io_unplug(bs, aio);
     }
 #endif
+#ifdef CONFIG_LINUX_IO_URING
+    if (s->use_linux_io_uring) {
+        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
+        luring_io_unplug(bs, aio);
+    }
+#endif
 }
 
 static int raw_co_flush_to_disk(BlockDriverState *bs)
@@ -1961,14 +2004,20 @@ static int raw_co_flush_to_disk(BlockDriverState *bs)
         .aio_type       = QEMU_AIO_FLUSH,
     };
 
+#ifdef CONFIG_LINUX_IO_URING
+    if (s->use_linux_io_uring) {
+        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
+        return luring_co_submit(bs, aio, s->fd, 0, NULL, QEMU_AIO_FLUSH);
+    }
+#endif
     return raw_thread_pool_submit(bs, handle_aiocb_flush, &acb);
 }
 
 static void raw_aio_attach_aio_context(BlockDriverState *bs,
                                        AioContext *new_context)
 {
+    BDRVRawState __attribute__((unused)) *s = bs->opaque;
 #ifdef CONFIG_LINUX_AIO
-    BDRVRawState *s = bs->opaque;
     if (s->use_linux_aio) {
         Error *local_err;
         if (!aio_setup_linux_aio(new_context, &local_err)) {
@@ -1978,6 +2027,16 @@ static void raw_aio_attach_aio_context(BlockDriverState *bs,
         }
     }
 #endif
+#ifdef CONFIG_LINUX_IO_URING
+    if (s->use_linux_io_uring) {
+        Error *local_err;
+        if (!aio_setup_linux_io_uring(new_context, &local_err)) {
+            error_reportf_err(local_err, "Unable to use linux io_uring, "
+                                         "falling back to thread pool: ");
+            s->use_linux_io_uring = false;
+        }
+    }
+#endif
 }
 
 static void raw_close(BlockDriverState *bs)
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (7 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:37   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling Aarushi Mehta
                   ` (6 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 block/io_uring.c   | 22 +++++++++++++++++++---
 block/trace-events | 12 ++++++++++++
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/block/io_uring.c b/block/io_uring.c
index e8dbc388a6..e9c1dc1dc7 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -17,6 +17,7 @@
 #include "block/raw-aio.h"
 #include "qemu/coroutine.h"
 #include "qapi/error.h"
+#include "trace.h"
 
 #define MAX_EVENTS 128
 
@@ -93,6 +94,8 @@ static void luring_resubmit_short_read(LuringState *s, LuringAIOCB *luringcb,
     QEMUIOVector *resubmit_qiov;
     size_t remaining;
 
+    trace_luring_resubmit_short_read(s, luringcb, nread);
+
     /* Update read position */
     luringcb->total_read = nread;
     remaining = luringcb->qiov->size - luringcb->total_read;
@@ -163,6 +166,7 @@ static void luring_process_completions(LuringState *s)
 
         /* Change counters one-by-one because we can be nested. */
         s->io_q.in_flight--;
+        trace_luring_process_completion(s, luringcb, ret);
 
         /* total_read is non-zero only for resubmitted read requests */
         total_bytes = ret + luringcb->total_read;
@@ -263,6 +267,7 @@ static int ioq_submit(LuringState *s)
             QSIMPLEQ_REMOVE_HEAD(&s->io_q.sq_overflow, next);
         }
         ret = io_uring_submit(&s->ring);
+        trace_luring_io_uring_submit(s, ret);
         /* Prevent infinite loop if submission is refused */
         if (ret <= 0) {
             if (ret == -EAGAIN) {
@@ -287,12 +292,15 @@ static int ioq_submit(LuringState *s)
 
 void luring_io_plug(BlockDriverState *bs, LuringState *s)
 {
+    trace_luring_io_plug(s);
     s->io_q.plugged++;
 }
 
 void luring_io_unplug(BlockDriverState *bs, LuringState *s)
 {
     assert(s->io_q.plugged);
+    trace_luring_io_unplug(s, s->io_q.blocked, s->io_q.plugged,
+                           s->io_q.in_queue, s->io_q.in_flight);
     if (--s->io_q.plugged == 0 &&
         !s->io_q.blocked && s->io_q.in_queue > 0) {
         ioq_submit(s);
@@ -313,6 +321,7 @@ void luring_io_unplug(BlockDriverState *bs, LuringState *s)
 static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
                             uint64_t offset, int type)
 {
+    int ret;
     struct io_uring_sqe *sqes = &luringcb->sqeq;
 
     switch (type) {
@@ -336,11 +345,14 @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
 
     QSIMPLEQ_INSERT_TAIL(&s->io_q.sq_overflow, luringcb, next);
     s->io_q.in_queue++;
-
+    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.plugged,
+                           s->io_q.in_queue, s->io_q.in_flight);
     if (!s->io_q.blocked &&
         (!s->io_q.plugged ||
          s->io_q.in_flight + s->io_q.in_queue >= MAX_EVENTS)) {
-        return ioq_submit(s);
+        ret = ioq_submit(s);
+        trace_luring_do_submit_done(s, ret);
+        return ret;
     }
     return 0;
 }
@@ -355,8 +367,10 @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
         .qiov       = qiov,
         .is_read    = (type == QEMU_AIO_READ),
     };
-
+    trace_luring_co_submit(bs, s, &luringcb, fd, offset, qiov ? qiov->size : 0,
+                           type);
     ret = luring_do_submit(fd, &luringcb, s, offset, type);
+
     if (ret < 0) {
         return ret;
     }
@@ -388,6 +402,7 @@ LuringState *luring_init(Error **errp)
     int rc;
     LuringState *s;
     s = g_new0(LuringState, 1);
+    trace_luring_init_state(s, sizeof(*s));
     struct io_uring *ring = &s->ring;
     rc = io_uring_queue_init(MAX_EVENTS, ring, 0);
     if (rc < 0) {
@@ -405,4 +420,5 @@ void luring_cleanup(LuringState *s)
 {
     io_uring_queue_exit(&s->ring);
     g_free(s);
+    trace_luring_cleanup_state(s);
 }
diff --git a/block/trace-events b/block/trace-events
index d724df0117..5060afb2f7 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -60,6 +60,18 @@ qmp_block_stream(void *bs) "bs %p"
 file_paio_submit(void *acb, void *opaque, int64_t offset, int count, int type) "acb %p opaque %p offset %"PRId64" count %d type %d"
 file_copy_file_range(void *bs, int src, int64_t src_off, int dst, int64_t dst_off, int64_t bytes, int flags, int64_t ret) "bs %p src_fd %d offset %"PRIu64" dst_fd %d offset %"PRIu64" bytes %"PRIu64" flags %d ret %"PRId64
 
+#io_uring.c
+luring_init_state(void *s, size_t size) "s %p size %zu"
+luring_cleanup_state(void *s) "%p freed"
+luring_io_plug(void *s) "LuringState %p plug"
+luring_io_unplug(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
+luring_do_submit(void *s, int blocked, int plugged, int queued, int inflight) "LuringState %p blocked %d plugged %d queued %d inflight %d"
+luring_do_submit_done(void *s, int ret) "LuringState %p submitted to kernel %d"
+luring_co_submit(void *bs, void *s, void *luringcb, int fd, uint64_t offset, size_t nbytes, int type) "bs %p s %p luringcb %p fd %d offset %" PRId64 " nbytes %zd type %d"
+luring_process_completion(void *s, void *aiocb, int ret) "LuringState %p luringcb %p ret %d"
+luring_io_uring_submit(void *s, int ret) "LuringState %p ret %d"
+luring_resubmit_short_read(void *s, void *luringcb, int nread) "LuringState %p luringcb %p nread
+
 # qcow2.c
 qcow2_writev_start_req(void *co, int64_t offset, int bytes) "co %p offset 0x%" PRIx64 " bytes %d"
 qcow2_writev_done_req(void *co, int ret) "co %p ret %d"
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (8 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:39   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine Aarushi Mehta
                   ` (5 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 block/io_uring.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/block/io_uring.c b/block/io_uring.c
index e9c1dc1dc7..de2a037151 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -237,6 +237,21 @@ static void qemu_luring_completion_cb(void *opaque)
     luring_process_completions_and_submit(s);
 }
 
+static bool qemu_luring_poll_cb(void *opaque)
+{
+    LuringState *s = opaque;
+    struct io_uring_cqe *cqes;
+
+    if (io_uring_peek_cqe(&s->ring, &cqes) == 0) {
+        if (cqes) {
+            luring_process_completions_and_submit(s);
+            return true;
+        }
+    }
+
+    return false;
+}
+
 static void ioq_init(LuringQueue *io_q)
 {
     QSIMPLEQ_INIT(&io_q->sq_overflow);
@@ -394,7 +409,7 @@ void luring_attach_aio_context(LuringState *s, AioContext *new_context)
     s->aio_context = new_context;
     s->completion_bh = aio_bh_new(new_context, qemu_luring_completion_bh, s);
     aio_set_fd_handler(s->aio_context, s->ring.ring_fd, false,
-                       qemu_luring_completion_cb, NULL, NULL, s);
+                       qemu_luring_completion_cb, NULL, qemu_luring_poll_cb, s);
 }
 
 LuringState *luring_init(Error **errp)
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (9 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:41   ` Stefan Hajnoczi
  2019-07-24 16:42   ` Julia Suvorova
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 12/14] qemu-img: " Aarushi Mehta
                   ` (4 subsequent siblings)
  15 siblings, 2 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Use -i AIOMODE instead of -k.

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 qemu-io.c | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/qemu-io.c b/qemu-io.c
index f64eca6940..3cee06248e 100644
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -130,7 +130,7 @@ static void open_help(void)
 " -C, -- use copy-on-read\n"
 " -n, -- disable host cache, short for -t none\n"
 " -U, -- force shared permissions\n"
-" -k, -- use kernel AIO implementation (on Linux only)\n"
+" -i, -- use AIO mode (threads, native or io_uring)"
 " -t, -- use the given cache mode for the image\n"
 " -d, -- use the given discard mode for the image\n"
 " -o, -- options to be given to the block driver"
@@ -187,9 +187,6 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
         case 'r':
             readonly = 1;
             break;
-        case 'k':
-            flags |= BDRV_O_NATIVE_AIO;
-            break;
         case 't':
             if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
                 error_report("Invalid cache option: %s", optarg);
@@ -204,6 +201,13 @@ static int open_f(BlockBackend *blk, int argc, char **argv)
                 return -EINVAL;
             }
             break;
+        case 'i':
+            if (bdrv_parse_aio(optarg, &flags) < 0) {
+                error_report("Invalid aio option: %s", optarg);
+                qemu_opts_reset(&empty_opts);
+                return -EINVAL;
+            }
+            break;
         case 'o':
             if (imageOpts) {
                 printf("--image-opts and 'open -o' are mutually exclusive\n");
@@ -291,7 +295,7 @@ static void usage(const char *name)
 "  -n, --nocache        disable host cache, short for -t none\n"
 "  -C, --copy-on-read   enable copy-on-read\n"
 "  -m, --misalign       misalign allocations for O_DIRECT\n"
-"  -k, --native-aio     use kernel AIO implementation (on Linux only)\n"
+"  -i, --aio=MODE       use AIO mode (threads, native or io_uring)\n"
 "  -t, --cache=MODE     use the given cache mode for the image\n"
 "  -d, --discard=MODE   use the given discard mode for the image\n"
 "  -T, --trace [[enable=]<pattern>][,events=<file>][,file=<file>]\n"
@@ -489,7 +493,7 @@ static QemuOptsList file_opts = {
 int main(int argc, char **argv)
 {
     int readonly = 0;
-    const char *sopt = "hVc:d:f:rsnCmkt:T:U";
+    const char *sopt = "hVc:d:f:rsnCmit:T:U";
     const struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },
@@ -500,7 +504,7 @@ int main(int argc, char **argv)
         { "nocache", no_argument, NULL, 'n' },
         { "copy-on-read", no_argument, NULL, 'C' },
         { "misalign", no_argument, NULL, 'm' },
-        { "native-aio", no_argument, NULL, 'k' },
+        { "aio", required_argument, NULL, 'i' },
         { "discard", required_argument, NULL, 'd' },
         { "cache", required_argument, NULL, 't' },
         { "trace", required_argument, NULL, 'T' },
@@ -565,8 +569,11 @@ int main(int argc, char **argv)
         case 'm':
             qemuio_misalign = true;
             break;
-        case 'k':
-            flags |= BDRV_O_NATIVE_AIO;
+        case 'i':
+            if (bdrv_parse_aio(optarg, &flags) < 0) {
+                error_report("Invalid aio option: %s", optarg);
+                exit(1);
+            }
             break;
         case 't':
             if (bdrv_parse_cache_mode(optarg, &flags, &writethrough) < 0) {
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 12/14] qemu-img: adds option to use aio engine
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (10 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:42   ` Stefan Hajnoczi
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines Aarushi Mehta
                   ` (3 subsequent siblings)
  15 siblings, 1 reply; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Use -i AIOMODE instead of -n.

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 qemu-img.c | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c
index 79983772de..b7a962afff 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -4192,7 +4192,7 @@ static int img_bench(int argc, char **argv)
             {"force-share", no_argument, 0, 'U'},
             {0, 0, 0, 0}
         };
-        c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
+        c = getopt_long(argc, argv, ":hc:d:f:io:qs:S:t:wU", long_options, NULL);
         if (c == -1) {
             break;
         }
@@ -4232,8 +4232,13 @@ static int img_bench(int argc, char **argv)
         case 'f':
             fmt = optarg;
             break;
-        case 'n':
-            flags |= BDRV_O_NATIVE_AIO;
+        case 'i':
+            ret = bdrv_parse_aio(optarg, &flags);
+            if (ret < 0) {
+                error_report("Invalid aio option: %s", optarg);
+                ret = -1;
+                goto out;
+            }
             break;
         case 'o':
         {
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (11 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 12/14] qemu-img: " Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:43   ` Stefan Hajnoczi
  2019-07-19 15:55   ` Eric Blake
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options Aarushi Mehta
                   ` (2 subsequent siblings)
  15 siblings, 2 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 qemu-nbd.c | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/qemu-nbd.c b/qemu-nbd.c
index a8cb39e510..e5a71b3501 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -135,7 +135,7 @@ static void usage(const char *name)
 "                            '[ID_OR_NAME]'\n"
 "  -n, --nocache             disable host cache\n"
 "      --cache=MODE          set cache mode (none, writeback, ...)\n"
-"      --aio=MODE            set AIO mode (native or threads)\n"
+"      --aio=MODE            set AIO mode (native, io_uring or threads)\n"
 "      --discard=MODE        set discard mode (ignore, unmap)\n"
 "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
 "      --image-opts          treat FILE as a full set of image options\n"
@@ -718,13 +718,9 @@ int main(int argc, char **argv)
                 exit(EXIT_FAILURE);
             }
             seen_aio = true;
-            if (!strcmp(optarg, "native")) {
-                flags |= BDRV_O_NATIVE_AIO;
-            } else if (!strcmp(optarg, "threads")) {
-                /* this is the default */
-            } else {
-               error_report("invalid aio mode `%s'", optarg);
-               exit(EXIT_FAILURE);
+            if (bdrv_parse_aio(optarg, &flags) < 0) {
+                error_report("Invalid aio mode `%s'", optarg);
+                exit(EXIT_FAILURE);
             }
             break;
         case QEMU_NBD_OPT_DISCARD:
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (12 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines Aarushi Mehta
@ 2019-07-19 13:35 ` Aarushi Mehta
  2019-07-19 15:54   ` Stefan Hajnoczi
  2019-07-24 16:49   ` Julia Suvorova
  2019-07-19 22:33 ` [Qemu-devel] [PATCH v6 00/14] Add support for io_uring no-reply
  2019-07-19 23:25 ` no-reply
  15 siblings, 2 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:35 UTC (permalink / raw)
  To: qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova,
	Aarushi Mehta

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---
 tests/qemu-iotests/check     | 14 +++++++++++++-
 tests/qemu-iotests/common.rc | 10 ++++++++++
 2 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index f925606cc5..2bc5bc62e2 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -132,6 +132,7 @@ sortme=false
 expunge=true
 have_test_arg=false
 cachemode=false
+aiomode=false
 
 tmp="${TEST_DIR}"/$$
 rm -f $tmp.list $tmp.tmp $tmp.sed
@@ -141,6 +142,7 @@ export IMGFMT_GENERIC=true
 export IMGPROTO=file
 export IMGOPTS=""
 export CACHEMODE="writeback"
+export AIOMODE="threads"
 export QEMU_IO_OPTIONS=""
 export QEMU_IO_OPTIONS_NO_FMT=""
 export CACHEMODE_IS_DEFAULT=true
@@ -225,6 +227,10 @@ s/ .*//p
         CACHEMODE_IS_DEFAULT=false
         cachemode=false
         continue
+    elif $aiomode
+    then
+        AIOMODE="$r"
+        aiomode=false
     fi
 
     xpand=true
@@ -269,6 +275,7 @@ other options
     -n                  show me, do not run tests
     -o options          -o options to pass to qemu-img create/convert
     -c mode             cache mode
+    -i mode             AIO mode
     -makecheck          pretty print output for make check
 
 testlist options
@@ -433,10 +440,13 @@ testlist options
             cachemode=true
             xpand=false
             ;;
+        -i)
+            aiomode=true
+            xpand=false
+            ;;
         -T)        # deprecated timestamp option
             xpand=false
             ;;
-
         -v)
             verbose=true
             xpand=false
@@ -515,6 +525,8 @@ done
 
 # Set qemu-io cache mode with $CACHEMODE we have
 QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS --cache $CACHEMODE"
+# Set qemu-io aio mode with $AIOMODE we have
+QEMU_IO_OPTIONS="$QEMU_IO_OPTIONS --aio $AIOMODE"
 
 QEMU_IO_OPTIONS_NO_FMT="$QEMU_IO_OPTIONS"
 if [ "$IMGOPTSSYNTAX" != "true" ]; then
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index 5502c3da2f..39c04cc169 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -482,6 +482,16 @@ _supported_cache_modes()
     _notrun "not suitable for cache mode: $CACHEMODE"
 }
 
+_supported_aio_modes()
+{
+    for mode; do
+        if [ "$mode" = "$AIOMODE" ]; then
+            return
+        fi
+    done
+    _notrun "not suitable for aio mode: $AIOMODE"
+}
+
 _default_cache_mode()
 {
     if $CACHEMODE_IS_DEFAULT; then
-- 
2.21.0



^ permalink raw reply related	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring Aarushi Mehta
@ 2019-07-19 15:20   ` Stefan Hajnoczi
  2019-07-19 15:49   ` Eric Blake
  1 sibling, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:20 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 812 bytes --]

On Fri, Jul 19, 2019 at 07:05:18PM +0530, Aarushi Mehta wrote:
> Only enumerates option for devices that support it
> 
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
> ---
>  qapi/block-core.json | 4 +++-
>  1 file changed, 3 insertions(+), 1 deletion(-)
> 
> diff --git a/qapi/block-core.json b/qapi/block-core.json
> index 0d43d4f37c..0a3d4ae7d2 100644
> --- a/qapi/block-core.json
> +++ b/qapi/block-core.json
> @@ -2792,11 +2792,13 @@
>  #
>  # @threads:     Use qemu's thread pool
>  # @native:      Use native AIO backend (only Linux and Windows)
> +# @io_uring:    Use linux io_uring (since 4.1)

Please change this to 4.2.  QEMU 4.1 is frozen prior to the upcoming
release and new features aren't being merged.

Stefan

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces for io_uring
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces " Aarushi Mehta
@ 2019-07-19 15:34   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:34 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 2680 bytes --]

On Fri, Jul 19, 2019 at 07:05:20PM +0530, Aarushi Mehta wrote:
> diff --git a/block.c b/block.c
> index 29e931e217..4aa3500ad8 100644
> --- a/block.c
> +++ b/block.c
> @@ -844,6 +844,28 @@ static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
>      return detect_zeroes;
>  }
>  
> +/**
> + * Set flags for aio engine

Other parse_*() functions are more specific about which type of flags
are produced:

s/flags/open flags/

> + *
> + * Return 0 on success, -1 if the engine specifies is invalid

s/specifies/specified/

> + */
> +int bdrv_parse_aio(const char *mode, int *flags)
> +{
> +    if (!strcmp(mode, "threads")) {
> +        /* do nothing, default */
> +    } else if (!strcmp(mode, "native")) {
> +        *flags |= BDRV_O_NATIVE_AIO;
> +#ifdef CONFIG_LINUX_IO_URING
> +    } else if (!strcmp(mode, "io_uring")) {
> +        *flags |= BDRV_O_IO_URING;
> +#endif
> +    } else {
> +        return -1;
> +    }
> +
> +    return 0;
> +}

Can you move this change to the patch that uses bdrv_parse_aio()?  I
don't see any callers in this patch.

> +        if (ret < 0) {
> +            if (ret == -EINTR) {
> +                luring_resubmit(s, luringcb);
> +                continue;
> +            }
> +        } else if (!luringcb->qiov) {
> +            goto end;
> +        } else if (total_bytes == luringcb->qiov->size) {
> +                ret = 0;

Indentation is off here.

> +static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
> +                            uint64_t offset, int type)
> +{
> +    struct io_uring_sqe *sqes = &luringcb->sqeq;
> +
> +    switch (type) {
> +    case QEMU_AIO_WRITE:
> +        io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
> +                             luringcb->qiov->niov, offset);
> +        break;
> +    case QEMU_AIO_READ:
> +        io_uring_prep_readv(sqes, fd, luringcb->qiov->iov,
> +                            luringcb->qiov->niov, offset);
> +        break;
> +    case QEMU_AIO_FLUSH:
> +        io_uring_prep_fsync(sqes, fd, 0);

In QEMU QEMU_AIO_FLUSH is fdatasync so the IORING_FSYNC_DATASYNC flag
can be used for a slightly cheaper fsync operation.

> +        break;
> +    default:
> +        fprintf(stderr, "%s: invalid AIO request type, aborting 0x%x.\n",
> +                        __func__, type);
> +        abort();
> +    }
> +    io_uring_sqe_set_data(sqes, luringcb);
> +
> +    QSIMPLEQ_INSERT_TAIL(&s->io_q.sq_overflow, luringcb, next);

Now that we use sq_overflow unconditionally it can be renamed to
submit_queue, making the code easier to understand.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring Aarushi Mehta
@ 2019-07-19 15:36   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:36 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova, Maxim Levitsky

[-- Attachment #1: Type: text/plain, Size: 360 bytes --]

On Fri, Jul 19, 2019 at 07:05:24PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
> ---
>  block/file-posix.c | 99 ++++++++++++++++++++++++++++++++++++----------
>  1 file changed, 79 insertions(+), 20 deletions(-)

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option Aarushi Mehta
@ 2019-07-19 15:36   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:36 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 260 bytes --]

On Fri, Jul 19, 2019 at 07:05:23PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  blockdev.c | 12 ++++--------
>  1 file changed, 4 insertions(+), 8 deletions(-)

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring Aarushi Mehta
@ 2019-07-19 15:37   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:37 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 391 bytes --]

On Fri, Jul 19, 2019 at 07:05:25PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  block/io_uring.c   | 22 +++++++++++++++++++---
>  block/trace-events | 12 ++++++++++++
>  2 files changed, 31 insertions(+), 3 deletions(-)

Trace events don't need to be a separate patch, but this is okay too.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling Aarushi Mehta
@ 2019-07-19 15:39   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:39 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 271 bytes --]

On Fri, Jul 19, 2019 at 07:05:26PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  block/io_uring.c | 17 ++++++++++++++++-
>  1 file changed, 16 insertions(+), 1 deletion(-)

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine Aarushi Mehta
@ 2019-07-19 15:41   ` Stefan Hajnoczi
  2019-07-19 15:44     ` Daniel P. Berrangé
  2019-07-24 16:42   ` Julia Suvorova
  1 sibling, 1 reply; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:41 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 824 bytes --]

On Fri, Jul 19, 2019 at 07:05:27PM +0530, Aarushi Mehta wrote:
> Use -i AIOMODE instead of -k.
> 
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  qemu-io.c | 25 ++++++++++++++++---------
>  1 file changed, 16 insertions(+), 9 deletions(-)
> 
> diff --git a/qemu-io.c b/qemu-io.c
> index f64eca6940..3cee06248e 100644
> --- a/qemu-io.c
> +++ b/qemu-io.c
> @@ -130,7 +130,7 @@ static void open_help(void)
>  " -C, -- use copy-on-read\n"
>  " -n, -- disable host cache, short for -t none\n"
>  " -U, -- force shared permissions\n"
> -" -k, -- use kernel AIO implementation (on Linux only)\n"
> +" -i, -- use AIO mode (threads, native or io_uring)"

Please keep the existing option for backwards compatibility.  Existing
command-lines must continue to work so we don't inconvenience users.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 12/14] qemu-img: adds option to use aio engine
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 12/14] qemu-img: " Aarushi Mehta
@ 2019-07-19 15:42   ` Stefan Hajnoczi
  0 siblings, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:42 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 758 bytes --]

On Fri, Jul 19, 2019 at 07:05:28PM +0530, Aarushi Mehta wrote:
> Use -i AIOMODE instead of -n.
> 
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  qemu-img.c | 11 ++++++++---
>  1 file changed, 8 insertions(+), 3 deletions(-)
> 
> diff --git a/qemu-img.c b/qemu-img.c
> index 79983772de..b7a962afff 100644
> --- a/qemu-img.c
> +++ b/qemu-img.c
> @@ -4192,7 +4192,7 @@ static int img_bench(int argc, char **argv)
>              {"force-share", no_argument, 0, 'U'},
>              {0, 0, 0, 0}
>          };
> -        c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
> +        c = getopt_long(argc, argv, ":hc:d:f:io:qs:S:t:wU", long_options, NULL);

Please preserve -n for backwards compability.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines Aarushi Mehta
@ 2019-07-19 15:43   ` Stefan Hajnoczi
  2019-07-19 15:55   ` Eric Blake
  1 sibling, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:43 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 260 bytes --]

On Fri, Jul 19, 2019 at 07:05:29PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  qemu-nbd.c | 12 ++++--------
>  1 file changed, 4 insertions(+), 8 deletions(-)

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine
  2019-07-19 15:41   ` Stefan Hajnoczi
@ 2019-07-19 15:44     ` Daniel P. Berrangé
  0 siblings, 0 replies; 33+ messages in thread
From: Daniel P. Berrangé @ 2019-07-19 15:44 UTC (permalink / raw)
  To: Stefan Hajnoczi
  Cc: Fam Zheng, Kevin Wolf, Stefan Hajnoczi, qemu-block, Sergio Lopez,
	Markus Armbruster, qemu-devel, Maxim Levitsky, saket.sinha89,
	Paolo Bonzini, Max Reitz, Julia Suvorova, Aarushi Mehta

On Fri, Jul 19, 2019 at 04:41:15PM +0100, Stefan Hajnoczi wrote:
> On Fri, Jul 19, 2019 at 07:05:27PM +0530, Aarushi Mehta wrote:
> > Use -i AIOMODE instead of -k.
> > 
> > Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> > ---
> >  qemu-io.c | 25 ++++++++++++++++---------
> >  1 file changed, 16 insertions(+), 9 deletions(-)
> > 
> > diff --git a/qemu-io.c b/qemu-io.c
> > index f64eca6940..3cee06248e 100644
> > --- a/qemu-io.c
> > +++ b/qemu-io.c
> > @@ -130,7 +130,7 @@ static void open_help(void)
> >  " -C, -- use copy-on-read\n"
> >  " -n, -- disable host cache, short for -t none\n"
> >  " -U, -- force shared permissions\n"
> > -" -k, -- use kernel AIO implementation (on Linux only)\n"
> > +" -i, -- use AIO mode (threads, native or io_uring)"
> 
> Please keep the existing option for backwards compatibility.  Existing
> command-lines must continue to work so we don't inconvenience users.

We could deprecate the -k option though, so it can be deleted a couple
of releases later.

Regards,
Daniel
-- 
|: https://berrange.com      -o-    https://www.flickr.com/photos/dberrange :|
|: https://libvirt.org         -o-            https://fstop138.berrange.com :|
|: https://entangle-photo.org    -o-    https://www.instagram.com/dberrange :|


^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring Aarushi Mehta
  2019-07-19 15:20   ` Stefan Hajnoczi
@ 2019-07-19 15:49   ` Eric Blake
  1 sibling, 0 replies; 33+ messages in thread
From: Eric Blake @ 2019-07-19 15:49 UTC (permalink / raw)
  To: Aarushi Mehta, qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova


[-- Attachment #1.1: Type: text/plain, Size: 1346 bytes --]

On 7/19/19 8:35 AM, Aarushi Mehta wrote:
> Only enumerates option for devices that support it
> 
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
> ---
>  qapi/block-core.json | 4 +++-
>  1 file changed, 3 insertions(+), 1 deletion(-)
> 
> diff --git a/qapi/block-core.json b/qapi/block-core.json
> index 0d43d4f37c..0a3d4ae7d2 100644
> --- a/qapi/block-core.json
> +++ b/qapi/block-core.json
> @@ -2792,11 +2792,13 @@
>  #
>  # @threads:     Use qemu's thread pool
>  # @native:      Use native AIO backend (only Linux and Windows)
> +# @io_uring:    Use linux io_uring (since 4.1)

I know you explained in an earlier revision why you chose 'io_uring'
instead of the more typical QAPI spelling of 'io-uring' (namely, it
matches the Linux kernel feature spelling).  That explanation belongs in
the commit message, rather than just the mailing list archives.

>  #
>  # Since: 2.9
>  ##
>  { 'enum': 'BlockdevAioOptions',
> -  'data': [ 'threads', 'native' ] }
> +  'data': [ 'threads', 'native',
> +            { 'name': 'io_uring', 'if': 'defined(CONFIG_LINUX_IO_URING)' } ] }
>  
>  ##
>  # @BlockdevCacheOptions:
> 

-- 
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options Aarushi Mehta
@ 2019-07-19 15:54   ` Stefan Hajnoczi
  2019-07-24 16:49   ` Julia Suvorova
  1 sibling, 0 replies; 33+ messages in thread
From: Stefan Hajnoczi @ 2019-07-19 15:54 UTC (permalink / raw)
  To: Aarushi Mehta
  Cc: Fam Zheng, Maxim Levitsky, qemu-block, Sergio Lopez, qemu-devel,
	Markus Armbruster, saket.sinha89, Max Reitz, Kevin Wolf,
	Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

[-- Attachment #1: Type: text/plain, Size: 691 bytes --]

On Fri, Jul 19, 2019 at 07:05:30PM +0530, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  tests/qemu-iotests/check     | 14 +++++++++++++-
>  tests/qemu-iotests/common.rc | 10 ++++++++++
>  2 files changed, 23 insertions(+), 1 deletion(-)

So far this patch affects qemu-io only.  That's a good start but more
can be done.

Taking CACHEMODE as an example, there are other places where the
parameter can be added.  The main one is qemu -drive options but
qemu-img could also use AIOMODE.

Please add an aiomode variable to the iotests.py module (see how
cachemode is set there) so that Python tests can use the the value set
on the ./check command-line.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines Aarushi Mehta
  2019-07-19 15:43   ` Stefan Hajnoczi
@ 2019-07-19 15:55   ` Eric Blake
  1 sibling, 0 replies; 33+ messages in thread
From: Eric Blake @ 2019-07-19 15:55 UTC (permalink / raw)
  To: Aarushi Mehta, qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova


[-- Attachment #1.1: Type: text/plain, Size: 2164 bytes --]

On 7/19/19 8:35 AM, Aarushi Mehta wrote:
> Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
> ---
>  qemu-nbd.c | 12 ++++--------
>  1 file changed, 4 insertions(+), 8 deletions(-)
> 

Missing a patch to qemu-nbd.texi to document this.

> diff --git a/qemu-nbd.c b/qemu-nbd.c
> index a8cb39e510..e5a71b3501 100644
> --- a/qemu-nbd.c
> +++ b/qemu-nbd.c
> @@ -135,7 +135,7 @@ static void usage(const char *name)
>  "                            '[ID_OR_NAME]'\n"
>  "  -n, --nocache             disable host cache\n"
>  "      --cache=MODE          set cache mode (none, writeback, ...)\n"
> -"      --aio=MODE            set AIO mode (native or threads)\n"
> +"      --aio=MODE            set AIO mode (native, io_uring or threads)\n"
>  "      --discard=MODE        set discard mode (ignore, unmap)\n"
>  "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
>  "      --image-opts          treat FILE as a full set of image options\n"
> @@ -718,13 +718,9 @@ int main(int argc, char **argv)
>                  exit(EXIT_FAILURE);
>              }
>              seen_aio = true;
> -            if (!strcmp(optarg, "native")) {
> -                flags |= BDRV_O_NATIVE_AIO;
> -            } else if (!strcmp(optarg, "threads")) {
> -                /* this is the default */
> -            } else {
> -               error_report("invalid aio mode `%s'", optarg);
> -               exit(EXIT_FAILURE);
> +            if (bdrv_parse_aio(optarg, &flags) < 0) {
> +                error_report("Invalid aio mode `%s'", optarg);
> +                exit(EXIT_FAILURE);

Nice - you're also fixing an indentation error.  We aren't consistent on
whether error messages start with upper or lowercase, so I will overlook
that change.

But as long as you're touching the line, could you also change `' to be
''?  The former form looks awkward in modern type, and while it was
popular 20 years ago, nowadays it makes programs look dated (or
identifies you as a user of m4...).

-- 
Eric Blake, Principal Software Engineer
Red Hat, Inc.           +1-919-301-3226
Virtualization:  qemu.org | libvirt.org


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 488 bytes --]

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 00/14] Add support for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (13 preceding siblings ...)
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options Aarushi Mehta
@ 2019-07-19 22:33 ` no-reply
  2019-07-19 23:25 ` no-reply
  15 siblings, 0 replies; 33+ messages in thread
From: no-reply @ 2019-07-19 22:33 UTC (permalink / raw)
  To: mehta.aaru20
  Cc: fam, kwolf, stefan, qemu-block, slp, qemu-devel, armbru,
	saket.sinha89, mreitz, stefanha, pbonzini, mlevitsk, jusual,
	mehta.aaru20

Patchew URL: https://patchew.org/QEMU/20190719133530.28688-1-mehta.aaru20@gmail.com/



Hi,

This series failed the asan build test. Please find the testing commands and
their output below. If you have Docker installed, you can probably reproduce it
locally.

=== TEST SCRIPT BEGIN ===
#!/bin/bash
make docker-image-fedora V=1 NETWORK=1
time make docker-test-debug@fedora TARGET_LIST=x86_64-softmmu J=14 NETWORK=1
=== TEST SCRIPT END ===

  CC      hw/arm/trace.o
  CC      hw/audio/trace.o
In file included from block/trace.c:4:
/tmp/qemu-test/build/block/trace.h:1704:96: error: expected ')'
        qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
                                                                                               ^
/tmp/qemu-test/build/block/trace.h:1704:17: note: to match this '('
        qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
                ^
/tmp/qemu-test/build/block/trace.h:1704:98: error: missing terminating '"' character [-Werror,-Winvalid-pp-token]
        qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
                                                                                                 ^
  CC      hw/block/trace.o


The full log is available at
http://patchew.org/logs/20190719133530.28688-1-mehta.aaru20@gmail.com/testing.asan/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to patchew-devel@redhat.com

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 00/14] Add support for io_uring
  2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
                   ` (14 preceding siblings ...)
  2019-07-19 22:33 ` [Qemu-devel] [PATCH v6 00/14] Add support for io_uring no-reply
@ 2019-07-19 23:25 ` no-reply
  15 siblings, 0 replies; 33+ messages in thread
From: no-reply @ 2019-07-19 23:25 UTC (permalink / raw)
  To: mehta.aaru20
  Cc: fam, kwolf, stefan, qemu-block, slp, qemu-devel, armbru,
	saket.sinha89, mreitz, stefanha, pbonzini, mlevitsk, jusual,
	mehta.aaru20

Patchew URL: https://patchew.org/QEMU/20190719133530.28688-1-mehta.aaru20@gmail.com/



Hi,

This series failed build test on s390x host. Please find the details below.

=== TEST SCRIPT BEGIN ===
#!/bin/bash
# Testing script will be invoked under the git checkout with
# HEAD pointing to a commit that has the patches applied on top of "base"
# branch
set -e

echo
echo "=== ENV ==="
env

echo
echo "=== PACKAGES ==="
rpm -qa

echo
echo "=== UNAME ==="
uname -a

CC=$HOME/bin/cc
INSTALL=$PWD/install
BUILD=$PWD/build
mkdir -p $BUILD $INSTALL
SRC=$PWD
cd $BUILD
$SRC/configure --cc=$CC --prefix=$INSTALL
make -j4
# XXX: we need reliable clean up
# make check -j4 V=1
make install
=== TEST SCRIPT END ===

  CC      nbd/trace.o
In file included from block/trace.c:4:
block/trace.h: In function ‘_nocheck__trace_luring_resubmit_short_read’:
block/trace.h:1704:96: error: stray ‘\’ in program
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                                                                                                ^
block/trace.h:1704:60: error: expected ‘)’ before ‘n’
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                                                            ^                                    ~
      |                                                            )
block/trace.h:1704:98: error: missing terminating " character [-Werror]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                                                                                                  ^
block/trace.h:1704:98: error: missing terminating " character
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                                                                                                  ^~
block/trace.h:1704:20: error: format ‘%d’ expects a matching ‘int’ argument [-Werror=format=]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                   ~^
      |                    |
      |                    int
block/trace.h:1704:24: error: format ‘%zu’ expects a matching ‘size_t’ argument [-Werror=format=]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                      ~~^
      |                        |
      |                        long unsigned int
block/trace.h:1704:30: error: format ‘%zu’ expects a matching ‘size_t’ argument [-Werror=format=]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                          ~~~~^
      |                              |
      |                              long unsigned int
block/trace.h:1704:18: error: format ‘%p’ expects a matching ‘void *’ argument [-Werror=format=]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
block/trace.h:1704:75: note: format string is defined here
---
      |                                                                          ~^
      |                                                                           |
      |                                                                           void *
block/trace.h:1704:18: error: format ‘%p’ expects a matching ‘void *’ argument [-Werror=format=]
 1704 |         qemu_log("%d@%zu.%06zu:luring_resubmit_short_read " "LuringState %p luringcb %p nread "\n",
      |                  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
block/trace.h:1704:87: note: format string is defined here


The full log is available at
http://patchew.org/logs/20190719133530.28688-1-mehta.aaru20@gmail.com/testing.s390x/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to patchew-devel@redhat.com

^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine Aarushi Mehta
  2019-07-19 15:41   ` Stefan Hajnoczi
@ 2019-07-24 16:42   ` Julia Suvorova
  1 sibling, 0 replies; 33+ messages in thread
From: Julia Suvorova @ 2019-07-24 16:42 UTC (permalink / raw)
  To: Aarushi Mehta, qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

On 7/19/19 3:35 PM, Aarushi Mehta wrote:
> @@ -489,7 +493,7 @@ static QemuOptsList file_opts = {
>   int main(int argc, char **argv)
>   {
>       int readonly = 0;
> -    const char *sopt = "hVc:d:f:rsnCmkt:T:U";
> +    const char *sopt = "hVc:d:f:rsnCmit:T:U";

Add ':' after 'i' to pass an argument after -i option, as it currently
works with a long variant.

Best regards, Julia Suvorova.


^ permalink raw reply	[flat|nested] 33+ messages in thread

* Re: [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options
  2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options Aarushi Mehta
  2019-07-19 15:54   ` Stefan Hajnoczi
@ 2019-07-24 16:49   ` Julia Suvorova
  1 sibling, 0 replies; 33+ messages in thread
From: Julia Suvorova @ 2019-07-24 16:49 UTC (permalink / raw)
  To: Aarushi Mehta, qemu-devel
  Cc: Fam Zheng, Kevin Wolf, qemu-block, Sergio Lopez,
	Markus Armbruster, Maxim Levitsky, saket.sinha89, Max Reitz,
	Stefan Hajnoczi, Paolo Bonzini, Stefan Hajnoczi, Julia Suvorova

On 7/19/19 3:35 PM, Aarushi Mehta wrote:
  @@ -225,6 +227,10 @@ s/ .*//p
>           CACHEMODE_IS_DEFAULT=false
>           cachemode=false
>           continue
> +    elif $aiomode
> +    then
> +        AIOMODE="$r"
> +        aiomode=false

'continue' is missed here.

Best regards, Julia Suvorova.


^ permalink raw reply	[flat|nested] 33+ messages in thread

* [Qemu-devel] [PATCH v6 00/14] Add support for io_uring
@ 2019-07-19 13:27 Aarushi Mehta
  0 siblings, 0 replies; 33+ messages in thread
From: Aarushi Mehta @ 2019-07-19 13:27 UTC (permalink / raw)
  To: qemu-devel; +Cc: Aarushi Mehta

This patch series adds support for the newly developed io_uring Linux AIO
interface. Linux io_uring is faster than Linux's AIO asynchronous I/O code,
offers efficient buffered asynchronous I/O support, the ability to do I/O
without performing a system call via polled I/O, and other efficiency enhancements.

Testing it requires a host kernel (5.1+) and the liburing library.
Use the option -drive aio=io_uring to enable it.

Benchmarks for the system at https://github.com/rooshm/benchmarks
io_uring has similar performance as libaio but supports cache=writeback.
Further performance enhancement will be implemented

There is currently an -EIO output when guests are booted from io_uring
disks for the second time with clean shutdowns that is being investigated.

v6:
- add slow path for short-read
- hooks up fsync
- enables qemu-iotests with aio options
- adds bdrv_parse_aio

v5:
- Adds completion polling
- Extends qemu-io
- Adds qemu-iotest

v4:
- Add error handling
- Add trace events
- Remove aio submission based code

Aarushi Mehta (14):
  configure: permit use of io_uring
  qapi/block-core: add option for io_uring
  block/block: add BDRV flag for io_uring
  block/io_uring: implements interfaces for io_uring
  stubs: add stubs for io_uring interface
  util/async: add aio interfaces for io_uring
  blockdev: accept io_uring as option
  block/file-posix.c: extend to use io_uring
  block: add trace events for io_uring
  block/io_uring: adds userspace completion polling
  qemu-io: adds option to use aio engine
  qemu-img: adds option to use aio engine
  qemu-nbd: adds option for aio engines
  tests/qemu-iotest: enable testing with qemu-io aio options

 MAINTAINERS                  |   8 +
 block.c                      |  22 ++
 block/Makefile.objs          |   3 +
 block/file-posix.c           |  99 ++++++--
 block/io_uring.c             | 439 +++++++++++++++++++++++++++++++++++
 block/trace-events           |  12 +
 blockdev.c                   |  12 +-
 configure                    |  27 +++
 include/block/aio.h          |  16 +-
 include/block/block.h        |   2 +
 include/block/raw-aio.h      |  12 +
 qapi/block-core.json         |   4 +-
 qemu-img.c                   |  11 +-
 qemu-io.c                    |  25 +-
 qemu-nbd.c                   |  12 +-
 stubs/Makefile.objs          |   1 +
 stubs/io_uring.c             |  32 +++
 tests/qemu-iotests/check     |  14 +-
 tests/qemu-iotests/common.rc |  10 +
 util/async.c                 |  36 +++
 20 files changed, 746 insertions(+), 51 deletions(-)
 create mode 100644 block/io_uring.c
 create mode 100644 stubs/io_uring.c

-- 
2.21.0



^ permalink raw reply	[flat|nested] 33+ messages in thread

end of thread, other threads:[~2019-07-24 17:15 UTC | newest]

Thread overview: 33+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2019-07-19 13:35 [Qemu-devel] [PATCH v6 00/14] Add support for io_uring Aarushi Mehta
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 01/14] configure: permit use of io_uring Aarushi Mehta
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 02/14] qapi/block-core: add option for io_uring Aarushi Mehta
2019-07-19 15:20   ` Stefan Hajnoczi
2019-07-19 15:49   ` Eric Blake
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 03/14] block/block: add BDRV flag " Aarushi Mehta
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 04/14] block/io_uring: implements interfaces " Aarushi Mehta
2019-07-19 15:34   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 05/14] stubs: add stubs for io_uring interface Aarushi Mehta
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 06/14] util/async: add aio interfaces for io_uring Aarushi Mehta
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 07/14] blockdev: accept io_uring as option Aarushi Mehta
2019-07-19 15:36   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 08/14] block/file-posix.c: extend to use io_uring Aarushi Mehta
2019-07-19 15:36   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 09/14] block: add trace events for io_uring Aarushi Mehta
2019-07-19 15:37   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 10/14] block/io_uring: adds userspace completion polling Aarushi Mehta
2019-07-19 15:39   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 11/14] qemu-io: adds option to use aio engine Aarushi Mehta
2019-07-19 15:41   ` Stefan Hajnoczi
2019-07-19 15:44     ` Daniel P. Berrangé
2019-07-24 16:42   ` Julia Suvorova
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 12/14] qemu-img: " Aarushi Mehta
2019-07-19 15:42   ` Stefan Hajnoczi
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 13/14] qemu-nbd: adds option for aio engines Aarushi Mehta
2019-07-19 15:43   ` Stefan Hajnoczi
2019-07-19 15:55   ` Eric Blake
2019-07-19 13:35 ` [Qemu-devel] [PATCH v6 14/14] qemu-iotest: enable testing with qemu-io aio options Aarushi Mehta
2019-07-19 15:54   ` Stefan Hajnoczi
2019-07-24 16:49   ` Julia Suvorova
2019-07-19 22:33 ` [Qemu-devel] [PATCH v6 00/14] Add support for io_uring no-reply
2019-07-19 23:25 ` no-reply
  -- strict thread matches above, loose matches on Subject: below --
2019-07-19 13:27 Aarushi Mehta

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.