Series comparison

-[Qemu-devel] [PULL 00/24] Block patches
+[PULL 00/18] Block patches
-The following changes since commit 5dae13cd71f0755a1395b5a4cde635b8a6ee3f58:
+The following changes since commit 928173659d6e5dc368284f73f90ea1d129e1f57d:
-  Merge remote-tracking branch 'remotes/rth/tags/pull-or-20170214' into staging (2017-02-14 09:55:48 +0000)
+  Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200130' into staging (2020-01-30 16:19:04 +0000)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://github.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to decc18f33adecb1316437a47fff0cf0a7665906a:
+for you to fetch changes up to 8dff69b9415b4287e900358744b732195e1ab2e2:
-  coroutine-lock: make CoRwlock thread-safe and fair (2017-02-16 17:17:34 +0000)
+  tests/qemu-iotests: use AIOMODE with various tests (2020-01-30 21:01:40 +0000)
 ----------------------------------------------------------------
 Pull request
 ----------------------------------------------------------------
-----------------------------------------------------------------
+Aarushi Mehta (15):
   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: adds bdrv_parse_aio to use io_uring
   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 for benchmarking
   qemu-nbd: adds option for aio engines
   tests/qemu-iotests: enable testing with aio options
   tests/qemu-iotests: use AIOMODE with various tests
-Paolo Bonzini (24):
+Paolo Bonzini (3):
-  block: move AioContext, QEMUTimer, main-loop to libqemuutil
+  block: eliminate BDRV_REQ_NO_SERIALISING
-  aio: introduce aio_co_schedule and aio_co_wake
+  block/io: wait for serialising requests when a request becomes
-  block-backend: allow blk_prw from coroutine context
+    serialising
-  test-thread-pool: use generic AioContext infrastructure
+  block/io: take bs->reqs_lock in bdrv_mark_request_serialising
   io: add methods to set I/O handlers on AioContext
   io: make qio_channel_yield aware of AioContexts
   nbd: convert to use qio_channel_yield
   coroutine-lock: reschedule coroutine on the AioContext it was running
     on
   blkdebug: reschedule coroutine on the AioContext it is running on
   qed: introduce qed_aio_start_io and qed_aio_next_io_cb
   aio: push aio_context_acquire/release down to dispatching
   block: explicitly acquire aiocontext in timers that need it
   block: explicitly acquire aiocontext in callbacks that need it
   block: explicitly acquire aiocontext in bottom halves that need it
   block: explicitly acquire aiocontext in aio callbacks that need it
   aio-posix: partially inline aio_dispatch into aio_poll
   async: remove unnecessary inc/dec pairs
   block: document fields protected by AioContext lock
   coroutine-lock: make CoMutex thread-safe
   coroutine-lock: add limited spinning to CoMutex
   test-aio-multithread: add performance comparison with thread-based
     mutexes
   coroutine-lock: place CoMutex before CoQueue in header
   coroutine-lock: add mutex argument to CoQueue APIs
   coroutine-lock: make CoRwlock thread-safe and fair
- Makefile.objs                       |   4 -
+ MAINTAINERS                   |   9 +
- stubs/Makefile.objs                 |   1 +
+ block.c                       |  22 ++
- tests/Makefile.include              |  19 +-
+ block/Makefile.objs           |   3 +
- util/Makefile.objs                  |   6 +-
+ block/file-posix.c            |  99 ++++++--
- block/nbd-client.h                  |   2 +-
+ block/io.c                    | 162 +++++++------
- block/qed.h                         |   3 +
+ block/io_uring.c              | 433 ++++++++++++++++++++++++++++++++++
- include/block/aio.h                 |  38 ++-
+ block/trace-events            |  12 +
- include/block/block_int.h           |  64 +++--
+ blockdev.c                    |  12 +-
- include/io/channel.h                |  72 +++++-
+ configure                     |  27 +++
- include/qemu/coroutine.h            |  84 ++++---
+ docs/interop/qemu-nbd.rst     |   4 +-
- include/qemu/coroutine_int.h        |  11 +-
+ include/block/aio.h           |  16 +-
- include/sysemu/block-backend.h      |  14 +-
+ include/block/block.h         |  14 +-
- tests/iothread.h                    |  25 ++
+ include/block/block_int.h     |   3 +-
- block/backup.c                      |   2 +-
+ include/block/raw-aio.h       |  12 +
- block/blkdebug.c                    |   9 +-
+ qapi/block-core.json          |   4 +-
- block/blkreplay.c                   |   2 +-
+ qemu-img-cmds.hx              |   4 +-
- block/block-backend.c               |  13 +-
+ qemu-img.c                    |  11 +-
- block/curl.c                        |  44 +++-
+ qemu-img.texi                 |   5 +-
- block/gluster.c                     |   9 +-
+ qemu-io.c                     |  25 +-
- block/io.c                          |  42 +---
+ qemu-nbd.c                    |  12 +-
- block/iscsi.c                       |  15 +-
+ stubs/Makefile.objs           |   1 +
- block/linux-aio.c                   |  10 +-
+ stubs/io_uring.c              |  32 +++
- block/mirror.c                      |  12 +-
+ tests/qemu-iotests/028        |   2 +-
- block/nbd-client.c                  | 119 +++++----
+ tests/qemu-iotests/058        |   2 +-
- block/nfs.c                         |   9 +-
+ tests/qemu-iotests/089        |   4 +-
- block/qcow2-cluster.c               |   4 +-
+ tests/qemu-iotests/091        |   4 +-
- block/qed-cluster.c                 |   2 +
+ tests/qemu-iotests/109        |   2 +-
- block/qed-table.c                   |  12 +-
+ tests/qemu-iotests/147        |   5 +-
- block/qed.c                         |  58 +++--
+ tests/qemu-iotests/181        |   8 +-
- block/sheepdog.c                    |  31 +--
+ tests/qemu-iotests/183        |   4 +-
- block/ssh.c                         |  29 +--
+ tests/qemu-iotests/185        |  10 +-
- block/throttle-groups.c             |   4 +-
+ tests/qemu-iotests/200        |   2 +-
- block/win32-aio.c                   |   9 +-
+ tests/qemu-iotests/201        |   8 +-
- dma-helpers.c                       |   2 +
+ tests/qemu-iotests/check      |  15 +-
- hw/9pfs/9p.c                        |   2 +-
+ tests/qemu-iotests/common.rc  |  14 ++
- hw/block/virtio-blk.c               |  19 +-
+ tests/qemu-iotests/iotests.py |  12 +-
- hw/scsi/scsi-bus.c                  |   2 +
+ util/async.c                  |  36 +++
- hw/scsi/scsi-disk.c                 |  15 ++
+files changed, 878 insertions(+), 172 deletions(-)
- hw/scsi/scsi-generic.c              |  20 +-
+ create mode 100644 block/io_uring.c
- hw/scsi/virtio-scsi.c               |   6 +
+ create mode 100644 stubs/io_uring.c
  io/channel-command.c                |  13 +
  io/channel-file.c                   |  11 +
  io/channel-socket.c                 |  16 +-
  io/channel-tls.c                    |  12 +
  io/channel-watch.c                  |   6 +
  io/channel.c                        |  97 ++++++--
  nbd/client.c                        |   2 +-
  nbd/common.c                        |   9 +-
  nbd/server.c                        |  94 +++-----
  stubs/linux-aio.c                   |  32 +++
  stubs/set-fd-handler.c              |  11 -
  tests/iothread.c                    |  91 +++++++
  tests/test-aio-multithread.c        | 463 ++++++++++++++++++++++++++++++++++++
  tests/test-thread-pool.c            |  12 +-
  aio-posix.c => util/aio-posix.c     |  62 ++---
  aio-win32.c => util/aio-win32.c     |  30 +--
  util/aiocb.c                        |  55 +++++
  async.c => util/async.c             |  84 ++++++-
  iohandler.c => util/iohandler.c     |   0
  main-loop.c => util/main-loop.c     |   0
  util/qemu-coroutine-lock.c          | 254 ++++++++++++++++++--
  util/qemu-coroutine-sleep.c         |   2 +-
  util/qemu-coroutine.c               |   8 +
  qemu-timer.c => util/qemu-timer.c   |   0
  thread-pool.c => util/thread-pool.c |   8 +-
  trace-events                        |  11 -
  util/trace-events                   |  17 +-
 files changed, 1711 insertions(+), 533 deletions(-)
  create mode 100644 tests/iothread.h
  create mode 100644 stubs/linux-aio.c
  create mode 100644 tests/iothread.c
  create mode 100644 tests/test-aio-multithread.c
  rename aio-posix.c => util/aio-posix.c (94%)
  rename aio-win32.c => util/aio-win32.c (95%)
  create mode 100644 util/aiocb.c
  rename async.c => util/async.c (82%)
  rename iohandler.c => util/iohandler.c (100%)
  rename main-loop.c => util/main-loop.c (100%)
  rename qemu-timer.c => util/qemu-timer.c (100%)
  rename thread-pool.c => util/thread-pool.c (97%)
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 23/24] coroutine-lock: add mutex argument to CoQueue APIs
+[PULL 01/18] block: eliminate BDRV_REQ_NO_SERIALISING
 From: Paolo Bonzini <pbonzini@redhat.com>
-All that CoQueue needs in order to become thread-safe is help
+It is unused since commit 00e30f0 ("block/backup: use backup-top instead
-from an external mutex.  Add this to the API.
+of write notifiers", 2019-10-01), drop it to simplify the code.
 While at it, drop redundant assertions on flags.
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Message-id: 1578495356-46219-2-git-send-email-pbonzini@redhat.com
-Message-id: 20170213181244.16297-6-pbonzini@redhat.com
+Message-Id: <1578495356-46219-2-git-send-email-pbonzini@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/coroutine.h   |  8 +++++---
+ block/io.c            | 18 ++++--------------
- block/backup.c             |  2 +-
+ include/block/block.h | 12 ------------
- block/io.c                 |  4 ++--
+files changed, 4 insertions(+), 26 deletions(-)
  block/nbd-client.c         |  2 +-
  block/qcow2-cluster.c      |  4 +---
  block/sheepdog.c           |  2 +-
  block/throttle-groups.c    |  2 +-
  hw/9pfs/9p.c               |  2 +-
  util/qemu-coroutine-lock.c | 24 +++++++++++++++++++++---
 files changed, 34 insertions(+), 16 deletions(-)
-diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/coroutine.h
-+++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex);
- /**
-  * CoQueues are a mechanism to queue coroutines in order to continue executing
-- * them later.
-+ * them later.  They are similar to condition variables, but they need help
-+ * from an external mutex in order to maintain thread-safety.
-  */
- typedef struct CoQueue {
-     QSIMPLEQ_HEAD(, Coroutine) entries;
-@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_init(CoQueue *queue);
- /**
-  * Adds the current coroutine to the CoQueue and transfers control to the
-- * caller of the coroutine.
-+ * caller of the coroutine.  The mutex is unlocked during the wait and
-+ * locked again afterwards.
-  */
--void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
-+void coroutine_fn qemu_co_queue_wait(CoQueue *queue, CoMutex *mutex);
- /**
-  * Restarts the next coroutine in the CoQueue and removes it from the queue.
-diff --git a/block/backup.c b/block/backup.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/backup.c
-+++ b/block/backup.c
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job,
-         retry = false;
-         QLIST_FOREACH(req, &job->inflight_reqs, list) {
-             if (end > req->start && start < req->end) {
--                qemu_co_queue_wait(&req->wait_queue);
-+                qemu_co_queue_wait(&req->wait_queue, NULL);
-                 retry = true;
-                 break;
-             }
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
-                  * (instead of producing a deadlock in the former case). */
+      * potential fallback support, if we ever implement any read flags
-                 if (!req->waiting_for) {
+      * to pass through to drivers.  For now, there aren't any
-                     self->waiting_for = req;
+      * passthrough flags.  */
--                    qemu_co_queue_wait(&req->wait_queue);
+-    assert(!(flags & ~(BDRV_REQ_NO_SERIALISING | BDRV_REQ_COPY_ON_READ |
-+                    qemu_co_queue_wait(&req->wait_queue, NULL);
+-                       BDRV_REQ_PREFETCH)));
-                     self->waiting_for = NULL;
++    assert(!(flags & ~(BDRV_REQ_COPY_ON_READ | BDRV_REQ_PREFETCH)));
-                     retry = true;
-                     waited = true;
+     /* Handle Copy on Read and associated serialisation */
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
+     if (flags & BDRV_REQ_COPY_ON_READ) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
-     /* Wait until any previous flushes are completed */
+         bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
      while (bs->active_flush_req) {
 -        qemu_co_queue_wait(&bs->flush_queue);
 +        qemu_co_queue_wait(&bs->flush_queue, NULL);
      }
-     bs->active_flush_req = true;
+-    /* BDRV_REQ_SERIALISING is only for write operation */
-diff --git a/block/nbd-client.c b/block/nbd-client.c
+-    assert(!(flags & BDRV_REQ_SERIALISING));
 -
 -    if (!(flags & BDRV_REQ_NO_SERIALISING)) {
 -        bdrv_wait_serialising_requests(req);
 -    }
 +    bdrv_wait_serialising_requests(req);
      if (flags & BDRV_REQ_COPY_ON_READ) {
          int64_t pnum;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
      bdrv_inc_in_flight(bs);
      /* Don't do copy-on-read if we read data before write operation */
 -    if (atomic_read(&bs->copy_on_read) && !(flags & BDRV_REQ_NO_SERIALISING)) {
 +    if (atomic_read(&bs->copy_on_read)) {
          flags |= BDRV_REQ_COPY_ON_READ;
      }
@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_prepare(BdrvChild *child, int64_t offset, uint64_t bytes,
          return -EPERM;
      }
 -    /* BDRV_REQ_NO_SERIALISING is only for read operation */
 -    assert(!(flags & BDRV_REQ_NO_SERIALISING));
      assert(!(bs->open_flags & BDRV_O_INACTIVE));
      assert((bs->open_flags & BDRV_O_NO_IO) == 0);
      assert(!(flags & ~BDRV_REQ_MASK));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(
          /* BDRV_REQ_SERIALISING is only for write operation */
          assert(!(read_flags & BDRV_REQ_SERIALISING));
 -        if (!(read_flags & BDRV_REQ_NO_SERIALISING)) {
 -            bdrv_wait_serialising_requests(&req);
 -        }
 +        bdrv_wait_serialising_requests(&req);
          ret = src->bs->drv->bdrv_co_copy_range_from(src->bs,
                                                      src, src_offset,
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/nbd-client.c
+--- a/include/block/block.h
-+++ b/block/nbd-client.c
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ static void nbd_coroutine_start(NBDClientSession *s,
+@@ -XXX,XX +XXX,XX @@ typedef enum {
-     /* Poor man semaphore.  The free_sema is locked when no other request
+      */
-      * can be accepted, and unlocked after receiving one reply.  */
+     BDRV_REQ_MAY_UNMAP          = 0x4,
-     if (s->in_flight == MAX_NBD_REQUESTS) {
--        qemu_co_queue_wait(&s->free_sema);
+-    /*
-+        qemu_co_queue_wait(&s->free_sema, NULL);
+-     * The BDRV_REQ_NO_SERIALISING flag is only valid for reads and means that
-         assert(s->in_flight < MAX_NBD_REQUESTS);
+-     * we don't want wait_serialising_requests() during the read operation.
-     }
+-     *
-     s->in_flight++;
+-     * This flag is used for backup copy-on-write operations, when we need to
-diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+-     * read old data before write (write notifier triggered). It is okay since
-index XXXXXXX..XXXXXXX 100644
+-     * we already waited for other serializing requests in the initiating write
---- a/block/qcow2-cluster.c
+-     * (see bdrv_aligned_pwritev), and it is necessary if the initiating write
-+++ b/block/qcow2-cluster.c
+-     * is already serializing (without the flag, the read would deadlock
-@@ -XXX,XX +XXX,XX @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
+-     * waiting for the serialising write to complete).
-             if (bytes == 0) {
+-     */
-                 /* Wait for the dependency to complete. We need to recheck
+-    BDRV_REQ_NO_SERIALISING     = 0x8,
-                  * the free/allocated clusters when we continue. */
+     BDRV_REQ_FUA                = 0x10,
--                qemu_co_mutex_unlock(&s->lock);
+     BDRV_REQ_WRITE_COMPRESSED   = 0x20,
--                qemu_co_queue_wait(&old_alloc->dependent_requests);
 -                qemu_co_mutex_lock(&s->lock);
 +                qemu_co_queue_wait(&old_alloc->dependent_requests, &s->lock);
                  return -EAGAIN;
              }
          }
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static void wait_for_overlapping_aiocb(BDRVSheepdogState *s, SheepdogAIOCB *acb)
  retry:
      QLIST_FOREACH(cb, &s->inflight_aiocb_head, aiocb_siblings) {
          if (AIOCBOverlapping(acb, cb)) {
 -            qemu_co_queue_wait(&s->overlapping_queue);
 +            qemu_co_queue_wait(&s->overlapping_queue, NULL);
              goto retry;
          }
      }
 diff --git a/block/throttle-groups.c b/block/throttle-groups.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/throttle-groups.c
 +++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(BlockBackend *blk,
      if (must_wait || blkp->pending_reqs[is_write]) {
          blkp->pending_reqs[is_write]++;
          qemu_mutex_unlock(&tg->lock);
 -        qemu_co_queue_wait(&blkp->throttled_reqs[is_write]);
 +        qemu_co_queue_wait(&blkp->throttled_reqs[is_write], NULL);
          qemu_mutex_lock(&tg->lock);
          blkp->pending_reqs[is_write]--;
      }
 diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/9pfs/9p.c
 +++ b/hw/9pfs/9p.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn v9fs_flush(void *opaque)
          /*
           * Wait for pdu to complete.
           */
 -        qemu_co_queue_wait(&cancel_pdu->complete);
 +        qemu_co_queue_wait(&cancel_pdu->complete, NULL);
          cancel_pdu->cancelled = 0;
          pdu_free(cancel_pdu);
      }
 diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-lock.c
 +++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_init(CoQueue *queue)
      QSIMPLEQ_INIT(&queue->entries);
  }
 -void coroutine_fn qemu_co_queue_wait(CoQueue *queue)
 +void coroutine_fn qemu_co_queue_wait(CoQueue *queue, CoMutex *mutex)
  {
      Coroutine *self = qemu_coroutine_self();
      QSIMPLEQ_INSERT_TAIL(&queue->entries, self, co_queue_next);
 +
 +    if (mutex) {
 +        qemu_co_mutex_unlock(mutex);
 +    }
 +
 +    /* There is no race condition here.  Other threads will call
 +     * aio_co_schedule on our AioContext, which can reenter this
 +     * coroutine but only after this yield and after the main loop
 +     * has gone through the next iteration.
 +     */
      qemu_coroutine_yield();
      assert(qemu_in_coroutine());
 +
 +    /* TODO: OSv implements wait morphing here, where the wakeup
 +     * primitive automatically places the woken coroutine on the
 +     * mutex's queue.  This avoids the thundering herd effect.
 +     */
 +    if (mutex) {
 +        qemu_co_mutex_lock(mutex);
 +    }
  }
  /**
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_rdlock(CoRwlock *lock)
      Coroutine *self = qemu_coroutine_self();
      while (lock->writer) {
 -        qemu_co_queue_wait(&lock->queue);
 +        qemu_co_queue_wait(&lock->queue, NULL);
      }
      lock->reader++;
      self->locks_held++;
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_wrlock(CoRwlock *lock)
      Coroutine *self = qemu_coroutine_self();
      while (lock->writer || lock->reader) {
 -        qemu_co_queue_wait(&lock->queue);
 +        qemu_co_queue_wait(&lock->queue, NULL);
      }
      lock->writer = true;
      self->locks_held++;
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 15/24] block: explicitly acquire aiocontext in aio callbacks that need it
+[PULL 02/18] block/io: wait for serialising requests when a request becomes serialising
 From: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Marking without waiting would not result in actual serialising behavior.
 Thus, make a call bdrv_mark_request_serialising sufficient for
 serialisation to happen.
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Message-id: 1578495356-46219-3-git-send-email-pbonzini@redhat.com
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+Message-Id: <1578495356-46219-3-git-send-email-pbonzini@redhat.com>
 Message-id: 20170213135235.12274-16-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/archipelago.c    |  3 ---
+ block/file-posix.c        |  1 -
- block/block-backend.c  |  7 -------
+ block/io.c                | 40 +++++++++++++++++----------------------
- block/curl.c           |  2 +-
+ include/block/block_int.h |  3 +--
- block/io.c             |  6 +-----
+files changed, 18 insertions(+), 26 deletions(-)
  block/iscsi.c          |  3 ---
  block/linux-aio.c      |  5 +----
  block/mirror.c         | 12 +++++++++---
  block/null.c           |  8 --------
  block/qed-cluster.c    |  2 ++
  block/qed-table.c      | 12 ++++++++++--
  block/qed.c            |  4 ++--
  block/rbd.c            |  4 ----
  block/win32-aio.c      |  3 ---
  hw/block/virtio-blk.c  | 12 +++++++++++-
  hw/scsi/scsi-disk.c    | 15 +++++++++++++++
  hw/scsi/scsi-generic.c | 20 +++++++++++++++++---
  util/thread-pool.c     |  4 +++-
 files changed, 72 insertions(+), 50 deletions(-)
-diff --git a/block/archipelago.c b/block/archipelago.c
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/archipelago.c
+--- a/block/file-posix.c
-+++ b/block/archipelago.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
+@@ -XXX,XX +XXX,XX @@ raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
- {
+         req->overlap_bytes = req->bytes;
-     AIORequestData *reqdata = (AIORequestData *) opaque;
-     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
+         bdrv_mark_request_serialising(req, bs->bl.request_alignment);
--    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
+-        bdrv_wait_serialising_requests(req);
 -    aio_context_acquire(ctx);
      aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
 -    aio_context_release(ctx);
      aio_cb->status = 0;
      qemu_aio_unref(aio_cb);
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
  static void error_callback_bh(void *opaque)
  {
      struct BlockBackendAIOCB *acb = opaque;
 -    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
      bdrv_dec_in_flight(acb->common.bs);
 -    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, acb->ret);
 -    aio_context_release(ctx);
      qemu_aio_unref(acb);
  }
@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete(BlkAioEmAIOCB *acb)
  static void blk_aio_complete_bh(void *opaque)
  {
      BlkAioEmAIOCB *acb = opaque;
 -    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 -
      assert(acb->has_returned);
 -    aio_context_acquire(ctx);
      blk_aio_complete(acb);
 -    aio_context_release(ctx);
  }
  static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
 diff --git a/block/curl.c b/block/curl.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/curl.c
 +++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
      curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
  out:
 +    aio_context_release(ctx);
      if (ret != -EINPROGRESS) {
          acb->common.cb(acb->common.opaque, ret);
          qemu_aio_unref(acb);
      }
--    aio_context_release(ctx);
+ #endif
- }
  static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void bdrv_co_io_em_complete(void *opaque, int ret)
+@@ -XXX,XX +XXX,XX @@
-     CoroutineIOCompletion *co = opaque;
+ #define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
-     co->ret = ret;
+ static void bdrv_parent_cb_resize(BlockDriverState *bs);
--    qemu_coroutine_enter(co->coroutine);
++static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
-+    aio_co_wake(co->coroutine);
+ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
      int64_t offset, int bytes, BdrvRequestFlags flags);
@@ -XXX,XX +XXX,XX @@ static void tracked_request_begin(BdrvTrackedRequest *req,
      qemu_co_mutex_unlock(&bs->reqs_lock);
  }
- static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
+-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
-@@ -XXX,XX +XXX,XX @@ static void bdrv_co_complete(BlockAIOCBCoroutine *acb)
++bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
  static void bdrv_co_em_bh(void *opaque)
  {
-     BlockAIOCBCoroutine *acb = opaque;
+     int64_t overlap_offset = req->offset & ~(align - 1);
--    BlockDriverState *bs = acb->common.bs;
+     uint64_t overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
--    AioContext *ctx = bdrv_get_aio_context(bs);
+@@ -XXX,XX +XXX,XX @@ void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
-     assert(!acb->need_bh);
+     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
--    aio_context_acquire(ctx);
+     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
-     bdrv_co_complete(acb);
+-}
--    aio_context_release(ctx);
+-
 -static bool is_request_serialising_and_aligned(BdrvTrackedRequest *req)
 -{
 -    /*
 -     * If the request is serialising, overlap_offset and overlap_bytes are set,
 -     * so we can check if the request is aligned. Otherwise, don't care and
 -     * return false.
 -     */
 -
 -    return req->serialising && (req->offset == req->overlap_offset) &&
 -           (req->bytes == req->overlap_bytes);
 +    return bdrv_wait_serialising_requests(req);
  }
- static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine *acb)
+ /**
-diff --git a/block/iscsi.c b/block/iscsi.c
+@@ -XXX,XX +XXX,XX @@ void bdrv_dec_in_flight(BlockDriverState *bs)
      bdrv_wakeup(bs);
  }
 -bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
 +static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
  {
      BlockDriverState *bs = self->bs;
      BdrvTrackedRequest *req;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
           * it ensures that the CoR read and write operations are atomic and
           * guest writes cannot interleave between them. */
          bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
 +    } else {
 +        bdrv_wait_serialising_requests(req);
      }
 -    bdrv_wait_serialising_requests(req);
 -
      if (flags & BDRV_REQ_COPY_ON_READ) {
          int64_t pnum;
@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_prepare(BdrvChild *child, int64_t offset, uint64_t bytes,
      assert(!(flags & ~BDRV_REQ_MASK));
      if (flags & BDRV_REQ_SERIALISING) {
 -        bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
 +        waited = bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
 +        /*
 +         * For a misaligned request we should have already waited earlier,
 +         * because we come after bdrv_padding_rmw_read which must be called
 +         * with the request already marked as serialising.
 +         */
 +        assert(!waited ||
 +               (req->offset == req->overlap_offset &&
 +                req->bytes == req->overlap_bytes));
 +    } else {
 +        bdrv_wait_serialising_requests(req);
      }
 -    waited = bdrv_wait_serialising_requests(req);
 -
 -    assert(!waited || !req->serialising ||
 -           is_request_serialising_and_aligned(req));
      assert(req->overlap_offset <= offset);
      assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
      assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
      padding = bdrv_init_padding(bs, offset, bytes, &pad);
      if (padding) {
          bdrv_mark_request_serialising(req, align);
 -        bdrv_wait_serialising_requests(req);
          bdrv_padding_rmw_read(child, req, &pad, true);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
      if (bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad)) {
          bdrv_mark_request_serialising(&req, align);
 -        bdrv_wait_serialising_requests(&req);
          bdrv_padding_rmw_read(child, &req, &pad, false);
      }
 diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+--- a/include/block/block_int.h
-+++ b/block/iscsi.c
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@ static void
+@@ -XXX,XX +XXX,XX @@ extern unsigned int bdrv_drain_all_count;
- iscsi_bh_cb(void *p)
+ void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
- {
+ void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);
-     IscsiAIOCB *acb = p;
--    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
+-bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
+-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
-     qemu_bh_delete(acb->bh);
++bool coroutine_fn bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
+ BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs);
-     g_free(acb->buf);
-     acb->buf = NULL;
+ int get_tmp_filename(char *filename, int size);
 -    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, acb->status);
 -    aio_context_release(ctx);
      if (acb->task != NULL) {
          scsi_free_scsi_task(acb->task);
 diff --git a/block/linux-aio.c b/block/linux-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/linux-aio.c
 +++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ static inline ssize_t io_event_ret(struct io_event *ev)
   */
  static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
  {
 -    LinuxAioState *s = laiocb->ctx;
      int ret;
      ret = laiocb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
      }
      laiocb->ret = ret;
 -    aio_context_acquire(s->aio_context);
      if (laiocb->co) {
          /* If the coroutine is already entered it must be in ioq_submit() and
           * will notice laio->ret has been filled in when it eventually runs
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
           * that!
           */
          if (!qemu_coroutine_entered(laiocb->co)) {
 -            qemu_coroutine_enter(laiocb->co);
 +            aio_co_wake(laiocb->co);
          }
      } else {
          laiocb->common.cb(laiocb->common.opaque, ret);
          qemu_aio_unref(laiocb);
      }
 -    aio_context_release(s->aio_context);
  }
  /**
 diff --git a/block/mirror.c b/block/mirror.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/mirror.c
 +++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void mirror_write_complete(void *opaque, int ret)
  {
      MirrorOp *op = opaque;
      MirrorBlockJob *s = op->s;
 +
 +    aio_context_acquire(blk_get_aio_context(s->common.blk));
      if (ret < 0) {
          BlockErrorAction action;
@@ -XXX,XX +XXX,XX @@ static void mirror_write_complete(void *opaque, int ret)
          }
      }
      mirror_iteration_done(op, ret);
 +    aio_context_release(blk_get_aio_context(s->common.blk));
  }
  static void mirror_read_complete(void *opaque, int ret)
  {
      MirrorOp *op = opaque;
      MirrorBlockJob *s = op->s;
 +
 +    aio_context_acquire(blk_get_aio_context(s->common.blk));
      if (ret < 0) {
          BlockErrorAction action;
@@ -XXX,XX +XXX,XX @@ static void mirror_read_complete(void *opaque, int ret)
          }
          mirror_iteration_done(op, ret);
 -        return;
 +    } else {
 +        blk_aio_pwritev(s->target, op->sector_num * BDRV_SECTOR_SIZE, &op->qiov,
 +                        0, mirror_write_complete, op);
      }
 -    blk_aio_pwritev(s->target, op->sector_num * BDRV_SECTOR_SIZE, &op->qiov,
 -                    0, mirror_write_complete, op);
 +    aio_context_release(blk_get_aio_context(s->common.blk));
  }
  static inline void mirror_clip_sectors(MirrorBlockJob *s,
 diff --git a/block/null.c b/block/null.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/null.c
 +++ b/block/null.c
@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo null_aiocb_info = {
  static void null_bh_cb(void *opaque)
  {
      NullAIOCB *acb = opaque;
 -    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 -
 -    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, 0);
 -    aio_context_release(ctx);
      qemu_aio_unref(acb);
  }
  static void null_timer_cb(void *opaque)
  {
      NullAIOCB *acb = opaque;
 -    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 -
 -    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, 0);
 -    aio_context_release(ctx);
      timer_deinit(&acb->timer);
      qemu_aio_unref(acb);
  }
 diff --git a/block/qed-cluster.c b/block/qed-cluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed-cluster.c
 +++ b/block/qed-cluster.c
@@ -XXX,XX +XXX,XX @@ static void qed_find_cluster_cb(void *opaque, int ret)
      unsigned int index;
      unsigned int n;
 +    qed_acquire(s);
      if (ret) {
          goto out;
      }
@@ -XXX,XX +XXX,XX @@ static void qed_find_cluster_cb(void *opaque, int ret)
  out:
      find_cluster_cb->cb(find_cluster_cb->opaque, ret, offset, len);
 +    qed_release(s);
      g_free(find_cluster_cb);
  }
 diff --git a/block/qed-table.c b/block/qed-table.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed-table.c
 +++ b/block/qed-table.c
@@ -XXX,XX +XXX,XX @@ static void qed_read_table_cb(void *opaque, int ret)
  {
      QEDReadTableCB *read_table_cb = opaque;
      QEDTable *table = read_table_cb->table;
 +    BDRVQEDState *s = read_table_cb->s;
      int noffsets = read_table_cb->qiov.size / sizeof(uint64_t);
      int i;
@@ -XXX,XX +XXX,XX @@ static void qed_read_table_cb(void *opaque, int ret)
      }
      /* Byteswap offsets */
 +    qed_acquire(s);
      for (i = 0; i < noffsets; i++) {
          table->offsets[i] = le64_to_cpu(table->offsets[i]);
      }
 +    qed_release(s);
  out:
      /* Completion */
 -    trace_qed_read_table_cb(read_table_cb->s, read_table_cb->table, ret);
 +    trace_qed_read_table_cb(s, read_table_cb->table, ret);
      gencb_complete(&read_table_cb->gencb, ret);
  }
@@ -XXX,XX +XXX,XX @@ typedef struct {
  static void qed_write_table_cb(void *opaque, int ret)
  {
      QEDWriteTableCB *write_table_cb = opaque;
 +    BDRVQEDState *s = write_table_cb->s;
 -    trace_qed_write_table_cb(write_table_cb->s,
 +    trace_qed_write_table_cb(s,
                               write_table_cb->orig_table,
                               write_table_cb->flush,
                               ret);
@@ -XXX,XX +XXX,XX @@ static void qed_write_table_cb(void *opaque, int ret)
      if (write_table_cb->flush) {
          /* We still need to flush first */
          write_table_cb->flush = false;
 +        qed_acquire(s);
          bdrv_aio_flush(write_table_cb->s->bs, qed_write_table_cb,
                         write_table_cb);
 +        qed_release(s);
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void qed_read_l2_table_cb(void *opaque, int ret)
      CachedL2Table *l2_table = request->l2_table;
      uint64_t l2_offset = read_l2_table_cb->l2_offset;
 +    qed_acquire(s);
      if (ret) {
          /* can't trust loaded L2 table anymore */
          qed_unref_l2_cache_entry(l2_table);
@@ -XXX,XX +XXX,XX @@ static void qed_read_l2_table_cb(void *opaque, int ret)
          request->l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset);
          assert(request->l2_table != NULL);
      }
 +    qed_release(s);
      gencb_complete(&read_l2_table_cb->gencb, ret);
  }
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_is_allocated_cb(void *opaque, int ret, uint64_t offset, size_t l
      }
      if (cb->co) {
 -        qemu_coroutine_enter(cb->co);
 +        aio_co_wake(cb->co);
      }
  }
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qed_co_pwrite_zeroes_cb(void *opaque, int ret)
      cb->done = true;
      cb->ret = ret;
      if (cb->co) {
 -        qemu_coroutine_enter(cb->co);
 +        aio_co_wake(cb->co);
      }
  }
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ shutdown:
  static void qemu_rbd_complete_aio(RADOSCB *rcb)
  {
      RBDAIOCB *acb = rcb->acb;
 -    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
      int64_t r;
      r = rcb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_complete_aio(RADOSCB *rcb)
          qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
      }
      qemu_vfree(acb->bounce);
 -
 -    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret));
 -    aio_context_release(ctx);
      qemu_aio_unref(acb);
  }
 diff --git a/block/win32-aio.c b/block/win32-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/win32-aio.c
 +++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ static void win32_aio_process_completion(QEMUWin32AIOState *s,
          qemu_vfree(waiocb->buf);
      }
 -
 -    aio_context_acquire(s->aio_ctx);
      waiocb->common.cb(waiocb->common.opaque, ret);
 -    aio_context_release(s->aio_ctx);
      qemu_aio_unref(waiocb);
  }
 diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/virtio-blk.c
 +++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
  static void virtio_blk_rw_complete(void *opaque, int ret)
  {
      VirtIOBlockReq *next = opaque;
 +    VirtIOBlock *s = next->dev;
 +    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
      while (next) {
          VirtIOBlockReq *req = next;
          next = req->mr_next;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
          block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
          virtio_blk_free_request(req);
      }
 +    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
  }
  static void virtio_blk_flush_complete(void *opaque, int ret)
  {
      VirtIOBlockReq *req = opaque;
 +    VirtIOBlock *s = req->dev;
 +    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
      if (ret) {
          if (virtio_blk_handle_rw_error(req, -ret, 0)) {
 -            return;
 +            goto out;
          }
      }
      virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
      block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
      virtio_blk_free_request(req);
 +
 +out:
 +    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
  }
  #ifdef __linux__
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_ioctl_complete(void *opaque, int status)
      virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len);
  out:
 +    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
      virtio_blk_req_complete(req, status);
      virtio_blk_free_request(req);
 +    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
      g_free(ioctl_req);
  }
 diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/scsi-disk.c
 +++ b/hw/scsi/scsi-disk.c
@@ -XXX,XX +XXX,XX @@ static void scsi_aio_complete(void *opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (scsi_disk_req_check_error(r, ret, true)) {
          goto done;
      }
@@ -XXX,XX +XXX,XX @@ static void scsi_aio_complete(void *opaque, int ret)
      scsi_req_complete(&r->req, GOOD);
  done:
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
      scsi_req_unref(&r->req);
  }
@@ -XXX,XX +XXX,XX @@ static void scsi_dma_complete(void *opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (ret < 0) {
          block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
      } else {
          block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
      }
      scsi_dma_complete_noio(r, ret);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  static void scsi_read_complete(void * opaque, int ret)
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (scsi_disk_req_check_error(r, ret, true)) {
          goto done;
      }
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
  done:
      scsi_req_unref(&r->req);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  /* Actually issue a read to the block device.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_do_read_cb(void *opaque, int ret)
      assert (r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (ret < 0) {
          block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
      } else {
          block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
      }
      scsi_do_read(opaque, ret);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  /* Read more data from scsi device into buffer.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
      assert (r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (ret < 0) {
          block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
      } else {
          block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
      }
      scsi_write_complete_noio(r, ret);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  static void scsi_write_data(SCSIRequest *req)
@@ -XXX,XX +XXX,XX @@ static void scsi_unmap_complete(void *opaque, int ret)
  {
      UnmapCBData *data = opaque;
      SCSIDiskReq *r = data->r;
 +    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      scsi_unmap_complete_noio(data, ret);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf)
@@ -XXX,XX +XXX,XX @@ static void scsi_write_same_complete(void *opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
      if (scsi_disk_req_check_error(r, ret, true)) {
          goto done;
      }
@@ -XXX,XX +XXX,XX @@ done:
      scsi_req_unref(&r->req);
      qemu_vfree(data->iov.iov_base);
      g_free(data);
 +    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
  }
  static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf)
 diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/scsi-generic.c
 +++ b/hw/scsi/scsi-generic.c
@@ -XXX,XX +XXX,XX @@ done:
  static void scsi_command_complete(void *opaque, int ret)
  {
      SCSIGenericReq *r = (SCSIGenericReq *)opaque;
 +    SCSIDevice *s = r->req.dev;
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +
 +    aio_context_acquire(blk_get_aio_context(s->conf.blk));
      scsi_command_complete_noio(r, ret);
 +    aio_context_release(blk_get_aio_context(s->conf.blk));
  }
  static int execute_command(BlockBackend *blk,
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->conf.blk));
 +
      if (ret || r->req.io_canceled) {
          scsi_command_complete_noio(r, ret);
 -        return;
 +        goto done;
      }
      len = r->io_header.dxfer_len - r->io_header.resid;
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
      r->len = -1;
      if (len == 0) {
          scsi_command_complete_noio(r, 0);
 -        return;
 +        goto done;
      }
      /* Snoop READ CAPACITY output to set the blocksize.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
      }
      scsi_req_data(&r->req, len);
      scsi_req_unref(&r->req);
 +
 +done:
 +    aio_context_release(blk_get_aio_context(s->conf.blk));
  }
  /* Read more data from scsi device into buffer.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
      assert(r->req.aiocb != NULL);
      r->req.aiocb = NULL;
 +    aio_context_acquire(blk_get_aio_context(s->conf.blk));
 +
      if (ret || r->req.io_canceled) {
          scsi_command_complete_noio(r, ret);
 -        return;
 +        goto done;
      }
      if (r->req.cmd.buf[0] == MODE_SELECT && r->req.cmd.buf[4] == 12 &&
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
      }
      scsi_command_complete_noio(r, ret);
 +
 +done:
 +    aio_context_release(blk_get_aio_context(s->conf.blk));
  }
  /* Write data to a scsi device.  Returns nonzero on failure.
 diff --git a/util/thread-pool.c b/util/thread-pool.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/thread-pool.c
 +++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ restart:
               */
              qemu_bh_schedule(pool->completion_bh);
 +            aio_context_release(pool->ctx);
              elem->common.cb(elem->common.opaque, elem->ret);
 +            aio_context_acquire(pool->ctx);
              qemu_aio_unref(elem);
              goto restart;
          } else {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_co_cb(void *opaque, int ret)
      ThreadPoolCo *co = opaque;
      co->ret = ret;
 -    qemu_coroutine_enter(co->co);
 +    aio_co_wake(co->co);
  }
  int coroutine_fn thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func,
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 14/24] block: explicitly acquire aiocontext in bottom halves that need it
+[PULL 03/18] block/io: take bs->reqs_lock in bdrv_mark_request_serialising
 From: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+bdrv_mark_request_serialising is writing the overlap_offset and
 overlap_bytes fields of BdrvTrackedRequest.  Take bs->reqs_lock
 for the whole duration of it, and not just when waiting for
 serialising requests, so that tracked_request_overlaps does not
 look at a half-updated request.
 The new code does not unlock/relock around retries.  This is unnecessary
 because a retry is always preceded by a CoQueue wait, which already
 releases and reacquires bs->reqs_lock.
 Reported-by: Peter Lieven <pl@kamp.de>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Message-id: 1578495356-46219-4-git-send-email-pbonzini@redhat.com
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+Message-Id: <1578495356-46219-4-git-send-email-pbonzini@redhat.com>
 Message-id: 20170213135235.12274-15-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/archipelago.c   |  3 +++
+ block/io.c | 112 ++++++++++++++++++++++++++++++-----------------------
- block/blkreplay.c     |  2 +-
+file changed, 63 insertions(+), 49 deletions(-)
  block/block-backend.c |  6 ++++++
  block/curl.c          | 26 ++++++++++++++++++--------
  block/gluster.c       |  9 +--------
  block/io.c            |  6 +++++-
  block/iscsi.c         |  6 +++++-
  block/linux-aio.c     | 15 +++++++++------
  block/nfs.c           |  3 ++-
  block/null.c          |  4 ++++
  block/qed.c           |  3 +++
  block/rbd.c           |  4 ++++
  dma-helpers.c         |  2 ++
  hw/block/virtio-blk.c |  2 ++
  hw/scsi/scsi-bus.c    |  2 ++
  util/async.c          |  4 ++--
  util/thread-pool.c    |  2 ++
 files changed, 71 insertions(+), 28 deletions(-)
-diff --git a/block/archipelago.c b/block/archipelago.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/archipelago.c
-+++ b/block/archipelago.c
-@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
- {
-     AIORequestData *reqdata = (AIORequestData *) opaque;
-     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
-+    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
-+    aio_context_acquire(ctx);
-     aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
-+    aio_context_release(ctx);
-     aio_cb->status = 0;
-     qemu_aio_unref(aio_cb);
-diff --git a/block/blkreplay.c b/block/blkreplay.c
-index XXXXXXX..XXXXXXX 100755
---- a/block/blkreplay.c
-+++ b/block/blkreplay.c
-@@ -XXX,XX +XXX,XX @@ static int64_t blkreplay_getlength(BlockDriverState *bs)
- static void blkreplay_bh_cb(void *opaque)
- {
-     Request *req = opaque;
--    qemu_coroutine_enter(req->co);
-+    aio_co_wake(req->co);
-     qemu_bh_delete(req->bh);
-     g_free(req);
- }
-diff --git a/block/block-backend.c b/block/block-backend.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
-+++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
- static void error_callback_bh(void *opaque)
- {
-     struct BlockBackendAIOCB *acb = opaque;
-+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-     bdrv_dec_in_flight(acb->common.bs);
-+    aio_context_acquire(ctx);
-     acb->common.cb(acb->common.opaque, acb->ret);
-+    aio_context_release(ctx);
-     qemu_aio_unref(acb);
- }
-@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete(BlkAioEmAIOCB *acb)
- static void blk_aio_complete_bh(void *opaque)
- {
-     BlkAioEmAIOCB *acb = opaque;
-+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-     assert(acb->has_returned);
-+    aio_context_acquire(ctx);
-     blk_aio_complete(acb);
-+    aio_context_release(ctx);
- }
- static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
-diff --git a/block/curl.c b/block/curl.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/curl.c
-+++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
- {
-     CURLState *state;
-     int running;
-+    int ret = -EINPROGRESS;
-     CURLAIOCB *acb = p;
--    BDRVCURLState *s = acb->common.bs->opaque;
-+    BlockDriverState *bs = acb->common.bs;
-+    BDRVCURLState *s = bs->opaque;
-+    AioContext *ctx = bdrv_get_aio_context(bs);
-     size_t start = acb->sector_num * BDRV_SECTOR_SIZE;
-     size_t end;
-+    aio_context_acquire(ctx);
-+
-     // In case we have the requested data already (e.g. read-ahead),
-     // we can just call the callback and be done.
-     switch (curl_find_buf(s, start, acb->nb_sectors * BDRV_SECTOR_SIZE, acb)) {
-@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
-             qemu_aio_unref(acb);
-             // fall through
-         case FIND_RET_WAIT:
--            return;
-+            goto out;
-         default:
-             break;
-     }
-@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
-     // No cache found, so let's start a new request
-     state = curl_init_state(acb->common.bs, s);
-     if (!state) {
--        acb->common.cb(acb->common.opaque, -EIO);
--        qemu_aio_unref(acb);
--        return;
-+        ret = -EIO;
-+        goto out;
-     }
-     acb->start = 0;
-@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
-     state->orig_buf = g_try_malloc(state->buf_len);
-     if (state->buf_len && state->orig_buf == NULL) {
-         curl_clean_state(state);
--        acb->common.cb(acb->common.opaque, -ENOMEM);
--        qemu_aio_unref(acb);
--        return;
-+        ret = -ENOMEM;
-+        goto out;
-     }
-     state->acb[0] = acb;
-@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
-     /* Tell curl it needs to kick things off */
-     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
-+
-+out:
-+    if (ret != -EINPROGRESS) {
-+        acb->common.cb(acb->common.opaque, ret);
-+        qemu_aio_unref(acb);
-+    }
-+    aio_context_release(ctx);
- }
- static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
-diff --git a/block/gluster.c b/block/gluster.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/gluster.c
-+++ b/block/gluster.c
-@@ -XXX,XX +XXX,XX @@ static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
-     return qemu_gluster_glfs_init(gconf, errp);
- }
--static void qemu_gluster_complete_aio(void *opaque)
--{
--    GlusterAIOCB *acb = (GlusterAIOCB *)opaque;
--
--    qemu_coroutine_enter(acb->coroutine);
--}
--
- /*
-  * AIO callback routine called from GlusterFS thread.
-  */
-@@ -XXX,XX +XXX,XX @@ static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg)
-         acb->ret = -EIO; /* Partial read/write - fail it */
-     }
--    aio_bh_schedule_oneshot(acb->aio_context, qemu_gluster_complete_aio, acb);
-+    aio_co_schedule(acb->aio_context, acb->coroutine);
- }
- static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
+@@ -XXX,XX +XXX,XX @@
-     bdrv_dec_in_flight(bs);
+ #define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
-     bdrv_drained_begin(bs);
-     data->done = true;
+ static void bdrv_parent_cb_resize(BlockDriverState *bs);
--    qemu_coroutine_enter(co);
+-static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
-+    aio_co_wake(co);
+ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
      int64_t offset, int bytes, BdrvRequestFlags flags);
@@ -XXX,XX +XXX,XX @@ static void tracked_request_begin(BdrvTrackedRequest *req,
      qemu_co_mutex_unlock(&bs->reqs_lock);
  }
- static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)
++static bool tracked_request_overlaps(BdrvTrackedRequest *req,
-@@ -XXX,XX +XXX,XX @@ static void bdrv_co_complete(BlockAIOCBCoroutine *acb)
++                                     int64_t offset, uint64_t bytes)
- static void bdrv_co_em_bh(void *opaque)
++{
 +    /*        aaaa   bbbb */
 +    if (offset >= req->overlap_offset + req->overlap_bytes) {
 +        return false;
 +    }
 +    /* bbbb   aaaa        */
 +    if (req->overlap_offset >= offset + bytes) {
 +        return false;
 +    }
 +    return true;
 +}
 +
 +static bool coroutine_fn
 +bdrv_wait_serialising_requests_locked(BlockDriverState *bs,
 +                                      BdrvTrackedRequest *self)
 +{
 +    BdrvTrackedRequest *req;
 +    bool retry;
 +    bool waited = false;
 +
 +    do {
 +        retry = false;
 +        QLIST_FOREACH(req, &bs->tracked_requests, list) {
 +            if (req == self || (!req->serialising && !self->serialising)) {
 +                continue;
 +            }
 +            if (tracked_request_overlaps(req, self->overlap_offset,
 +                                         self->overlap_bytes))
 +            {
 +                /* Hitting this means there was a reentrant request, for
 +                 * example, a block driver issuing nested requests.  This must
 +                 * never happen since it means deadlock.
 +                 */
 +                assert(qemu_coroutine_self() != req->co);
 +
 +                /* If the request is already (indirectly) waiting for us, or
 +                 * will wait for us as soon as it wakes up, then just go on
 +                 * (instead of producing a deadlock in the former case). */
 +                if (!req->waiting_for) {
 +                    self->waiting_for = req;
 +                    qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);
 +                    self->waiting_for = NULL;
 +                    retry = true;
 +                    waited = true;
 +                    break;
 +                }
 +            }
 +        }
 +    } while (retry);
 +    return waited;
 +}
 +
  bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
  {
-     BlockAIOCBCoroutine *acb = opaque;
++    BlockDriverState *bs = req->bs;
-+    BlockDriverState *bs = acb->common.bs;
+     int64_t overlap_offset = req->offset & ~(align - 1);
-+    AioContext *ctx = bdrv_get_aio_context(bs);
+     uint64_t overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
+                                - overlap_offset;
-     assert(!acb->need_bh);
++    bool waited;
-+    aio_context_acquire(ctx);
-     bdrv_co_complete(acb);
++    qemu_co_mutex_lock(&bs->reqs_lock);
-+    aio_context_release(ctx);
+     if (!req->serialising) {
          atomic_inc(&req->bs->serialising_in_flight);
          req->serialising = true;
@@ -XXX,XX +XXX,XX @@ bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
      req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
      req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
 -    return bdrv_wait_serialising_requests(req);
 +    waited = bdrv_wait_serialising_requests_locked(bs, req);
 +    qemu_co_mutex_unlock(&bs->reqs_lock);
 +    return waited;
  }
- static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine *acb)
-diff --git a/block/iscsi.c b/block/iscsi.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
-+++ b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ static void
- iscsi_bh_cb(void *p)
- {
-     IscsiAIOCB *acb = p;
-+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-     qemu_bh_delete(acb->bh);
-     g_free(acb->buf);
-     acb->buf = NULL;
-+    aio_context_acquire(ctx);
-     acb->common.cb(acb->common.opaque, acb->status);
-+    aio_context_release(ctx);
-     if (acb->task != NULL) {
-         scsi_free_scsi_task(acb->task);
-@@ -XXX,XX +XXX,XX @@ iscsi_schedule_bh(IscsiAIOCB *acb)
- static void iscsi_co_generic_bh_cb(void *opaque)
- {
-     struct IscsiTask *iTask = opaque;
-+
-     iTask->complete = 1;
--    qemu_coroutine_enter(iTask->co);
-+    aio_co_wake(iTask->co);
- }
- static void iscsi_retry_timer_expired(void *opaque)
-diff --git a/block/linux-aio.c b/block/linux-aio.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/linux-aio.c
-+++ b/block/linux-aio.c
-@@ -XXX,XX +XXX,XX @@ struct LinuxAioState {
-     io_context_t ctx;
-     EventNotifier e;
--    /* io queue for submit at batch */
-+    /* io queue for submit at batch.  Protected by AioContext lock. */
-     LaioQueue io_q;
--    /* I/O completion processing */
-+    /* I/O completion processing.  Only runs in I/O thread.  */
-     QEMUBH *completion_bh;
-     int event_idx;
-     int event_max;
-@@ -XXX,XX +XXX,XX @@ static inline ssize_t io_event_ret(struct io_event *ev)
-  */
- static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
- {
-+    LinuxAioState *s = laiocb->ctx;
-     int ret;
-     ret = laiocb->ret;
-@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
-     }
-     laiocb->ret = ret;
-+    aio_context_acquire(s->aio_context);
-     if (laiocb->co) {
-         /* If the coroutine is already entered it must be in ioq_submit() and
-          * will notice laio->ret has been filled in when it eventually runs
-@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
-         laiocb->common.cb(laiocb->common.opaque, ret);
-         qemu_aio_unref(laiocb);
-     }
-+    aio_context_release(s->aio_context);
- }
  /**
-@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completions(LinuxAioState *s)
+@@ -XXX,XX +XXX,XX @@ static int bdrv_get_cluster_size(BlockDriverState *bs)
  static void qemu_laio_process_completions_and_submit(LinuxAioState *s)
  {
      qemu_laio_process_completions(s);
 +
 +    aio_context_acquire(s->aio_context);
      if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
          ioq_submit(s);
      }
 +    aio_context_release(s->aio_context);
  }
  static void qemu_laio_completion_bh(void *opaque)
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_completion_cb(EventNotifier *e)
      LinuxAioState *s = container_of(e, LinuxAioState, e);
      if (event_notifier_test_and_clear(&s->e)) {
 -        aio_context_acquire(s->aio_context);
          qemu_laio_process_completions_and_submit(s);
 -        aio_context_release(s->aio_context);
      }
  }
-@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
+-static bool tracked_request_overlaps(BdrvTrackedRequest *req,
 -                                     int64_t offset, uint64_t bytes)
 -{
 -    /*        aaaa   bbbb */
 -    if (offset >= req->overlap_offset + req->overlap_bytes) {
 -        return false;
 -    }
 -    /* bbbb   aaaa        */
 -    if (req->overlap_offset >= offset + bytes) {
 -        return false;
 -    }
 -    return true;
 -}
 -
  void bdrv_inc_in_flight(BlockDriverState *bs)
  {
      atomic_inc(&bs->in_flight);
@@ -XXX,XX +XXX,XX @@ void bdrv_dec_in_flight(BlockDriverState *bs)
  static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
  {
      BlockDriverState *bs = self->bs;
 -    BdrvTrackedRequest *req;
 -    bool retry;
      bool waited = false;
      if (!atomic_read(&bs->serialising_in_flight)) {
          return false;
      }
--    aio_context_acquire(s->aio_context);
+-    do {
-     qemu_laio_process_completions_and_submit(s);
+-        retry = false;
--    aio_context_release(s->aio_context);
+-        qemu_co_mutex_lock(&bs->reqs_lock);
-     return true;
+-        QLIST_FOREACH(req, &bs->tracked_requests, list) {
 -            if (req == self || (!req->serialising && !self->serialising)) {
 -                continue;
 -            }
 -            if (tracked_request_overlaps(req, self->overlap_offset,
 -                                         self->overlap_bytes))
 -            {
 -                /* Hitting this means there was a reentrant request, for
 -                 * example, a block driver issuing nested requests.  This must
 -                 * never happen since it means deadlock.
 -                 */
 -                assert(qemu_coroutine_self() != req->co);
 -
 -                /* If the request is already (indirectly) waiting for us, or
 -                 * will wait for us as soon as it wakes up, then just go on
 -                 * (instead of producing a deadlock in the former case). */
 -                if (!req->waiting_for) {
 -                    self->waiting_for = req;
 -                    qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);
 -                    self->waiting_for = NULL;
 -                    retry = true;
 -                    waited = true;
 -                    break;
 -                }
 -            }
 -        }
 -        qemu_co_mutex_unlock(&bs->reqs_lock);
 -    } while (retry);
 +    qemu_co_mutex_lock(&bs->reqs_lock);
 +    waited = bdrv_wait_serialising_requests_locked(bs, self);
 +    qemu_co_mutex_unlock(&bs->reqs_lock);
      return waited;
  }
-@@ -XXX,XX +XXX,XX @@ void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
- {
-     aio_set_event_notifier(old_context, &s->e, false, NULL, NULL);
-     qemu_bh_delete(s->completion_bh);
-+    s->aio_context = NULL;
- }
- void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
-diff --git a/block/nfs.c b/block/nfs.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/nfs.c
-+++ b/block/nfs.c
-@@ -XXX,XX +XXX,XX @@ static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
- static void nfs_co_generic_bh_cb(void *opaque)
- {
-     NFSRPC *task = opaque;
-+
-     task->complete = 1;
--    qemu_coroutine_enter(task->co);
-+    aio_co_wake(task->co);
- }
- static void
-diff --git a/block/null.c b/block/null.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/null.c
-+++ b/block/null.c
-@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo null_aiocb_info = {
- static void null_bh_cb(void *opaque)
- {
-     NullAIOCB *acb = opaque;
-+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-+
-+    aio_context_acquire(ctx);
-     acb->common.cb(acb->common.opaque, 0);
-+    aio_context_release(ctx);
-     qemu_aio_unref(acb);
- }
-diff --git a/block/qed.c b/block/qed.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/qed.c
-+++ b/block/qed.c
-@@ -XXX,XX +XXX,XX @@ static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,
- static void qed_aio_complete_bh(void *opaque)
- {
-     QEDAIOCB *acb = opaque;
-+    BDRVQEDState *s = acb_to_s(acb);
-     BlockCompletionFunc *cb = acb->common.cb;
-     void *user_opaque = acb->common.opaque;
-     int ret = acb->bh_ret;
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete_bh(void *opaque)
-     qemu_aio_unref(acb);
-     /* Invoke callback */
-+    qed_acquire(s);
-     cb(user_opaque, ret);
-+    qed_release(s);
- }
- static void qed_aio_complete(QEDAIOCB *acb, int ret)
-diff --git a/block/rbd.c b/block/rbd.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
-+++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ shutdown:
- static void qemu_rbd_complete_aio(RADOSCB *rcb)
- {
-     RBDAIOCB *acb = rcb->acb;
-+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-     int64_t r;
-     r = rcb->ret;
-@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_complete_aio(RADOSCB *rcb)
-         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
-     }
-     qemu_vfree(acb->bounce);
-+
-+    aio_context_acquire(ctx);
-     acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret));
-+    aio_context_release(ctx);
-     qemu_aio_unref(acb);
- }
-diff --git a/dma-helpers.c b/dma-helpers.c
-index XXXXXXX..XXXXXXX 100644
---- a/dma-helpers.c
-+++ b/dma-helpers.c
-@@ -XXX,XX +XXX,XX @@ static void dma_blk_cb(void *opaque, int ret)
-                                 QEMU_ALIGN_DOWN(dbs->iov.size, dbs->align));
-     }
-+    aio_context_acquire(dbs->ctx);
-     dbs->acb = dbs->io_func(dbs->offset, &dbs->iov,
-                             dma_blk_cb, dbs, dbs->io_func_opaque);
-+    aio_context_release(dbs->ctx);
-     assert(dbs->acb);
- }
-diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/block/virtio-blk.c
-+++ b/hw/block/virtio-blk.c
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_dma_restart_bh(void *opaque)
-     s->rq = NULL;
-+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
-     while (req) {
-         VirtIOBlockReq *next = req->next;
-         if (virtio_blk_handle_request(req, &mrb)) {
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_dma_restart_bh(void *opaque)
-     if (mrb.num_reqs) {
-         virtio_blk_submit_multireq(s->blk, &mrb);
-     }
-+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
- }
- static void virtio_blk_dma_restart_cb(void *opaque, int running,
-diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c
-index XXXXXXX..XXXXXXX 100644
---- a/hw/scsi/scsi-bus.c
-+++ b/hw/scsi/scsi-bus.c
-@@ -XXX,XX +XXX,XX @@ static void scsi_dma_restart_bh(void *opaque)
-     qemu_bh_delete(s->bh);
-     s->bh = NULL;
-+    aio_context_acquire(blk_get_aio_context(s->conf.blk));
-     QTAILQ_FOREACH_SAFE(req, &s->requests, next, next) {
-         scsi_req_ref(req);
-         if (req->retry) {
-@@ -XXX,XX +XXX,XX @@ static void scsi_dma_restart_bh(void *opaque)
-         }
-         scsi_req_unref(req);
-     }
-+    aio_context_release(blk_get_aio_context(s->conf.blk));
- }
- void scsi_req_retry(SCSIRequest *req)
-diff --git a/util/async.c b/util/async.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/async.c
-+++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
-                 ret = 1;
-             }
-             bh->idle = 0;
--            aio_context_acquire(ctx);
-             aio_bh_call(bh);
--            aio_context_release(ctx);
-         }
-         if (bh->deleted) {
-             deleted = true;
-@@ -XXX,XX +XXX,XX @@ static void co_schedule_bh_cb(void *opaque)
-         Coroutine *co = QSLIST_FIRST(&straight);
-         QSLIST_REMOVE_HEAD(&straight, co_scheduled_next);
-         trace_aio_co_schedule_bh_cb(ctx, co);
-+        aio_context_acquire(ctx);
-         qemu_coroutine_enter(co);
-+        aio_context_release(ctx);
-     }
- }
-diff --git a/util/thread-pool.c b/util/thread-pool.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/thread-pool.c
-+++ b/util/thread-pool.c
-@@ -XXX,XX +XXX,XX @@ static void thread_pool_completion_bh(void *opaque)
-     ThreadPool *pool = opaque;
-     ThreadPoolElement *elem, *next;
-+    aio_context_acquire(pool->ctx);
- restart:
-     QLIST_FOREACH_SAFE(elem, &pool->head, all, next) {
-         if (elem->state != THREAD_DONE) {
-@@ -XXX,XX +XXX,XX @@ restart:
-             qemu_aio_unref(elem);
-         }
-     }
-+    aio_context_release(pool->ctx);
- }
- static void thread_pool_cancel(BlockAIOCB *acb)
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 24/24] coroutine-lock: make CoRwlock thread-safe and fair
+[PULL 04/18] configure: permit use of io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This adds a CoMutex around the existing CoQueue.  Because the write-side
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-can just take CoMutex, the old "writer" field is not necessary anymore.
+Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
-Instead of removing it altogether, count the number of pending writers
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-during a read-side critical section and forbid further readers from
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-entering.
+Message-id: 20200120141858.587874-2-stefanha@redhat.com
+Message-Id: <20200120141858.587874-2-stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213181244.16297-7-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/coroutine.h   |  3 ++-
+ configure | 27 +++++++++++++++++++++++++++
- util/qemu-coroutine-lock.c | 35 ++++++++++++++++++++++++-----------
+file changed, 27 insertions(+)
 files changed, 26 insertions(+), 12 deletions(-)
-diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
+diff --git a/configure b/configure
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/include/qemu/coroutine.h
+--- a/configure
-+++ b/include/qemu/coroutine.h
++++ b/configure
-@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue);
+@@ -XXX,XX +XXX,XX @@ xen=""
+ xen_ctrl_version=""
+ xen_pci_passthrough=""
- typedef struct CoRwlock {
+ linux_aio=""
--    bool writer;
++linux_io_uring=""
-+    int pending_writer;
+ cap_ng=""
-     int reader;
+ attr=""
-+    CoMutex mutex;
+ libattr=""
-     CoQueue queue;
+@@ -XXX,XX +XXX,XX @@ for opt do
- } CoRwlock;
+   ;;
+   --enable-linux-aio) linux_aio="yes"
-diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
+   ;;
-index XXXXXXX..XXXXXXX 100644
++  --disable-linux-io-uring) linux_io_uring="no"
---- a/util/qemu-coroutine-lock.c
++  ;;
-+++ b/util/qemu-coroutine-lock.c
++  --enable-linux-io-uring) linux_io_uring="yes"
-@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_init(CoRwlock *lock)
++  ;;
- {
+   --disable-attr) attr="no"
-     memset(lock, 0, sizeof(*lock));
+   ;;
-     qemu_co_queue_init(&lock->queue);
+   --enable-attr) attr="yes"
-+    qemu_co_mutex_init(&lock->mutex);
+@@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available:
- }
+   vde             support for vde network
+   netmap          support for netmap network
- void qemu_co_rwlock_rdlock(CoRwlock *lock)
+   linux-aio       Linux AIO support
- {
++  linux-io-uring  Linux io_uring support
-     Coroutine *self = qemu_coroutine_self();
+   cap-ng          libcap-ng support
+   attr            attr and xattr support
--    while (lock->writer) {
+   vhost-net       vhost-net kernel acceleration support
--        qemu_co_queue_wait(&lock->queue, NULL);
+@@ -XXX,XX +XXX,XX @@ EOF
-+    qemu_co_mutex_lock(&lock->mutex);
+     linux_aio=no
-+    /* For fairness, wait if a writer is in line.  */
+   fi
-+    while (lock->pending_writer) {
+ fi
-+        qemu_co_queue_wait(&lock->queue, &lock->mutex);
++##########################################
-     }
++# linux-io-uring probe
      lock->reader++;
 +    qemu_co_mutex_unlock(&lock->mutex);
 +
-+    /* The rest of the read-side critical section is run without the mutex.  */
++if test "$linux_io_uring" != "no" ; then
-     self->locks_held++;
++  if $pkg_config liburing; then
- }
++    linux_io_uring_cflags=$($pkg_config --cflags liburing)
++    linux_io_uring_libs=$($pkg_config --libs liburing)
-@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_unlock(CoRwlock *lock)
++    linux_io_uring=yes
-     Coroutine *self = qemu_coroutine_self();
++  else
++    if test "$linux_io_uring" = "yes" ; then
-     assert(qemu_in_coroutine());
++      feature_not_found "linux io_uring" "Install liburing devel"
--    if (lock->writer) {
++    fi
--        lock->writer = false;
++    linux_io_uring=no
-+    if (!lock->reader) {
++  fi
-+        /* The critical section started in qemu_co_rwlock_wrlock.  */
++fi
-         qemu_co_queue_restart_all(&lock->queue);
-     } else {
+ ##########################################
-+        self->locks_held--;
+ # TPM emulation is only on POSIX
-+
+@@ -XXX,XX +XXX,XX @@ echo "PIE               $pie"
-+        qemu_co_mutex_lock(&lock->mutex);
+ echo "vde support       $vde"
-         lock->reader--;
+ echo "netmap support    $netmap"
-         assert(lock->reader >= 0);
+ echo "Linux AIO support $linux_aio"
-         /* Wakeup only one waiting writer */
++echo "Linux io_uring support $linux_io_uring"
-@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_unlock(CoRwlock *lock)
+ echo "ATTR/XATTR support $attr"
-             qemu_co_queue_next(&lock->queue);
+ echo "Install blobs     $blobs"
-         }
+ echo "KVM support       $kvm"
-     }
+@@ -XXX,XX +XXX,XX @@ fi
--    self->locks_held--;
+ if test "$linux_aio" = "yes" ; then
-+    qemu_co_mutex_unlock(&lock->mutex);
+   echo "CONFIG_LINUX_AIO=y" >> $config_host_mak
- }
+ fi
++if test "$linux_io_uring" = "yes" ; then
- void qemu_co_rwlock_wrlock(CoRwlock *lock)
++  echo "CONFIG_LINUX_IO_URING=y" >> $config_host_mak
- {
++  echo "LINUX_IO_URING_CFLAGS=$linux_io_uring_cflags" >> $config_host_mak
--    Coroutine *self = qemu_coroutine_self();
++  echo "LINUX_IO_URING_LIBS=$linux_io_uring_libs" >> $config_host_mak
--
++fi
--    while (lock->writer || lock->reader) {
+ if test "$attr" = "yes" ; then
--        qemu_co_queue_wait(&lock->queue, NULL);
+   echo "CONFIG_ATTR=y" >> $config_host_mak
-+    qemu_co_mutex_lock(&lock->mutex);
+ fi
 +    lock->pending_writer++;
 +    while (lock->reader) {
 +        qemu_co_queue_wait(&lock->queue, &lock->mutex);
      }
 -    lock->writer = true;
 -    self->locks_held++;
 +    lock->pending_writer--;
 +
 +    /* The rest of the write-side critical section is run with
 +     * the mutex taken, so that lock->reader remains zero.
 +     * There is no need to update self->locks_held.
 +     */
  }
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 22/24] coroutine-lock: place CoMutex before CoQueue in header
+[PULL 05/18] qapi/block-core: add option for io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This will avoid forward references in the next patch.  It is also
+Since io_uring is the actual name of the Linux API, we use it as enum
-more logical because CoQueue is not anymore the basic primitive.
+value even though the QAPI schema conventions would prefer io-uring.
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
-Message-id: 20170213181244.16297-5-pbonzini@redhat.com
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20200120141858.587874-3-stefanha@redhat.com
 Message-Id: <20200120141858.587874-3-stefanha@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/coroutine.h | 89 ++++++++++++++++++++++++------------------------
+ qapi/block-core.json | 4 +++-
-file changed, 44 insertions(+), 45 deletions(-)
+file changed, 3 insertions(+), 1 deletion(-)
-diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
+diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/coroutine.h
+--- a/qapi/block-core.json
-+++ b/include/qemu/coroutine.h
++++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@ bool qemu_in_coroutine(void);
+@@ -XXX,XX +XXX,XX @@
-  */
+ #
- bool qemu_coroutine_entered(Coroutine *co);
+ # @threads:     Use qemu's thread pool
+ # @native:      Use native AIO backend (only Linux and Windows)
--
++# @io_uring:    Use linux io_uring (since 5.0)
--/**
+ #
-- * CoQueues are a mechanism to queue coroutines in order to continue executing
+ # Since: 2.9
-- * them later. They provide the fundamental primitives on which coroutine locks
+ ##
-- * are built.
+ { 'enum': 'BlockdevAioOptions',
-- */
+-  'data': [ 'threads', 'native' ] }
--typedef struct CoQueue {
++  'data': [ 'threads', 'native',
--    QSIMPLEQ_HEAD(, Coroutine) entries;
++            { 'name': 'io_uring', 'if': 'defined(CONFIG_LINUX_IO_URING)' } ] }
--} CoQueue;
--
+ ##
--/**
+ # @BlockdevCacheOptions:
 - * Initialise a CoQueue. This must be called before any other operation is used
 - * on the CoQueue.
 - */
 -void qemu_co_queue_init(CoQueue *queue);
 -
 -/**
 - * Adds the current coroutine to the CoQueue and transfers control to the
 - * caller of the coroutine.
 - */
 -void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
 -
 -/**
 - * Restarts the next coroutine in the CoQueue and removes it from the queue.
 - *
 - * Returns true if a coroutine was restarted, false if the queue is empty.
 - */
 -bool coroutine_fn qemu_co_queue_next(CoQueue *queue);
 -
 -/**
 - * Restarts all coroutines in the CoQueue and leaves the queue empty.
 - */
 -void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue);
 -
 -/**
 - * Enter the next coroutine in the queue
 - */
 -bool qemu_co_enter_next(CoQueue *queue);
 -
 -/**
 - * Checks if the CoQueue is empty.
 - */
 -bool qemu_co_queue_empty(CoQueue *queue);
 -
 -
  /**
   * Provides a mutex that can be used to synchronise coroutines
   */
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex);
   */
  void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex);
 +
 +/**
 + * CoQueues are a mechanism to queue coroutines in order to continue executing
 + * them later.
 + */
 +typedef struct CoQueue {
 +    QSIMPLEQ_HEAD(, Coroutine) entries;
 +} CoQueue;
 +
 +/**
 + * Initialise a CoQueue. This must be called before any other operation is used
 + * on the CoQueue.
 + */
 +void qemu_co_queue_init(CoQueue *queue);
 +
 +/**
 + * Adds the current coroutine to the CoQueue and transfers control to the
 + * caller of the coroutine.
 + */
 +void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
 +
 +/**
 + * Restarts the next coroutine in the CoQueue and removes it from the queue.
 + *
 + * Returns true if a coroutine was restarted, false if the queue is empty.
 + */
 +bool coroutine_fn qemu_co_queue_next(CoQueue *queue);
 +
 +/**
 + * Restarts all coroutines in the CoQueue and leaves the queue empty.
 + */
 +void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue);
 +
 +/**
 + * Enter the next coroutine in the queue
 + */
 +bool qemu_co_enter_next(CoQueue *queue);
 +
 +/**
 + * Checks if the CoQueue is empty.
 + */
 +bool qemu_co_queue_empty(CoQueue *queue);
 +
 +
  typedef struct CoRwlock {
      bool writer;
      int reader;
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 16/24] aio-posix: partially inline aio_dispatch into aio_poll
+[PULL 06/18] block/block: add BDRV flag for io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This patch prepares for the removal of unnecessary lockcnt inc/dec pairs.
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-Extract the dispatching loop for file descriptor handlers into a new
+Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
-function aio_dispatch_handlers, and then inline aio_dispatch into
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-aio_poll.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200120141858.587874-4-stefanha@redhat.com
-aio_dispatch can now become void.
+Message-Id: <20200120141858.587874-4-stefanha@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
 Message-id: 20170213135235.12274-17-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/aio.h |  6 +-----
+ include/block/block.h | 1 +
- util/aio-posix.c    | 44 ++++++++++++++------------------------------
+file changed, 1 insertion(+)
  util/aio-win32.c    | 13 ++++---------
  util/async.c        |  2 +-
 files changed, 20 insertions(+), 45 deletions(-)
-diff --git a/include/block/aio.h b/include/block/aio.h
+diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/aio.h
+--- a/include/block/block.h
-+++ b/include/block/aio.h
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ bool aio_pending(AioContext *ctx);
+@@ -XXX,XX +XXX,XX @@ typedef struct HDGeometry {
- /* Dispatch any pending callbacks from the GSource attached to the AioContext.
+                                       ignoring the format layer */
-  *
+ #define BDRV_O_NO_IO       0x10000 /* don't initialize for I/O */
-  * This is used internally in the implementation of the GSource.
+ #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 */
-- * @dispatch_fds: true to process fds, false to skip them
-- *                (can be used as an optimization by callers that know there
+ #define BDRV_O_CACHE_MASK  (BDRV_O_NOCACHE | BDRV_O_NO_FLUSH)
 - *                are no fds ready)
   */
 -bool aio_dispatch(AioContext *ctx, bool dispatch_fds);
 +void aio_dispatch(AioContext *ctx);
  /* Progress in completing AIO work to occur.  This can issue new pending
   * aio as a result of executing I/O completion or bh callbacks.
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
      AioHandler *node, *tmp;
      bool progress = false;
 -    /*
 -     * We have to walk very carefully in case aio_set_fd_handler is
 -     * called while we're walking.
 -     */
 -    qemu_lockcnt_inc(&ctx->list_lock);
 -
      QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
          int revents;
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
          }
      }
 -    qemu_lockcnt_dec(&ctx->list_lock);
      return progress;
  }
 -/*
 - * Note that dispatch_fds == false has the side-effect of post-poning the
 - * freeing of deleted handlers.
 - */
 -bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
 +void aio_dispatch(AioContext *ctx)
  {
 -    bool progress;
 +    aio_bh_poll(ctx);
 -    /*
 -     * If there are callbacks left that have been queued, we need to call them.
 -     * Do not call select in this case, because it is possible that the caller
 -     * does not need a complete flush (as is the case for aio_poll loops).
 -     */
 -    progress = aio_bh_poll(ctx);
 +    qemu_lockcnt_inc(&ctx->list_lock);
 +    aio_dispatch_handlers(ctx);
 +    qemu_lockcnt_dec(&ctx->list_lock);
 -    if (dispatch_fds) {
 -        progress |= aio_dispatch_handlers(ctx);
 -    }
 -
 -    /* Run our timers */
 -    progress |= timerlistgroup_run_timers(&ctx->tlg);
 -
 -    return progress;
 +    timerlistgroup_run_timers(&ctx->tlg);
  }
  /* These thread-local variables are used only in a small part of aio_poll
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
      npfd = 0;
      qemu_lockcnt_dec(&ctx->list_lock);
 -    /* Run dispatch even if there were no readable fds to run timers */
 -    if (aio_dispatch(ctx, ret > 0)) {
 -        progress = true;
 +    progress |= aio_bh_poll(ctx);
 +
 +    if (ret > 0) {
 +        qemu_lockcnt_inc(&ctx->list_lock);
 +        progress |= aio_dispatch_handlers(ctx);
 +        qemu_lockcnt_dec(&ctx->list_lock);
      }
 +    progress |= timerlistgroup_run_timers(&ctx->tlg);
 +
      return progress;
  }
 diff --git a/util/aio-win32.c b/util/aio-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-win32.c
 +++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
      return progress;
  }
 -bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
 +void aio_dispatch(AioContext *ctx)
  {
 -    bool progress;
 -
 -    progress = aio_bh_poll(ctx);
 -    if (dispatch_fds) {
 -        progress |= aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
 -    }
 -    progress |= timerlistgroup_run_timers(&ctx->tlg);
 -    return progress;
 +    aio_bh_poll(ctx);
 +    aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
 +    timerlistgroup_run_timers(&ctx->tlg);
  }
  bool aio_poll(AioContext *ctx, bool blocking)
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_dispatch(GSource     *source,
      AioContext *ctx = (AioContext *) source;
      assert(callback == NULL);
 -    aio_dispatch(ctx, true);
 +    aio_dispatch(ctx);
      return true;
  }
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 19/24] coroutine-lock: make CoMutex thread-safe
+[PULL 07/18] block/io_uring: implements interfaces for io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This uses the lock-free mutex described in the paper '"Blocking without
+Aborts when sqe fails to be set as sqes cannot be returned to the
-Locking", or LFTHREADS: A lock-free thread library' by Gidenstam and
+ring. Adds slow path for short reads for older kernels
 Papatriantafilou.  The same technique is used in OSv, and in fact
 the code is essentially a conversion to C of OSv's code.
-[Added missing coroutine_fn in tests/test-aio-multithread.c.
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
---Stefan]
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-id: 20200120141858.587874-5-stefanha@redhat.com
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Message-Id: <20200120141858.587874-5-stefanha@redhat.com>
 Message-id: 20170213181244.16297-2-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/coroutine.h     |  17 ++++-
+ MAINTAINERS             |   8 +
- tests/test-aio-multithread.c |  86 ++++++++++++++++++++++++
+ block/Makefile.objs     |   3 +
- util/qemu-coroutine-lock.c   | 155 ++++++++++++++++++++++++++++++++++++++++---
+ block/io_uring.c        | 401 ++++++++++++++++++++++++++++++++++++++++
- util/trace-events            |   1 +
+ include/block/aio.h     |  16 +-
-files changed, 246 insertions(+), 13 deletions(-)
+ include/block/raw-aio.h |  12 ++
 files changed, 439 insertions(+), 1 deletion(-)
  create mode 100644 block/io_uring.c
-diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/coroutine.h
+--- a/MAINTAINERS
-+++ b/include/qemu/coroutine.h
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue);
+@@ -XXX,XX +XXX,XX @@ F: block/file-posix.c
- /**
+ F: block/file-win32.c
-  * Provides a mutex that can be used to synchronise coroutines
+ F: block/win32-aio.c
-  */
-+struct CoWaitRecord;
++Linux io_uring
- typedef struct CoMutex {
++M: Aarushi Mehta <mehta.aaru20@gmail.com>
--    bool locked;
++M: Julia Suvorova <jusual@redhat.com>
-+    /* Count of pending lockers; 0 for a free mutex, 1 for an
++M: Stefan Hajnoczi <stefanha@redhat.com>
-+     * uncontended mutex.
++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/Makefile.objs b/block/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/block/Makefile.objs
 +++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * 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"
 +
 +/* io_uring ring size */
 +#define MAX_ENTRIES 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().
 +     */
-+    unsigned locked;
++    int total_read;
-+
++    QEMUIOVector resubmit_qiov;
-+    /* A queue of waiters.  Elements are added atomically in front of
++} LuringAIOCB;
-+     * from_push.  to_pop is only populated, and popped from, by whoever
++
-+     * is in charge of the next wakeup.  This can be an unlocker or,
++typedef struct LuringQueue {
-+     * through the handoff protocol, a locker that is about to go to sleep.
++    int plugged;
 +    unsigned int in_queue;
 +    unsigned int in_flight;
 +    bool blocked;
 +    QSIMPLEQ_HEAD(, LuringAIOCB) submit_queue;
 +} 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;
 +
 +/**
 + * luring_resubmit:
 + *
 + * Resubmit a request by appending it to submit_queue.  The caller must ensure
 + * that ioq_submit() is called later so that submit_queue requests are started.
 + */
 +static void luring_resubmit(LuringState *s, LuringAIOCB *luringcb)
 +{
 +    QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, 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().
 + *
 + * 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.
 +     */
-+    QSLIST_HEAD(, CoWaitRecord) from_push, to_pop;
++    qemu_bh_schedule(s->completion_bh);
 +
-+    unsigned handoff, sequence;
++    while (io_uring_peek_cqe(&s->ring, &cqes) == 0) {
-+
++        LuringAIOCB *luringcb;
-     Coroutine *holder;
++        int ret;
--    CoQueue queue;
++
- } CoMutex;
++        if (!cqes) {
  /**
 diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-aio-multithread.c
 +++ b/tests/test-aio-multithread.c
@@ -XXX,XX +XXX,XX @@ static void test_multi_co_schedule_10(void)
      test_multi_co_schedule(10);
  }
 +/* CoMutex thread-safety.  */
 +
 +static uint32_t atomic_counter;
 +static uint32_t running;
 +static uint32_t counter;
 +static CoMutex comutex;
 +
 +static void coroutine_fn test_multi_co_mutex_entry(void *opaque)
 +{
 +    while (!atomic_mb_read(&now_stopping)) {
 +        qemu_co_mutex_lock(&comutex);
 +        counter++;
 +        qemu_co_mutex_unlock(&comutex);
 +
 +        /* Increase atomic_counter *after* releasing the mutex.  Otherwise
 +         * there is a chance (it happens about 1 in 3 runs) that the iothread
 +         * exits before the coroutine is woken up, causing a spurious
 +         * assertion failure.
 +         */
 +        atomic_inc(&atomic_counter);
 +    }
 +    atomic_dec(&running);
 +}
 +
 +static void test_multi_co_mutex(int threads, int seconds)
 +{
 +    int i;
 +
 +    qemu_co_mutex_init(&comutex);
 +    counter = 0;
 +    atomic_counter = 0;
 +    now_stopping = false;
 +
 +    create_aio_contexts();
 +    assert(threads <= NUM_CONTEXTS);
 +    running = threads;
 +    for (i = 0; i < threads; i++) {
 +        Coroutine *co1 = qemu_coroutine_create(test_multi_co_mutex_entry, NULL);
 +        aio_co_schedule(ctx[i], co1);
 +    }
 +
 +    g_usleep(seconds * 1000000);
 +
 +    atomic_mb_set(&now_stopping, true);
 +    while (running > 0) {
 +        g_usleep(100000);
 +    }
 +
 +    join_aio_contexts();
 +    g_test_message("%d iterations/second\n", counter / seconds);
 +    g_assert_cmpint(counter, ==, atomic_counter);
 +}
 +
 +/* Testing with NUM_CONTEXTS threads focuses on the queue.  The mutex however
 + * is too contended (and the threads spend too much time in aio_poll)
 + * to actually stress the handoff protocol.
 + */
 +static void test_multi_co_mutex_1(void)
 +{
 +    test_multi_co_mutex(NUM_CONTEXTS, 1);
 +}
 +
 +static void test_multi_co_mutex_10(void)
 +{
 +    test_multi_co_mutex(NUM_CONTEXTS, 10);
 +}
 +
 +/* Testing with fewer threads stresses the handoff protocol too.  Still, the
 + * case where the locker _can_ pick up a handoff is very rare, happening
 + * about 10 times in 1 million, so increase the runtime a bit compared to
 + * other "quick" testcases that only run for 1 second.
 + */
 +static void test_multi_co_mutex_2_3(void)
 +{
 +    test_multi_co_mutex(2, 3);
 +}
 +
 +static void test_multi_co_mutex_2_30(void)
 +{
 +    test_multi_co_mutex(2, 30);
 +}
 +
  /* End of tests.  */
  int main(int argc, char **argv)
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
      if (g_test_quick()) {
          g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
 +        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
 +        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
      } else {
          g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
 +        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
 +        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
      }
      return g_test_run();
  }
 diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-lock.c
 +++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
   * THE SOFTWARE.
 + *
 + * The lock-free mutex implementation is based on OSv
 + * (core/lfmutex.cc, include/lockfree/mutex.hh).
 + * Copyright (C) 2013 Cloudius Systems, Ltd.
   */
  #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue)
      return QSIMPLEQ_FIRST(&queue->entries) == NULL;
  }
 +/* The wait records are handled with a multiple-producer, single-consumer
 + * lock-free queue.  There cannot be two concurrent pop_waiter() calls
 + * because pop_waiter() can only be called while mutex->handoff is zero.
 + * This can happen in three cases:
 + * - in qemu_co_mutex_unlock, before the hand-off protocol has started.
 + *   In this case, qemu_co_mutex_lock will see mutex->handoff == 0 and
 + *   not take part in the handoff.
 + * - in qemu_co_mutex_lock, if it steals the hand-off responsibility from
 + *   qemu_co_mutex_unlock.  In this case, qemu_co_mutex_unlock will fail
 + *   the cmpxchg (it will see either 0 or the next sequence value) and
 + *   exit.  The next hand-off cannot begin until qemu_co_mutex_lock has
 + *   woken up someone.
 + * - in qemu_co_mutex_unlock, if it takes the hand-off token itself.
 + *   In this case another iteration starts with mutex->handoff == 0;
 + *   a concurrent qemu_co_mutex_lock will fail the cmpxchg, and
 + *   qemu_co_mutex_unlock will go back to case (1).
 + *
 + * The following functions manage this queue.
 + */
 +typedef struct CoWaitRecord {
 +    Coroutine *co;
 +    QSLIST_ENTRY(CoWaitRecord) next;
 +} CoWaitRecord;
 +
 +static void push_waiter(CoMutex *mutex, CoWaitRecord *w)
 +{
 +    w->co = qemu_coroutine_self();
 +    QSLIST_INSERT_HEAD_ATOMIC(&mutex->from_push, w, next);
 +}
 +
 +static void move_waiters(CoMutex *mutex)
 +{
 +    QSLIST_HEAD(, CoWaitRecord) reversed;
 +    QSLIST_MOVE_ATOMIC(&reversed, &mutex->from_push);
 +    while (!QSLIST_EMPTY(&reversed)) {
 +        CoWaitRecord *w = QSLIST_FIRST(&reversed);
 +        QSLIST_REMOVE_HEAD(&reversed, next);
 +        QSLIST_INSERT_HEAD(&mutex->to_pop, w, next);
 +    }
 +}
 +
 +static CoWaitRecord *pop_waiter(CoMutex *mutex)
 +{
 +    CoWaitRecord *w;
 +
 +    if (QSLIST_EMPTY(&mutex->to_pop)) {
 +        move_waiters(mutex);
 +        if (QSLIST_EMPTY(&mutex->to_pop)) {
 +            return NULL;
 +        }
 +    }
 +    w = QSLIST_FIRST(&mutex->to_pop);
 +    QSLIST_REMOVE_HEAD(&mutex->to_pop, next);
 +    return w;
 +}
 +
 +static bool has_waiters(CoMutex *mutex)
 +{
 +    return QSLIST_EMPTY(&mutex->to_pop) || QSLIST_EMPTY(&mutex->from_push);
 +}
 +
  void qemu_co_mutex_init(CoMutex *mutex)
  {
      memset(mutex, 0, sizeof(*mutex));
 -    qemu_co_queue_init(&mutex->queue);
  }
 -void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
 +static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
  {
      Coroutine *self = qemu_coroutine_self();
 +    CoWaitRecord w;
 +    unsigned old_handoff;
      trace_qemu_co_mutex_lock_entry(mutex, self);
 +    w.co = self;
 +    push_waiter(mutex, &w);
 -    while (mutex->locked) {
 -        qemu_co_queue_wait(&mutex->queue);
 +    /* This is the "Responsibility Hand-Off" protocol; a lock() picks from
 +     * a concurrent unlock() the responsibility of waking somebody up.
 +     */
 +    old_handoff = atomic_mb_read(&mutex->handoff);
 +    if (old_handoff &&
 +        has_waiters(mutex) &&
 +        atomic_cmpxchg(&mutex->handoff, old_handoff, 0) == old_handoff) {
 +        /* There can be no concurrent pops, because there can be only
 +         * one active handoff at a time.
 +         */
 +        CoWaitRecord *to_wake = pop_waiter(mutex);
 +        Coroutine *co = to_wake->co;
 +        if (co == self) {
 +            /* We got the lock ourselves!  */
 +            assert(to_wake == &w);
 +            return;
 +        }
 +
 +        aio_co_wake(co);
      }
 -    mutex->locked = true;
 -    mutex->holder = self;
 -    self->locks_held++;
 -
 +    qemu_coroutine_yield();
      trace_qemu_co_mutex_lock_return(mutex, self);
  }
 +void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
 +{
 +    Coroutine *self = qemu_coroutine_self();
 +
 +    if (atomic_fetch_inc(&mutex->locked) == 0) {
 +        /* Uncontended.  */
 +        trace_qemu_co_mutex_lock_uncontended(mutex, self);
 +    } else {
 +        qemu_co_mutex_lock_slowpath(mutex);
 +    }
 +    mutex->holder = self;
 +    self->locks_held++;
 +}
 +
  void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
  {
      Coroutine *self = qemu_coroutine_self();
      trace_qemu_co_mutex_unlock_entry(mutex, self);
 -    assert(mutex->locked == true);
 +    assert(mutex->locked);
      assert(mutex->holder == self);
      assert(qemu_in_coroutine());
 -    mutex->locked = false;
      mutex->holder = NULL;
      self->locks_held--;
 -    qemu_co_queue_next(&mutex->queue);
 +    if (atomic_fetch_dec(&mutex->locked) == 1) {
 +        /* No waiting qemu_co_mutex_lock().  Pfew, that was easy!  */
 +        return;
 +    }
 +
 +    for (;;) {
 +        CoWaitRecord *to_wake = pop_waiter(mutex);
 +        unsigned our_handoff;
 +
 +        if (to_wake) {
 +            Coroutine *co = to_wake->co;
 +            aio_co_wake(co);
 +            break;
 +        }
 +
-+        /* Some concurrent lock() is in progress (we know this because
++        luringcb = io_uring_cqe_get_data(cqes);
-+         * mutex->locked was >1) but it hasn't yet put itself on the wait
++        ret = cqes->res;
-+         * queue.  Pick a sequence number for the handoff protocol (not 0).
++        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 (++mutex->sequence == 0) {
++        if (!qemu_coroutine_entered(luringcb->co)) {
-+            mutex->sequence = 1;
++            aio_co_wake(luringcb->co);
 +        }
-+
++    }
-+        our_handoff = mutex->sequence;
++    qemu_bh_cancel(s->completion_bh);
-+        atomic_mb_set(&mutex->handoff, our_handoff);
++}
-+        if (!has_waiters(mutex)) {
++
-+            /* The concurrent lock has not added itself yet, so it
++static int ioq_submit(LuringState *s)
-+             * will be able to pick our handoff.
++{
-+             */
++    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.submit_queue, 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.submit_queue, 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;
-+        /* Try to do the handoff protocol ourselves; if somebody else has
++        s->io_q.in_queue  -= ret;
-+         * already taken it, however, we're done and they're responsible.
++    }
 +    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.
 +         */
-+        if (atomic_cmpxchg(&mutex->handoff, our_handoff, 0) != our_handoff) {
++        luring_process_completions(s);
-+            break;
++    }
-+        }
++    return ret;
-+    }
++}
++
-     trace_qemu_co_mutex_unlock_return(mutex, self);
++static void luring_process_completions_and_submit(LuringState *s)
- }
++{
-diff --git a/util/trace-events b/util/trace-events
++    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->submit_queue);
 +    io_q->plugged = 0;
 +    io_q->in_queue = 0;
 +    io_q->in_flight = 0;
 +    io_q->blocked = false;
 +}
 +
 +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, IORING_FSYNC_DATASYNC);
 +        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.submit_queue, 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_ENTRIES)) {
 +        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 = g_new0(LuringState, 1);
 +    struct io_uring *ring = &s->ring;
 +
 +    rc = io_uring_queue_init(MAX_ENTRIES, 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 XXXXXXX..XXXXXXX 100644
---- a/util/trace-events
+--- a/include/block/aio.h
-+++ b/util/trace-events
++++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ qemu_coroutine_terminate(void *co) "self %p"
+@@ -XXX,XX +XXX,XX @@ typedef void IOHandler(void *opaque);
+ struct Coroutine;
- # util/qemu-coroutine-lock.c
+ struct ThreadPool;
- qemu_co_queue_run_restart(void *co) "co %p"
+ struct LinuxAioState;
-+qemu_co_mutex_lock_uncontended(void *mutex, void *self) "mutex %p self %p"
++struct LuringState;
- qemu_co_mutex_lock_entry(void *mutex, void *self) "mutex %p self %p"
- qemu_co_mutex_lock_return(void *mutex, void *self) "mutex %p self %p"
+ struct AioContext {
- qemu_co_mutex_unlock_entry(void *mutex, void *self) "mutex %p self %p"
+     GSource source;
@@ -XXX,XX +XXX,XX @@ 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.
@@ -XXX,XX +XXX,XX @@ 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/raw-aio.h b/include/block/raw-aio.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/raw-aio.h
 +++ b/include/block/raw-aio.h
@@ -XXX,XX +XXX,XX @@ 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;
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 01/24] block: move AioContext, QEMUTimer, main-loop to libqemuutil
+[PULL 08/18] stubs: add stubs for io_uring interface
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-AioContext is fairly self contained, the only dependency is QEMUTimer but
+Follow linux-aio.o and stub out the block/io_uring.o APIs that will be
-that in turn doesn't need anything else.  So move them out of block-obj-y
+missing when a binary is linked with obj-util-y but without
-to avoid introducing a dependency from io/ to block-obj-y.
+block-util-y (e.g. vhost-user-gpu).
-main-loop and its dependency iohandler also need to be moved, because
+For example, the stubs are necessary so that a binary using util/async.o
-later in this series io/ will call iohandler_get_aio_context.
+from obj-util-y for qemu_bh_new() links successfully.  In this case
 block/io_uring.o from block-util-y isn't needed and we can avoid
 dragging in the block layer by linking the stubs instead.  The stub
 functions never get called.
-[Changed copyright "the QEMU team" to "other QEMU contributors" as
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-suggested by Daniel Berrange and agreed by Paolo.
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
---Stefan]
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200120141858.587874-6-stefanha@redhat.com
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-Id: <20200120141858.587874-6-stefanha@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213135235.12274-2-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- Makefile.objs                       |  4 ---
+ MAINTAINERS         |  1 +
- stubs/Makefile.objs                 |  1 +
+ stubs/Makefile.objs |  1 +
- tests/Makefile.include              | 11 ++++----
+ stubs/io_uring.c    | 32 ++++++++++++++++++++++++++++++++
- util/Makefile.objs                  |  6 +++-
+files changed, 34 insertions(+)
- block/io.c                          | 29 -------------------
+ create mode 100644 stubs/io_uring.c
  stubs/linux-aio.c                   | 32 +++++++++++++++++++++
  stubs/set-fd-handler.c              | 11 --------
  aio-posix.c => util/aio-posix.c     |  2 +-
  aio-win32.c => util/aio-win32.c     |  0
  util/aiocb.c                        | 55 +++++++++++++++++++++++++++++++++++++
  async.c => util/async.c             |  3 +-
  iohandler.c => util/iohandler.c     |  0
  main-loop.c => util/main-loop.c     |  0
  qemu-timer.c => util/qemu-timer.c   |  0
  thread-pool.c => util/thread-pool.c |  2 +-
  trace-events                        | 11 --------
  util/trace-events                   | 11 ++++++++
 files changed, 114 insertions(+), 64 deletions(-)
  create mode 100644 stubs/linux-aio.c
  rename aio-posix.c => util/aio-posix.c (99%)
  rename aio-win32.c => util/aio-win32.c (100%)
  create mode 100644 util/aiocb.c
  rename async.c => util/async.c (99%)
  rename iohandler.c => util/iohandler.c (100%)
  rename main-loop.c => util/main-loop.c (100%)
  rename qemu-timer.c => util/qemu-timer.c (100%)
  rename thread-pool.c => util/thread-pool.c (99%)
-diff --git a/Makefile.objs b/Makefile.objs
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/Makefile.objs
+--- a/MAINTAINERS
-+++ b/Makefile.objs
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ chardev-obj-y = chardev/
+@@ -XXX,XX +XXX,XX @@ M: Stefan Hajnoczi <stefanha@redhat.com>
- #######################################################################
+ L: qemu-block@nongnu.org
- # block-obj-y is code used by both qemu system emulation and qemu-img
+ S: Maintained
+ F: block/io_uring.c
--block-obj-y = async.o thread-pool.o
++F: stubs/io_uring.c
- block-obj-y += nbd/
- block-obj-y += block.o blockjob.o
+ qcow2
--block-obj-y += main-loop.o iohandler.o qemu-timer.o
+ M: Kevin Wolf <kwolf@redhat.com>
 -block-obj-$(CONFIG_POSIX) += aio-posix.o
 -block-obj-$(CONFIG_WIN32) += aio-win32.o
  block-obj-y += block/
  block-obj-y += qemu-io-cmds.o
  block-obj-$(CONFIG_REPLICATION) += replication.o
 diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/stubs/Makefile.objs
 +++ b/stubs/Makefile.objs
-@@ -XXX,XX +XXX,XX @@ stub-obj-y += get-vm-name.o
+@@ -XXX,XX +XXX,XX @@ stub-obj-y += iothread.o
  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_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 += monitor.o
+ stub-obj-y += change-state-handler.o
-diff --git a/tests/Makefile.include b/tests/Makefile.include
+diff --git a/stubs/io_uring.c b/stubs/io_uring.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/Makefile.include
 +++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ check-unit-y += tests/test-visitor-serialization$(EXESUF)
  check-unit-y += tests/test-iov$(EXESUF)
  gcov-files-test-iov-y = util/iov.c
  check-unit-y += tests/test-aio$(EXESUF)
 +gcov-files-test-aio-y = util/async.c util/qemu-timer.o
 +gcov-files-test-aio-$(CONFIG_WIN32) += util/aio-win32.c
 +gcov-files-test-aio-$(CONFIG_POSIX) += util/aio-posix.c
  check-unit-y += tests/test-throttle$(EXESUF)
  gcov-files-test-aio-$(CONFIG_WIN32) = aio-win32.c
  gcov-files-test-aio-$(CONFIG_POSIX) = aio-posix.c
@@ -XXX,XX +XXX,XX @@ tests/check-qjson$(EXESUF): tests/check-qjson.o $(test-util-obj-y)
  tests/check-qom-interface$(EXESUF): tests/check-qom-interface.o $(test-qom-obj-y)
  tests/check-qom-proplist$(EXESUF): tests/check-qom-proplist.o $(test-qom-obj-y)
 -tests/test-char$(EXESUF): tests/test-char.o qemu-timer.o \
 -    $(test-util-obj-y) $(qtest-obj-y) $(test-block-obj-y) $(chardev-obj-y)
 +tests/test-char$(EXESUF): tests/test-char.o $(test-util-obj-y) $(qtest-obj-y) $(test-io-obj-y) $(chardev-obj-y)
  tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
  tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
  tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
@@ -XXX,XX +XXX,XX @@ tests/test-vmstate$(EXESUF): tests/test-vmstate.o \
      migration/vmstate.o migration/qemu-file.o \
          migration/qemu-file-channel.o migration/qjson.o \
      $(test-io-obj-y)
 -tests/test-timed-average$(EXESUF): tests/test-timed-average.o qemu-timer.o \
 -    $(test-util-obj-y)
 +tests/test-timed-average$(EXESUF): tests/test-timed-average.o $(test-util-obj-y)
  tests/test-base64$(EXESUF): tests/test-base64.o \
      libqemuutil.a libqemustub.a
  tests/ptimer-test$(EXESUF): tests/ptimer-test.o tests/ptimer-test-stubs.o hw/core/ptimer.o libqemustub.a
@@ -XXX,XX +XXX,XX @@ tests/usb-hcd-ehci-test$(EXESUF): tests/usb-hcd-ehci-test.o $(libqos-usb-obj-y)
  tests/usb-hcd-xhci-test$(EXESUF): tests/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
  tests/pc-cpu-test$(EXESUF): tests/pc-cpu-test.o
  tests/postcopy-test$(EXESUF): tests/postcopy-test.o
 -tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o qemu-timer.o \
 +tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o $(test-util-obj-y) \
      $(qtest-obj-y) $(test-io-obj-y) $(libqos-virtio-obj-y) $(libqos-pc-obj-y) \
      $(chardev-obj-y)
  tests/qemu-iotests/socket_scm_helper$(EXESUF): tests/qemu-iotests/socket_scm_helper.o
 diff --git a/util/Makefile.objs b/util/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/util/Makefile.objs
 +++ b/util/Makefile.objs
@@ -XXX,XX +XXX,XX @@
  util-obj-y = osdep.o cutils.o unicode.o qemu-timer-common.o
  util-obj-y += bufferiszero.o
  util-obj-y += lockcnt.o
 +util-obj-y += aiocb.o async.o thread-pool.o qemu-timer.o
 +util-obj-y += main-loop.o iohandler.o
 +util-obj-$(CONFIG_POSIX) += aio-posix.o
  util-obj-$(CONFIG_POSIX) += compatfd.o
  util-obj-$(CONFIG_POSIX) += event_notifier-posix.o
  util-obj-$(CONFIG_POSIX) += mmap-alloc.o
  util-obj-$(CONFIG_POSIX) += oslib-posix.o
  util-obj-$(CONFIG_POSIX) += qemu-openpty.o
  util-obj-$(CONFIG_POSIX) += qemu-thread-posix.o
 -util-obj-$(CONFIG_WIN32) += event_notifier-win32.o
  util-obj-$(CONFIG_POSIX) += memfd.o
 +util-obj-$(CONFIG_WIN32) += aio-win32.o
 +util-obj-$(CONFIG_WIN32) += event_notifier-win32.o
  util-obj-$(CONFIG_WIN32) += oslib-win32.o
  util-obj-$(CONFIG_WIN32) += qemu-thread-win32.o
  util-obj-y += envlist.o path.o module.o
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
      return &acb->common;
  }
 -void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
 -                   BlockCompletionFunc *cb, void *opaque)
 -{
 -    BlockAIOCB *acb;
 -
 -    acb = g_malloc(aiocb_info->aiocb_size);
 -    acb->aiocb_info = aiocb_info;
 -    acb->bs = bs;
 -    acb->cb = cb;
 -    acb->opaque = opaque;
 -    acb->refcnt = 1;
 -    return acb;
 -}
 -
 -void qemu_aio_ref(void *p)
 -{
 -    BlockAIOCB *acb = p;
 -    acb->refcnt++;
 -}
 -
 -void qemu_aio_unref(void *p)
 -{
 -    BlockAIOCB *acb = p;
 -    assert(acb->refcnt > 0);
 -    if (--acb->refcnt == 0) {
 -        g_free(acb);
 -    }
 -}
 -
  /**************************************************************/
  /* Coroutine block device emulation */
 diff --git a/stubs/linux-aio.c b/stubs/linux-aio.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/stubs/linux-aio.c
++++ b/stubs/io_uring.c
 @@ -XXX,XX +XXX,XX @@
 +/*
-+ * Linux native AIO support.
++ * 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 laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
++void luring_detach_aio_context(LuringState *s, AioContext *old_context)
 +{
 +    abort();
 +}
 +
-+void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
++void luring_attach_aio_context(LuringState *s, AioContext *new_context)
 +{
 +    abort();
 +}
 +
-+LinuxAioState *laio_init(void)
++LuringState *luring_init(Error **errp)
 +{
 +    abort();
 +}
 +
-+void laio_cleanup(LinuxAioState *s)
++void luring_cleanup(LuringState *s)
 +{
 +    abort();
 +}
-diff --git a/stubs/set-fd-handler.c b/stubs/set-fd-handler.c
-index XXXXXXX..XXXXXXX 100644
---- a/stubs/set-fd-handler.c
-+++ b/stubs/set-fd-handler.c
-@@ -XXX,XX +XXX,XX @@ void qemu_set_fd_handler(int fd,
- {
-     abort();
- }
--
--void aio_set_fd_handler(AioContext *ctx,
--                        int fd,
--                        bool is_external,
--                        IOHandler *io_read,
--                        IOHandler *io_write,
--                        AioPollFn *io_poll,
--                        void *opaque)
--{
--    abort();
--}
-diff --git a/aio-posix.c b/util/aio-posix.c
-similarity index 99%
-rename from aio-posix.c
-rename to util/aio-posix.c
-index XXXXXXX..XXXXXXX 100644
---- a/aio-posix.c
-+++ b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/rcu_queue.h"
- #include "qemu/sockets.h"
- #include "qemu/cutils.h"
--#include "trace-root.h"
-+#include "trace.h"
- #ifdef CONFIG_EPOLL_CREATE1
- #include <sys/epoll.h>
- #endif
-diff --git a/aio-win32.c b/util/aio-win32.c
-similarity index 100%
-rename from aio-win32.c
-rename to util/aio-win32.c
-diff --git a/util/aiocb.c b/util/aiocb.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/util/aiocb.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * BlockAIOCB allocation
-+ *
-+ * Copyright (c) 2003-2017 Fabrice Bellard and other QEMU contributors
-+ *
-+ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * of this software and associated documentation files (the "Software"), to deal
-+ * in the Software without restriction, including without limitation the rights
-+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-+ * copies of the Software, and to permit persons to whom the Software is
-+ * furnished to do so, subject to the following conditions:
-+ *
-+ * The above copyright notice and this permission notice shall be included in
-+ * all copies or substantial portions of the Software.
-+ *
-+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
-+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-+ * THE SOFTWARE.
-+ */
-+
-+#include "qemu/osdep.h"
-+#include "block/aio.h"
-+
-+void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
-+                   BlockCompletionFunc *cb, void *opaque)
-+{
-+    BlockAIOCB *acb;
-+
-+    acb = g_malloc(aiocb_info->aiocb_size);
-+    acb->aiocb_info = aiocb_info;
-+    acb->bs = bs;
-+    acb->cb = cb;
-+    acb->opaque = opaque;
-+    acb->refcnt = 1;
-+    return acb;
-+}
-+
-+void qemu_aio_ref(void *p)
-+{
-+    BlockAIOCB *acb = p;
-+    acb->refcnt++;
-+}
-+
-+void qemu_aio_unref(void *p)
-+{
-+    BlockAIOCB *acb = p;
-+    assert(acb->refcnt > 0);
-+    if (--acb->refcnt == 0) {
-+        g_free(acb);
-+    }
-+}
-diff --git a/async.c b/util/async.c
-similarity index 99%
-rename from async.c
-rename to util/async.c
-index XXXXXXX..XXXXXXX 100644
---- a/async.c
-+++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@
- /*
-- * QEMU System Emulator
-+ * Data plane event loop
-  *
-  * Copyright (c) 2003-2008 Fabrice Bellard
-+ * Copyright (c) 2009-2017 QEMU contributors
-  *
-  * Permission is hereby granted, free of charge, to any person obtaining a copy
-  * of this software and associated documentation files (the "Software"), to deal
-diff --git a/iohandler.c b/util/iohandler.c
-similarity index 100%
-rename from iohandler.c
-rename to util/iohandler.c
-diff --git a/main-loop.c b/util/main-loop.c
-similarity index 100%
-rename from main-loop.c
-rename to util/main-loop.c
-diff --git a/qemu-timer.c b/util/qemu-timer.c
-similarity index 100%
-rename from qemu-timer.c
-rename to util/qemu-timer.c
-diff --git a/thread-pool.c b/util/thread-pool.c
-similarity index 99%
-rename from thread-pool.c
-rename to util/thread-pool.c
-index XXXXXXX..XXXXXXX 100644
---- a/thread-pool.c
-+++ b/util/thread-pool.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/queue.h"
- #include "qemu/thread.h"
- #include "qemu/coroutine.h"
--#include "trace-root.h"
-+#include "trace.h"
- #include "block/thread-pool.h"
- #include "qemu/main-loop.h"
-diff --git a/trace-events b/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/trace-events
-+++ b/trace-events
-@@ -XXX,XX +XXX,XX @@
- #
- # The <format-string> should be a sprintf()-compatible format string.
--# aio-posix.c
--run_poll_handlers_begin(void *ctx, int64_t max_ns) "ctx %p max_ns %"PRId64
--run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
--poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
--poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
--
--# thread-pool.c
--thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
--thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
--thread_pool_cancel(void *req, void *opaque) "req %p opaque %p"
--
- # ioport.c
- cpu_in(unsigned int addr, char size, unsigned int val) "addr %#x(%c) value %u"
- cpu_out(unsigned int addr, char size, unsigned int val) "addr %#x(%c) value %u"
-diff --git a/util/trace-events b/util/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/util/trace-events
-+++ b/util/trace-events
-@@ -XXX,XX +XXX,XX @@
- # See docs/tracing.txt for syntax documentation.
-+# util/aio-posix.c
-+run_poll_handlers_begin(void *ctx, int64_t max_ns) "ctx %p max_ns %"PRId64
-+run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
-+poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-+poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-+
-+# util/thread-pool.c
-+thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
-+thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
-+thread_pool_cancel(void *req, void *opaque) "req %p opaque %p"
-+
- # util/buffer.c
- buffer_resize(const char *buf, size_t olen, size_t len) "%s: old %zd, new %zd"
- buffer_move_empty(const char *buf, size_t len, const char *from) "%s: %zd bytes from %s"
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 02/24] aio: introduce aio_co_schedule and aio_co_wake
+[PULL 09/18] util/async: add aio interfaces for io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-aio_co_wake provides the infrastructure to start a coroutine on a "home"
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-AioContext.  It will be used by CoMutex and CoQueue, so that coroutines
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-don't jump from one context to another when they go to sleep on a
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-mutex or waitqueue.  However, it can also be used as a more efficient
+Message-id: 20200120141858.587874-7-stefanha@redhat.com
-alternative to one-shot bottom halves, and saves the effort of tracking
+Message-Id: <20200120141858.587874-7-stefanha@redhat.com>
 which AioContext a coroutine is running on.
 aio_co_schedule is the part of aio_co_wake that starts a coroutine
 on a remove AioContext, but it is also useful to implement e.g.
 bdrv_set_aio_context callbacks.
 The implementation of aio_co_schedule is based on a lock-free
 multiple-producer, single-consumer queue.  The multiple producers use
 cmpxchg to add to a LIFO stack.  The consumer (a per-AioContext bottom
 half) grabs all items added so far, inverts the list to make it FIFO,
 and goes through it one item at a time until it's empty.  The data
 structure was inspired by OSv, which uses it in the very code we'll
 "port" to QEMU for the thread-safe CoMutex.
 Most of the new code is really tests.
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213135235.12274-3-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/Makefile.include       |   8 +-
+ util/async.c | 36 ++++++++++++++++++++++++++++++++++++
- include/block/aio.h          |  32 +++++++
+file changed, 36 insertions(+)
  include/qemu/coroutine_int.h |  11 ++-
  tests/iothread.h             |  25 +++++
  tests/iothread.c             |  91 ++++++++++++++++++
  tests/test-aio-multithread.c | 213 +++++++++++++++++++++++++++++++++++++++++++
  util/async.c                 |  65 +++++++++++++
  util/qemu-coroutine.c        |   8 ++
  util/trace-events            |   4 +
 files changed, 453 insertions(+), 4 deletions(-)
  create mode 100644 tests/iothread.h
  create mode 100644 tests/iothread.c
  create mode 100644 tests/test-aio-multithread.c
-diff --git a/tests/Makefile.include b/tests/Makefile.include
-index XXXXXXX..XXXXXXX 100644
---- a/tests/Makefile.include
-+++ b/tests/Makefile.include
-@@ -XXX,XX +XXX,XX @@ check-unit-y += tests/test-aio$(EXESUF)
- gcov-files-test-aio-y = util/async.c util/qemu-timer.o
- gcov-files-test-aio-$(CONFIG_WIN32) += util/aio-win32.c
- gcov-files-test-aio-$(CONFIG_POSIX) += util/aio-posix.c
-+check-unit-y += tests/test-aio-multithread$(EXESUF)
-+gcov-files-test-aio-multithread-y = $(gcov-files-test-aio-y)
-+gcov-files-test-aio-multithread-y += util/qemu-coroutine.c tests/iothread.c
- check-unit-y += tests/test-throttle$(EXESUF)
--gcov-files-test-aio-$(CONFIG_WIN32) = aio-win32.c
--gcov-files-test-aio-$(CONFIG_POSIX) = aio-posix.c
- check-unit-y += tests/test-thread-pool$(EXESUF)
- gcov-files-test-thread-pool-y = thread-pool.c
- gcov-files-test-hbitmap-y = util/hbitmap.c
-@@ -XXX,XX +XXX,XX @@ test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o \
-     $(test-qom-obj-y)
- test-crypto-obj-y = $(crypto-obj-y) $(test-qom-obj-y)
- test-io-obj-y = $(io-obj-y) $(test-crypto-obj-y)
--test-block-obj-y = $(block-obj-y) $(test-io-obj-y)
-+test-block-obj-y = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
- tests/check-qint$(EXESUF): tests/check-qint.o $(test-util-obj-y)
- tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
-@@ -XXX,XX +XXX,XX @@ tests/check-qom-proplist$(EXESUF): tests/check-qom-proplist.o $(test-qom-obj-y)
- tests/test-char$(EXESUF): tests/test-char.o $(test-util-obj-y) $(qtest-obj-y) $(test-io-obj-y) $(chardev-obj-y)
- tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
- tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
-+tests/test-aio-multithread$(EXESUF): tests/test-aio-multithread.o $(test-block-obj-y)
- tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
- tests/test-blockjob$(EXESUF): tests/test-blockjob.o $(test-block-obj-y) $(test-util-obj-y)
- tests/test-blockjob-txn$(EXESUF): tests/test-blockjob-txn.o $(test-block-obj-y) $(test-util-obj-y)
-diff --git a/include/block/aio.h b/include/block/aio.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/aio.h
-+++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ typedef void QEMUBHFunc(void *opaque);
- typedef bool AioPollFn(void *opaque);
- typedef void IOHandler(void *opaque);
-+struct Coroutine;
- struct ThreadPool;
- struct LinuxAioState;
-@@ -XXX,XX +XXX,XX @@ struct AioContext {
-     bool notified;
-     EventNotifier notifier;
-+    QSLIST_HEAD(, Coroutine) scheduled_coroutines;
-+    QEMUBH *co_schedule_bh;
-+
-     /* Thread pool for performing work and receiving completion callbacks.
-      * Has its own locking.
-      */
-@@ -XXX,XX +XXX,XX @@ static inline bool aio_node_check(AioContext *ctx, bool is_external)
- }
- /**
-+ * aio_co_schedule:
-+ * @ctx: the aio context
-+ * @co: the coroutine
-+ *
-+ * Start a coroutine on a remote AioContext.
-+ *
-+ * The coroutine must not be entered by anyone else while aio_co_schedule()
-+ * is active.  In addition the coroutine must have yielded unless ctx
-+ * is the context in which the coroutine is running (i.e. the value of
-+ * qemu_get_current_aio_context() from the coroutine itself).
-+ */
-+void aio_co_schedule(AioContext *ctx, struct Coroutine *co);
-+
-+/**
-+ * aio_co_wake:
-+ * @co: the coroutine
-+ *
-+ * Restart a coroutine on the AioContext where it was running last, thus
-+ * preventing coroutines from jumping from one context to another when they
-+ * go to sleep.
-+ *
-+ * aio_co_wake may be executed either in coroutine or non-coroutine
-+ * context.  The coroutine must not be entered by anyone else while
-+ * aio_co_wake() is active.
-+ */
-+void aio_co_wake(struct Coroutine *co);
-+
-+/**
-  * Return the AioContext whose event loop runs in the current thread.
-  *
-  * If called from an IOThread this will be the IOThread's AioContext.  If
-diff --git a/include/qemu/coroutine_int.h b/include/qemu/coroutine_int.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/coroutine_int.h
-+++ b/include/qemu/coroutine_int.h
-@@ -XXX,XX +XXX,XX @@ struct Coroutine {
-     CoroutineEntry *entry;
-     void *entry_arg;
-     Coroutine *caller;
-+
-+    /* Only used when the coroutine has terminated.  */
-     QSLIST_ENTRY(Coroutine) pool_next;
-+
-     size_t locks_held;
--    /* Coroutines that should be woken up when we yield or terminate */
-+    /* Coroutines that should be woken up when we yield or terminate.
-+     * Only used when the coroutine is running.
-+     */
-     QSIMPLEQ_HEAD(, Coroutine) co_queue_wakeup;
-+
-+    /* Only used when the coroutine has yielded.  */
-+    AioContext *ctx;
-     QSIMPLEQ_ENTRY(Coroutine) co_queue_next;
-+    QSLIST_ENTRY(Coroutine) co_scheduled_next;
- };
- Coroutine *qemu_coroutine_new(void);
-diff --git a/tests/iothread.h b/tests/iothread.h
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/iothread.h
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * Event loop thread implementation for unit tests
-+ *
-+ * Copyright Red Hat Inc., 2013, 2016
-+ *
-+ * Authors:
-+ *  Stefan Hajnoczi   <stefanha@redhat.com>
-+ *  Paolo Bonzini     <pbonzini@redhat.com>
-+ *
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
-+ * See the COPYING file in the top-level directory.
-+ */
-+#ifndef TEST_IOTHREAD_H
-+#define TEST_IOTHREAD_H
-+
-+#include "block/aio.h"
-+#include "qemu/thread.h"
-+
-+typedef struct IOThread IOThread;
-+
-+IOThread *iothread_new(void);
-+void iothread_join(IOThread *iothread);
-+AioContext *iothread_get_aio_context(IOThread *iothread);
-+
-+#endif
-diff --git a/tests/iothread.c b/tests/iothread.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/iothread.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * Event loop thread implementation for unit tests
-+ *
-+ * Copyright Red Hat Inc., 2013, 2016
-+ *
-+ * Authors:
-+ *  Stefan Hajnoczi   <stefanha@redhat.com>
-+ *  Paolo Bonzini     <pbonzini@redhat.com>
-+ *
-+ * 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 "qapi/error.h"
-+#include "block/aio.h"
-+#include "qemu/main-loop.h"
-+#include "qemu/rcu.h"
-+#include "iothread.h"
-+
-+struct IOThread {
-+    AioContext *ctx;
-+
-+    QemuThread thread;
-+    QemuMutex init_done_lock;
-+    QemuCond init_done_cond;    /* is thread initialization done? */
-+    bool stopping;
-+};
-+
-+static __thread IOThread *my_iothread;
-+
-+AioContext *qemu_get_current_aio_context(void)
-+{
-+    return my_iothread ? my_iothread->ctx : qemu_get_aio_context();
-+}
-+
-+static void *iothread_run(void *opaque)
-+{
-+    IOThread *iothread = opaque;
-+
-+    rcu_register_thread();
-+
-+    my_iothread = iothread;
-+    qemu_mutex_lock(&iothread->init_done_lock);
-+    iothread->ctx = aio_context_new(&error_abort);
-+    qemu_cond_signal(&iothread->init_done_cond);
-+    qemu_mutex_unlock(&iothread->init_done_lock);
-+
-+    while (!atomic_read(&iothread->stopping)) {
-+        aio_poll(iothread->ctx, true);
-+    }
-+
-+    rcu_unregister_thread();
-+    return NULL;
-+}
-+
-+void iothread_join(IOThread *iothread)
-+{
-+    iothread->stopping = true;
-+    aio_notify(iothread->ctx);
-+    qemu_thread_join(&iothread->thread);
-+    qemu_cond_destroy(&iothread->init_done_cond);
-+    qemu_mutex_destroy(&iothread->init_done_lock);
-+    aio_context_unref(iothread->ctx);
-+    g_free(iothread);
-+}
-+
-+IOThread *iothread_new(void)
-+{
-+    IOThread *iothread = g_new0(IOThread, 1);
-+
-+    qemu_mutex_init(&iothread->init_done_lock);
-+    qemu_cond_init(&iothread->init_done_cond);
-+    qemu_thread_create(&iothread->thread, NULL, iothread_run,
-+                       iothread, QEMU_THREAD_JOINABLE);
-+
-+    /* Wait for initialization to complete */
-+    qemu_mutex_lock(&iothread->init_done_lock);
-+    while (iothread->ctx == NULL) {
-+        qemu_cond_wait(&iothread->init_done_cond,
-+                       &iothread->init_done_lock);
-+    }
-+    qemu_mutex_unlock(&iothread->init_done_lock);
-+    return iothread;
-+}
-+
-+AioContext *iothread_get_aio_context(IOThread *iothread)
-+{
-+    return iothread->ctx;
-+}
-diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/test-aio-multithread.c
-@@ -XXX,XX +XXX,XX @@
-+/*
-+ * AioContext multithreading tests
-+ *
-+ * Copyright Red Hat, Inc. 2016
-+ *
-+ * Authors:
-+ *  Paolo Bonzini    <pbonzini@redhat.com>
-+ *
-+ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
-+ * See the COPYING.LIB file in the top-level directory.
-+ */
-+
-+#include "qemu/osdep.h"
-+#include <glib.h>
-+#include "block/aio.h"
-+#include "qapi/error.h"
-+#include "qemu/coroutine.h"
-+#include "qemu/thread.h"
-+#include "qemu/error-report.h"
-+#include "iothread.h"
-+
-+/* AioContext management */
-+
-+#define NUM_CONTEXTS 5
-+
-+static IOThread *threads[NUM_CONTEXTS];
-+static AioContext *ctx[NUM_CONTEXTS];
-+static __thread int id = -1;
-+
-+static QemuEvent done_event;
-+
-+/* Run a function synchronously on a remote iothread. */
-+
-+typedef struct CtxRunData {
-+    QEMUBHFunc *cb;
-+    void *arg;
-+} CtxRunData;
-+
-+static void ctx_run_bh_cb(void *opaque)
-+{
-+    CtxRunData *data = opaque;
-+
-+    data->cb(data->arg);
-+    qemu_event_set(&done_event);
-+}
-+
-+static void ctx_run(int i, QEMUBHFunc *cb, void *opaque)
-+{
-+    CtxRunData data = {
-+        .cb = cb,
-+        .arg = opaque
-+    };
-+
-+    qemu_event_reset(&done_event);
-+    aio_bh_schedule_oneshot(ctx[i], ctx_run_bh_cb, &data);
-+    qemu_event_wait(&done_event);
-+}
-+
-+/* Starting the iothreads. */
-+
-+static void set_id_cb(void *opaque)
-+{
-+    int *i = opaque;
-+
-+    id = *i;
-+}
-+
-+static void create_aio_contexts(void)
-+{
-+    int i;
-+
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        threads[i] = iothread_new();
-+        ctx[i] = iothread_get_aio_context(threads[i]);
-+    }
-+
-+    qemu_event_init(&done_event, false);
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        ctx_run(i, set_id_cb, &i);
-+    }
-+}
-+
-+/* Stopping the iothreads. */
-+
-+static void join_aio_contexts(void)
-+{
-+    int i;
-+
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        aio_context_ref(ctx[i]);
-+    }
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        iothread_join(threads[i]);
-+    }
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        aio_context_unref(ctx[i]);
-+    }
-+    qemu_event_destroy(&done_event);
-+}
-+
-+/* Basic test for the stuff above. */
-+
-+static void test_lifecycle(void)
-+{
-+    create_aio_contexts();
-+    join_aio_contexts();
-+}
-+
-+/* aio_co_schedule test.  */
-+
-+static Coroutine *to_schedule[NUM_CONTEXTS];
-+
-+static bool now_stopping;
-+
-+static int count_retry;
-+static int count_here;
-+static int count_other;
-+
-+static bool schedule_next(int n)
-+{
-+    Coroutine *co;
-+
-+    co = atomic_xchg(&to_schedule[n], NULL);
-+    if (!co) {
-+        atomic_inc(&count_retry);
-+        return false;
-+    }
-+
-+    if (n == id) {
-+        atomic_inc(&count_here);
-+    } else {
-+        atomic_inc(&count_other);
-+    }
-+
-+    aio_co_schedule(ctx[n], co);
-+    return true;
-+}
-+
-+static void finish_cb(void *opaque)
-+{
-+    schedule_next(id);
-+}
-+
-+static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
-+{
-+    g_assert(to_schedule[id] == NULL);
-+    atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
-+
-+    while (!atomic_mb_read(&now_stopping)) {
-+        int n;
-+
-+        n = g_test_rand_int_range(0, NUM_CONTEXTS);
-+        schedule_next(n);
-+        qemu_coroutine_yield();
-+
-+        g_assert(to_schedule[id] == NULL);
-+        atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
-+    }
-+}
-+
-+
-+static void test_multi_co_schedule(int seconds)
-+{
-+    int i;
-+
-+    count_here = count_other = count_retry = 0;
-+    now_stopping = false;
-+
-+    create_aio_contexts();
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        Coroutine *co1 = qemu_coroutine_create(test_multi_co_schedule_entry, NULL);
-+        aio_co_schedule(ctx[i], co1);
-+    }
-+
-+    g_usleep(seconds * 1000000);
-+
-+    atomic_mb_set(&now_stopping, true);
-+    for (i = 0; i < NUM_CONTEXTS; i++) {
-+        ctx_run(i, finish_cb, NULL);
-+        to_schedule[i] = NULL;
-+    }
-+
-+    join_aio_contexts();
-+    g_test_message("scheduled %d, queued %d, retry %d, total %d\n",
-+                  count_other, count_here, count_retry,
-+                  count_here + count_other + count_retry);
-+}
-+
-+static void test_multi_co_schedule_1(void)
-+{
-+    test_multi_co_schedule(1);
-+}
-+
-+static void test_multi_co_schedule_10(void)
-+{
-+    test_multi_co_schedule(10);
-+}
-+
-+/* End of tests.  */
-+
-+int main(int argc, char **argv)
-+{
-+    init_clocks();
-+
-+    g_test_init(&argc, &argv, NULL);
-+    g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
-+    if (g_test_quick()) {
-+        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
-+    } else {
-+        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
-+    }
-+    return g_test_run();
-+}
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/main-loop.h"
- #include "qemu/atomic.h"
- #include "block/raw-aio.h"
-+#include "qemu/coroutine_int.h"
-+#include "trace.h"
- /***********************************************************/
- /* bottom halves (can be seen as timers which expire ASAP) */
 @@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
      }
  #endif
-+    assert(QSLIST_EMPTY(&ctx->scheduled_coroutines));
++#ifdef CONFIG_LINUX_IO_URING
-+    qemu_bh_delete(ctx->co_schedule_bh);
++    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
 +
-     qemu_lockcnt_lock(&ctx->list_lock);
+     assert(QSLIST_EMPTY(&ctx->scheduled_coroutines));
-     assert(!qemu_lockcnt_count(&ctx->list_lock));
+     qemu_bh_delete(ctx->co_schedule_bh);
-     while (ctx->first_bh) {
-@@ -XXX,XX +XXX,XX @@ static bool event_notifier_poll(void *opaque)
+@@ -XXX,XX +XXX,XX @@ LinuxAioState *aio_get_linux_aio(AioContext *ctx)
      return atomic_read(&ctx->notified);
  }
+ #endif
-+static void co_schedule_bh_cb(void *opaque)
 +#ifdef CONFIG_LINUX_IO_URING
 +LuringState *aio_setup_linux_io_uring(AioContext *ctx, Error **errp)
 +{
-+    AioContext *ctx = opaque;
++    if (ctx->linux_io_uring) {
-+    QSLIST_HEAD(, Coroutine) straight, reversed;
++        return ctx->linux_io_uring;
 +
 +    QSLIST_MOVE_ATOMIC(&reversed, &ctx->scheduled_coroutines);
 +    QSLIST_INIT(&straight);
 +
 +    while (!QSLIST_EMPTY(&reversed)) {
 +        Coroutine *co = QSLIST_FIRST(&reversed);
 +        QSLIST_REMOVE_HEAD(&reversed, co_scheduled_next);
 +        QSLIST_INSERT_HEAD(&straight, co, co_scheduled_next);
 +    }
 +
-+    while (!QSLIST_EMPTY(&straight)) {
++    ctx->linux_io_uring = luring_init(errp);
-+        Coroutine *co = QSLIST_FIRST(&straight);
++    if (!ctx->linux_io_uring) {
-+        QSLIST_REMOVE_HEAD(&straight, co_scheduled_next);
++        return NULL;
 +        trace_aio_co_schedule_bh_cb(ctx, co);
 +        qemu_coroutine_enter(co);
 +    }
++
++    luring_attach_aio_context(ctx->linux_io_uring, ctx);
++    return ctx->linux_io_uring;
 +}
 +
- AioContext *aio_context_new(Error **errp)
++LuringState *aio_get_linux_io_uring(AioContext *ctx)
 +{
 +    assert(ctx->linux_io_uring);
 +    return ctx->linux_io_uring;
 +}
 +#endif
 +
  void aio_notify(AioContext *ctx)
  {
-     int ret;
+     /* Write e.g. bh->scheduled before reading ctx->notify_me.  Pairs
 @@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
-     }
+ #ifdef CONFIG_LINUX_AIO
-     g_source_set_can_recurse(&ctx->source, true);
+     ctx->linux_aio = NULL;
-     qemu_lockcnt_init(&ctx->list_lock);
+ #endif
 +
-+    ctx->co_schedule_bh = aio_bh_new(ctx, co_schedule_bh_cb, ctx);
++#ifdef CONFIG_LINUX_IO_URING
-+    QSLIST_INIT(&ctx->scheduled_coroutines);
++    ctx->linux_io_uring = NULL;
 +#endif
 +
-     aio_set_event_notifier(ctx, &ctx->notifier,
+     ctx->thread_pool = NULL;
-                            false,
+     qemu_rec_mutex_init(&ctx->lock);
-                            (EventNotifierHandler *)
+     timerlistgroup_init(&ctx->tlg, aio_timerlist_notify, ctx);
@@ -XXX,XX +XXX,XX @@ fail:
      return NULL;
  }
 +void aio_co_schedule(AioContext *ctx, Coroutine *co)
 +{
 +    trace_aio_co_schedule(ctx, co);
 +    QSLIST_INSERT_HEAD_ATOMIC(&ctx->scheduled_coroutines,
 +                              co, co_scheduled_next);
 +    qemu_bh_schedule(ctx->co_schedule_bh);
 +}
 +
 +void aio_co_wake(struct Coroutine *co)
 +{
 +    AioContext *ctx;
 +
 +    /* Read coroutine before co->ctx.  Matches smp_wmb in
 +     * qemu_coroutine_enter.
 +     */
 +    smp_read_barrier_depends();
 +    ctx = atomic_read(&co->ctx);
 +
 +    if (ctx != qemu_get_current_aio_context()) {
 +        aio_co_schedule(ctx, co);
 +        return;
 +    }
 +
 +    if (qemu_in_coroutine()) {
 +        Coroutine *self = qemu_coroutine_self();
 +        assert(self != co);
 +        QSIMPLEQ_INSERT_TAIL(&self->co_queue_wakeup, co, co_queue_next);
 +    } else {
 +        aio_context_acquire(ctx);
 +        qemu_coroutine_enter(co);
 +        aio_context_release(ctx);
 +    }
 +}
 +
  void aio_context_ref(AioContext *ctx)
  {
      g_source_ref(&ctx->source);
 diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine.c
 +++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/atomic.h"
  #include "qemu/coroutine.h"
  #include "qemu/coroutine_int.h"
 +#include "block/aio.h"
  enum {
      POOL_BATCH_SIZE = 64,
@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
      }
      co->caller = self;
 +    co->ctx = qemu_get_current_aio_context();
 +
 +    /* Store co->ctx before anything that stores co.  Matches
 +     * barrier in aio_co_wake.
 +     */
 +    smp_wmb();
 +
      ret = qemu_coroutine_switch(self, co, COROUTINE_ENTER);
      qemu_co_queue_run_restart(co);
 diff --git a/util/trace-events b/util/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/util/trace-events
 +++ b/util/trace-events
@@ -XXX,XX +XXX,XX @@ run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
  poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
  poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
 +# util/async.c
 +aio_co_schedule(void *ctx, void *co) "ctx %p co %p"
 +aio_co_schedule_bh_cb(void *ctx, void *co) "ctx %p co %p"
 +
  # util/thread-pool.c
  thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
  thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 03/24] block-backend: allow blk_prw from coroutine context
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-qcow2_create2 calls this.  Do not run a nested event loop, as that
-breaks when aio_co_wake tries to queue the coroutine on the co_queue_wakeup
-list of the currently running one.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Message-id: 20170213135235.12274-4-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- block/block-backend.c | 12 ++++++++----
-file changed, 8 insertions(+), 4 deletions(-)
-diff --git a/block/block-backend.c b/block/block-backend.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
-+++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
- {
-     QEMUIOVector qiov;
-     struct iovec iov;
--    Coroutine *co;
-     BlkRwCo rwco;
-     iov = (struct iovec) {
-@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
-         .ret    = NOT_DONE,
-     };
--    co = qemu_coroutine_create(co_entry, &rwco);
--    qemu_coroutine_enter(co);
--    BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
-+    if (qemu_in_coroutine()) {
-+        /* Fast-path if already in coroutine context */
-+        co_entry(&rwco);
-+    } else {
-+        Coroutine *co = qemu_coroutine_create(co_entry, &rwco);
-+        qemu_coroutine_enter(co);
-+        BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
-+    }
-     return rwco.ret;
- }
---
-.9.3

-[Qemu-devel] [PULL 13/24] block: explicitly acquire aiocontext in callbacks that need it
+[PULL 10/18] blockdev: adds bdrv_parse_aio to use io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This covers both file descriptor callbacks and polling callbacks,
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-since they execute related code.
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200120141858.587874-8-stefanha@redhat.com
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-Id: <20200120141858.587874-8-stefanha@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
 Message-id: 20170213135235.12274-14-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/curl.c          | 16 +++++++++++++---
+ block.c               | 22 ++++++++++++++++++++++
- block/iscsi.c         |  4 ++++
+ blockdev.c            | 12 ++++--------
- block/linux-aio.c     |  4 ++++
+ include/block/block.h |  1 +
- block/nfs.c           |  6 ++++++
+files changed, 27 insertions(+), 8 deletions(-)
  block/sheepdog.c      | 29 +++++++++++++++--------------
  block/ssh.c           | 29 +++++++++--------------------
  block/win32-aio.c     | 10 ++++++----
  hw/block/virtio-blk.c |  5 ++++-
  hw/scsi/virtio-scsi.c |  6 ++++++
  util/aio-posix.c      |  7 -------
  util/aio-win32.c      |  6 ------
 files changed, 67 insertions(+), 55 deletions(-)
-diff --git a/block/curl.c b/block/curl.c
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/curl.c
+--- a/block.c
-+++ b/block/curl.c
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static void curl_multi_check_completion(BDRVCURLState *s)
+@@ -XXX,XX +XXX,XX @@ static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
-     }
+     return detect_zeroes;
  }
--static void curl_multi_do(void *arg)
++/**
-+static void curl_multi_do_locked(CURLState *s)
++ * Set open flags for aio engine
- {
++ *
--    CURLState *s = (CURLState *)arg;
++ * Return 0 on success, -1 if the engine specified is invalid
-     CURLSocket *socket, *next_socket;
++ */
-     int running;
++int bdrv_parse_aio(const char *mode, int *flags)
      int r;
@@ -XXX,XX +XXX,XX @@ static void curl_multi_do(void *arg)
      }
  }
 +static void curl_multi_do(void *arg)
 +{
-+    CURLState *s = (CURLState *)arg;
++    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;
 +    }
 +
-+    aio_context_acquire(s->s->aio_context);
++    return 0;
 +    curl_multi_do_locked(s);
 +    aio_context_release(s->s->aio_context);
 +}
 +
- static void curl_multi_read(void *arg)
+ /**
- {
+  * Set open flags for a given discard mode
-     CURLState *s = (CURLState *)arg;
+  *
+diff --git a/blockdev.c b/blockdev.c
 -    curl_multi_do(arg);
 +    aio_context_acquire(s->s->aio_context);
 +    curl_multi_do_locked(s);
      curl_multi_check_completion(s->s);
 +    aio_context_release(s->s->aio_context);
  }
  static void curl_multi_timeout_do(void *arg)
 diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+--- a/blockdev.c
-+++ b/block/iscsi.c
++++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ iscsi_process_read(void *arg)
+@@ -XXX,XX +XXX,XX @@ static void extract_common_blockdev_options(QemuOpts *opts, int *bdrv_flags,
-     IscsiLun *iscsilun = arg;
+         }
-     struct iscsi_context *iscsi = iscsilun->iscsi;
+         if ((aio = qemu_opt_get(opts, "aio")) != NULL) {
-+    aio_context_acquire(iscsilun->aio_context);
+-            if (!strcmp(aio, "native")) {
-     iscsi_service(iscsi, POLLIN);
+-                *bdrv_flags |= BDRV_O_NATIVE_AIO;
-     iscsi_set_events(iscsilun);
+-            } else if (!strcmp(aio, "threads")) {
-+    aio_context_release(iscsilun->aio_context);
+-                /* this is the default */
- }
+-            } else {
+-               error_setg(errp, "invalid aio option");
- static void
+-               return;
-@@ -XXX,XX +XXX,XX @@ iscsi_process_write(void *arg)
++            if (bdrv_parse_aio(aio, bdrv_flags) < 0) {
-     IscsiLun *iscsilun = arg;
++                error_setg(errp, "invalid aio option");
-     struct iscsi_context *iscsi = iscsilun->iscsi;
++                return;
+             }
-+    aio_context_acquire(iscsilun->aio_context);
+         }
-     iscsi_service(iscsi, POLLOUT);
+     }
-     iscsi_set_events(iscsilun);
+@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_common_drive_opts = {
-+    aio_context_release(iscsilun->aio_context);
+         },{
- }
+             .name = "aio",
+             .type = QEMU_OPT_STRING,
- static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
+-            .help = "host AIO implementation (threads, native)",
-diff --git a/block/linux-aio.c b/block/linux-aio.c
++            .help = "host AIO implementation (threads, native, io_uring)",
          },{
              .name = BDRV_OPT_CACHE_WB,
              .type = QEMU_OPT_BOOL,
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/linux-aio.c
+--- a/include/block/block.h
-+++ b/block/linux-aio.c
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ static void qemu_laio_completion_cb(EventNotifier *e)
+@@ -XXX,XX +XXX,XX @@ void bdrv_append(BlockDriverState *bs_new, BlockDriverState *bs_top,
-     LinuxAioState *s = container_of(e, LinuxAioState, e);
+ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
+                        Error **errp);
-     if (event_notifier_test_and_clear(&s->e)) {
-+        aio_context_acquire(s->aio_context);
++int bdrv_parse_aio(const char *mode, int *flags);
-         qemu_laio_process_completions_and_submit(s);
+ int bdrv_parse_cache_mode(const char *mode, int *flags, bool *writethrough);
-+        aio_context_release(s->aio_context);
+ int bdrv_parse_discard_flags(const char *mode, int *flags);
-     }
+ BdrvChild *bdrv_open_child(const char *filename,
  }
@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
          return false;
      }
 +    aio_context_acquire(s->aio_context);
      qemu_laio_process_completions_and_submit(s);
 +    aio_context_release(s->aio_context);
      return true;
  }
 diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nfs.c
 +++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static void nfs_set_events(NFSClient *client)
  static void nfs_process_read(void *arg)
  {
      NFSClient *client = arg;
 +
 +    aio_context_acquire(client->aio_context);
      nfs_service(client->context, POLLIN);
      nfs_set_events(client);
 +    aio_context_release(client->aio_context);
  }
  static void nfs_process_write(void *arg)
  {
      NFSClient *client = arg;
 +
 +    aio_context_acquire(client->aio_context);
      nfs_service(client->context, POLLOUT);
      nfs_set_events(client);
 +    aio_context_release(client->aio_context);
  }
  static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
      return ret;
  }
 -static void restart_co_req(void *opaque)
 -{
 -    Coroutine *co = opaque;
 -
 -    qemu_coroutine_enter(co);
 -}
 -
  typedef struct SheepdogReqCo {
      int sockfd;
      BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ typedef struct SheepdogReqCo {
      unsigned int *rlen;
      int ret;
      bool finished;
 +    Coroutine *co;
  } SheepdogReqCo;
 +static void restart_co_req(void *opaque)
 +{
 +    SheepdogReqCo *srco = opaque;
 +
 +    aio_co_wake(srco->co);
 +}
 +
  static coroutine_fn void do_co_req(void *opaque)
  {
      int ret;
 -    Coroutine *co;
      SheepdogReqCo *srco = opaque;
      int sockfd = srco->sockfd;
      SheepdogReq *hdr = srco->hdr;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void do_co_req(void *opaque)
      unsigned int *wlen = srco->wlen;
      unsigned int *rlen = srco->rlen;
 -    co = qemu_coroutine_self();
 +    srco->co = qemu_coroutine_self();
      aio_set_fd_handler(srco->aio_context, sockfd, false,
 -                       NULL, restart_co_req, NULL, co);
 +                       NULL, restart_co_req, NULL, srco);
      ret = send_co_req(sockfd, hdr, data, wlen);
      if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void do_co_req(void *opaque)
      }
      aio_set_fd_handler(srco->aio_context, sockfd, false,
 -                       restart_co_req, NULL, NULL, co);
 +                       restart_co_req, NULL, NULL, srco);
      ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
      if (ret != sizeof(*hdr)) {
@@ -XXX,XX +XXX,XX @@ out:
      aio_set_fd_handler(srco->aio_context, sockfd, false,
                         NULL, NULL, NULL, NULL);
 +    srco->co = NULL;
      srco->ret = ret;
      srco->finished = true;
      if (srco->bs) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn aio_read_response(void *opaque)
           * We've finished all requests which belong to the AIOCB, so
           * we can switch back to sd_co_readv/writev now.
           */
 -        qemu_coroutine_enter(acb->coroutine);
 +        aio_co_wake(acb->coroutine);
      }
      return;
@@ -XXX,XX +XXX,XX @@ static void co_read_response(void *opaque)
          s->co_recv = qemu_coroutine_create(aio_read_response, opaque);
      }
 -    qemu_coroutine_enter(s->co_recv);
 +    aio_co_wake(s->co_recv);
  }
  static void co_write_request(void *opaque)
  {
      BDRVSheepdogState *s = opaque;
 -    qemu_coroutine_enter(s->co_send);
 +    aio_co_wake(s->co_send);
  }
  /*
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static void restart_coroutine(void *opaque)
      DPRINTF("co=%p", co);
 -    qemu_coroutine_enter(co);
 +    aio_co_wake(co);
  }
 -static coroutine_fn void set_fd_handler(BDRVSSHState *s, BlockDriverState *bs)
 +/* A non-blocking call returned EAGAIN, so yield, ensuring the
 + * handlers are set up so that we'll be rescheduled when there is an
 + * interesting event on the socket.
 + */
 +static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
  {
      int r;
      IOHandler *rd_handler = NULL, *wr_handler = NULL;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void set_fd_handler(BDRVSSHState *s, BlockDriverState *bs)
      aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
                         false, rd_handler, wr_handler, NULL, co);
 -}
 -
 -static coroutine_fn void clear_fd_handler(BDRVSSHState *s,
 -                                          BlockDriverState *bs)
 -{
 -    DPRINTF("s->sock=%d", s->sock);
 -    aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
 -                       false, NULL, NULL, NULL, NULL);
 -}
 -
 -/* A non-blocking call returned EAGAIN, so yield, ensuring the
 - * handlers are set up so that we'll be rescheduled when there is an
 - * interesting event on the socket.
 - */
 -static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
 -{
 -    set_fd_handler(s, bs);
      qemu_coroutine_yield();
 -    clear_fd_handler(s, bs);
 +    DPRINTF("s->sock=%d - back", s->sock);
 +    aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, false,
 +                       NULL, NULL, NULL, NULL);
  }
  /* SFTP has a function `libssh2_sftp_seek64' which seeks to a position
 diff --git a/block/win32-aio.c b/block/win32-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/win32-aio.c
 +++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ struct QEMUWin32AIOState {
      HANDLE hIOCP;
      EventNotifier e;
      int count;
 -    bool is_aio_context_attached;
 +    AioContext *aio_ctx;
  };
  typedef struct QEMUWin32AIOCB {
@@ -XXX,XX +XXX,XX @@ static void win32_aio_process_completion(QEMUWin32AIOState *s,
      }
 +    aio_context_acquire(s->aio_ctx);
      waiocb->common.cb(waiocb->common.opaque, ret);
 +    aio_context_release(s->aio_ctx);
      qemu_aio_unref(waiocb);
  }
@@ -XXX,XX +XXX,XX @@ void win32_aio_detach_aio_context(QEMUWin32AIOState *aio,
                                    AioContext *old_context)
  {
      aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL);
 -    aio->is_aio_context_attached = false;
 +    aio->aio_ctx = NULL;
  }
  void win32_aio_attach_aio_context(QEMUWin32AIOState *aio,
                                    AioContext *new_context)
  {
 -    aio->is_aio_context_attached = true;
 +    aio->aio_ctx = new_context;
      aio_set_event_notifier(new_context, &aio->e, false,
                             win32_aio_completion_cb, NULL);
  }
@@ -XXX,XX +XXX,XX @@ out_free_state:
  void win32_aio_cleanup(QEMUWin32AIOState *aio)
  {
 -    assert(!aio->is_aio_context_attached);
 +    assert(!aio->aio_ctx);
      CloseHandle(aio->hIOCP);
      event_notifier_cleanup(&aio->e);
      g_free(aio);
 diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/virtio-blk.c
 +++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_ioctl_complete(void *opaque, int status)
  {
      VirtIOBlockIoctlReq *ioctl_req = opaque;
      VirtIOBlockReq *req = ioctl_req->req;
 -    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
 +    VirtIOBlock *s = req->dev;
 +    VirtIODevice *vdev = VIRTIO_DEVICE(s);
      struct virtio_scsi_inhdr *scsi;
      struct sg_io_hdr *hdr;
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
      VirtIOBlockReq *req;
      MultiReqBuffer mrb = {};
 +    aio_context_acquire(blk_get_aio_context(s->blk));
      blk_io_plug(s->blk);
      do {
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
      }
      blk_io_unplug(s->blk);
 +    aio_context_release(blk_get_aio_context(s->blk));
  }
  static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/scsi/virtio-scsi.c
 +++ b/hw/scsi/virtio-scsi.c
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)
  {
      VirtIOSCSIReq *req;
 +    virtio_scsi_acquire(s);
      while ((req = virtio_scsi_pop_req(s, vq))) {
          virtio_scsi_handle_ctrl_req(s, req);
      }
 +    virtio_scsi_release(s);
  }
  static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
      QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs);
 +    virtio_scsi_acquire(s);
      do {
          virtio_queue_set_notification(vq, 0);
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
      QTAILQ_FOREACH_SAFE(req, &reqs, next, next) {
          virtio_scsi_handle_cmd_req_submit(s, req);
      }
 +    virtio_scsi_release(s);
  }
  static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
@@ -XXX,XX +XXX,XX @@ out:
  void virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq)
  {
 +    virtio_scsi_acquire(s);
      if (s->events_dropped) {
          virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
      }
 +    virtio_scsi_release(s);
  }
  static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
              (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
              aio_node_check(ctx, node->is_external) &&
              node->io_read) {
 -            aio_context_acquire(ctx);
              node->io_read(node->opaque);
 -            aio_context_release(ctx);
              /* aio_notify() does not count as progress */
              if (node->opaque != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
              (revents & (G_IO_OUT | G_IO_ERR)) &&
              aio_node_check(ctx, node->is_external) &&
              node->io_write) {
 -            aio_context_acquire(ctx);
              node->io_write(node->opaque);
 -            aio_context_release(ctx);
              progress = true;
          }
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
          start = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
      }
 -    aio_context_acquire(ctx);
      progress = try_poll_mode(ctx, blocking);
 -    aio_context_release(ctx);
 -
      if (!progress) {
          assert(npfd == 0);
 diff --git a/util/aio-win32.c b/util/aio-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-win32.c
 +++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
              (revents || event_notifier_get_handle(node->e) == event) &&
              node->io_notify) {
              node->pfd.revents = 0;
 -            aio_context_acquire(ctx);
              node->io_notify(node->e);
 -            aio_context_release(ctx);
              /* aio_notify() does not count as progress */
              if (node->e != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
              (node->io_read || node->io_write)) {
              node->pfd.revents = 0;
              if ((revents & G_IO_IN) && node->io_read) {
 -                aio_context_acquire(ctx);
                  node->io_read(node->opaque);
 -                aio_context_release(ctx);
                  progress = true;
              }
              if ((revents & G_IO_OUT) && node->io_write) {
 -                aio_context_acquire(ctx);
                  node->io_write(node->opaque);
 -                aio_context_release(ctx);
                  progress = true;
              }
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 17/24] async: remove unnecessary inc/dec pairs
+[PULL 11/18] block/file-posix.c: extend to use io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Pull the increment/decrement pair out of aio_bh_poll and into the
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-callers.
+Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-id: 20200120141858.587874-9-stefanha@redhat.com
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Message-Id: <20200120141858.587874-9-stefanha@redhat.com>
 Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
 Message-id: 20170213135235.12274-18-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/aio-posix.c |  8 +++-----
+ block/file-posix.c | 98 +++++++++++++++++++++++++++++++++++++---------
- util/aio-win32.c |  8 ++++----
+file changed, 79 insertions(+), 19 deletions(-)
- util/async.c     | 12 ++++++------
-files changed, 13 insertions(+), 15 deletions(-)
+diff --git a/block/file-posix.c b/block/file-posix.c
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/aio-posix.c
+--- a/block/file-posix.c
-+++ b/util/aio-posix.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
+@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRawState {
+     bool has_write_zeroes:1;
- void aio_dispatch(AioContext *ctx)
+     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;
@@ -XXX,XX +XXX,XX @@ 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",
@@ -XXX,XX +XXX,XX @@ 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);
@@ -XXX,XX +XXX,XX @@ 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"),
@@ -XXX,XX +XXX,XX @@ 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) {
@@ -XXX,XX +XXX,XX @@ 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) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_pwritev(BlockDriverState *bs, uint64_t offset,
  static void raw_aio_plug(BlockDriverState *bs)
  {
-+    qemu_lockcnt_inc(&ctx->list_lock);
++    BDRVRawState __attribute__((unused)) *s = bs->opaque;
-     aio_bh_poll(ctx);
+ #ifdef CONFIG_LINUX_AIO
--
+-    BDRVRawState *s = bs->opaque;
--    qemu_lockcnt_inc(&ctx->list_lock);
+     if (s->use_linux_aio) {
-     aio_dispatch_handlers(ctx);
+         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
-     qemu_lockcnt_dec(&ctx->list_lock);
+         laio_io_plug(bs, aio);
+     }
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
+ #endif
-     }
++#ifdef CONFIG_LINUX_IO_URING
++    if (s->use_linux_io_uring) {
-     npfd = 0;
++        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
--    qemu_lockcnt_dec(&ctx->list_lock);
++        luring_io_plug(bs, aio);
++    }
-     progress |= aio_bh_poll(ctx);
++#endif
+ }
-     if (ret > 0) {
--        qemu_lockcnt_inc(&ctx->list_lock);
+ static void raw_aio_unplug(BlockDriverState *bs)
-         progress |= aio_dispatch_handlers(ctx);
+ {
--        qemu_lockcnt_dec(&ctx->list_lock);
++    BDRVRawState __attribute__((unused)) *s = bs->opaque;
-     }
+ #ifdef CONFIG_LINUX_AIO
+-    BDRVRawState *s = bs->opaque;
-+    qemu_lockcnt_dec(&ctx->list_lock);
+     if (s->use_linux_aio) {
-+
+         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
-     progress |= timerlistgroup_run_timers(&ctx->tlg);
+         laio_io_unplug(bs, aio);
+     }
-     return progress;
+ #endif
-diff --git a/util/aio-win32.c b/util/aio-win32.c
++#ifdef CONFIG_LINUX_IO_URING
-index XXXXXXX..XXXXXXX 100644
++    if (s->use_linux_io_uring) {
---- a/util/aio-win32.c
++        LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
-+++ b/util/aio-win32.c
++        luring_io_unplug(bs, aio);
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
++    }
-     bool progress = false;
++#endif
-     AioHandler *tmp;
+ }
--    qemu_lockcnt_inc(&ctx->list_lock);
+ static int raw_co_flush_to_disk(BlockDriverState *bs)
--
+@@ -XXX,XX +XXX,XX @@ static int raw_co_flush_to_disk(BlockDriverState *bs)
-     /*
+         .aio_type       = QEMU_AIO_FLUSH,
-      * We have to walk very carefully in case aio_set_fd_handler is
+     };
-      * called while we're walking.
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
++#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 = NULL;
          if (!aio_setup_linux_aio(new_context, &local_err)) {
@@ -XXX,XX +XXX,XX @@ static void raw_aio_attach_aio_context(BlockDriverState *bs,
          }
      }
+ #endif
--    qemu_lockcnt_dec(&ctx->list_lock);
++#ifdef CONFIG_LINUX_IO_URING
-     return progress;
++    if (s->use_linux_io_uring) {
- }
++        Error *local_err;
++        if (!aio_setup_linux_io_uring(new_context, &local_err)) {
- void aio_dispatch(AioContext *ctx)
++            error_reportf_err(local_err, "Unable to use linux io_uring, "
- {
++                                         "falling back to thread pool: ");
-+    qemu_lockcnt_inc(&ctx->list_lock);
++            s->use_linux_io_uring = false;
-     aio_bh_poll(ctx);
++        }
-     aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
++    }
-+    qemu_lockcnt_dec(&ctx->list_lock);
++#endif
-     timerlistgroup_run_timers(&ctx->tlg);
+ }
- }
+ static void raw_close(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
          }
      }
 -    qemu_lockcnt_dec(&ctx->list_lock);
      first = true;
      /* ctx->notifier is always registered.  */
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
          progress |= aio_dispatch_handlers(ctx, event);
      } while (count > 0);
 +    qemu_lockcnt_dec(&ctx->list_lock);
 +
      progress |= timerlistgroup_run_timers(&ctx->tlg);
      return progress;
  }
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ void aio_bh_call(QEMUBH *bh)
      bh->cb(bh->opaque);
  }
 -/* Multiple occurrences of aio_bh_poll cannot be called concurrently */
 +/* Multiple occurrences of aio_bh_poll cannot be called concurrently.
 + * The count in ctx->list_lock is incremented before the call, and is
 + * not affected by the call.
 + */
  int aio_bh_poll(AioContext *ctx)
  {
      QEMUBH *bh, **bhp, *next;
      int ret;
      bool deleted = false;
 -    qemu_lockcnt_inc(&ctx->list_lock);
 -
      ret = 0;
      for (bh = atomic_rcu_read(&ctx->first_bh); bh; bh = next) {
          next = atomic_rcu_read(&bh->next);
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
      /* remove deleted bhs */
      if (!deleted) {
 -        qemu_lockcnt_dec(&ctx->list_lock);
          return ret;
      }
 -    if (qemu_lockcnt_dec_and_lock(&ctx->list_lock)) {
 +    if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
          bhp = &ctx->first_bh;
          while (*bhp) {
              bh = *bhp;
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
                  bhp = &bh->next;
              }
          }
 -        qemu_lockcnt_unlock(&ctx->list_lock);
 +        qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
      }
      return ret;
  }
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 05/24] io: add methods to set I/O handlers on AioContext
+[PULL 12/18] block: add trace events for io_uring
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-This is in preparation for making qio_channel_yield work on
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-AioContexts other than the main one.
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+Message-id: 20200120141858.587874-10-stefanha@redhat.com
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20200120141858.587874-10-stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213135235.12274-6-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/io/channel.h | 25 +++++++++++++++++++++++++
+ block/io_uring.c   | 23 ++++++++++++++++++++---
- io/channel-command.c | 13 +++++++++++++
+ block/trace-events | 12 ++++++++++++
- io/channel-file.c    | 11 +++++++++++
+files changed, 32 insertions(+), 3 deletions(-)
  io/channel-socket.c  | 16 +++++++++++-----
  io/channel-tls.c     | 12 ++++++++++++
  io/channel-watch.c   |  6 ++++++
  io/channel.c         | 11 +++++++++++
 files changed, 89 insertions(+), 5 deletions(-)
-diff --git a/include/io/channel.h b/include/io/channel.h
+diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/io/channel.h
+--- a/block/io_uring.c
-+++ b/include/io/channel.h
++++ b/block/io_uring.c
 @@ -XXX,XX +XXX,XX @@
+ #include "block/raw-aio.h"
- #include "qemu-common.h"
+ #include "qemu/coroutine.h"
- #include "qom/object.h"
+ #include "qapi/error.h"
-+#include "block/aio.h"
++#include "trace.h"
- #define TYPE_QIO_CHANNEL "qio-channel"
+ /* io_uring ring size */
- #define QIO_CHANNEL(obj)                                    \
+ #define MAX_ENTRIES 128
-@@ -XXX,XX +XXX,XX @@ struct QIOChannelClass {
+@@ -XXX,XX +XXX,XX @@ static void luring_resubmit_short_read(LuringState *s, LuringAIOCB *luringcb,
-                      off_t offset,
+     QEMUIOVector *resubmit_qiov;
-                      int whence,
+     size_t remaining;
-                      Error **errp);
-+    void (*io_set_aio_fd_handler)(QIOChannel *ioc,
++    trace_luring_resubmit_short_read(s, luringcb, nread);
 +                                  AioContext *ctx,
 +                                  IOHandler *io_read,
 +                                  IOHandler *io_write,
 +                                  void *opaque);
  };
  /* General I/O handling functions */
@@ -XXX,XX +XXX,XX @@ void qio_channel_yield(QIOChannel *ioc,
  void qio_channel_wait(QIOChannel *ioc,
                        GIOCondition condition);
 +/**
 + * qio_channel_set_aio_fd_handler:
 + * @ioc: the channel object
 + * @ctx: the AioContext to set the handlers on
 + * @io_read: the read handler
 + * @io_write: the write handler
 + * @opaque: the opaque value passed to the handler
 + *
 + * This is used internally by qio_channel_yield().  It can
 + * be used by channel implementations to forward the handlers
 + * to another channel (e.g. from #QIOChannelTLS to the
 + * underlying socket).
 + */
 +void qio_channel_set_aio_fd_handler(QIOChannel *ioc,
 +                                    AioContext *ctx,
 +                                    IOHandler *io_read,
 +                                    IOHandler *io_write,
 +                                    void *opaque);
 +
- #endif /* QIO_CHANNEL_H */
+     /* Update read position */
-diff --git a/io/channel-command.c b/io/channel-command.c
+     luringcb->total_read = nread;
-index XXXXXXX..XXXXXXX 100644
+     remaining = luringcb->qiov->size - luringcb->total_read;
---- a/io/channel-command.c
+@@ -XXX,XX +XXX,XX @@ static void luring_process_completions(LuringState *s)
-+++ b/io/channel-command.c
-@@ -XXX,XX +XXX,XX @@ static int qio_channel_command_close(QIOChannel *ioc,
+         /* 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;
@@ -XXX,XX +XXX,XX @@ static int ioq_submit(LuringState *s)
              QSIMPLEQ_REMOVE_HEAD(&s->io_q.submit_queue, 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) {
@@ -XXX,XX +XXX,XX @@ static void ioq_init(LuringQueue *io_q)
  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)
 +static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
 +                                                   AioContext *ctx,
 +                                                   IOHandler *io_read,
 +                                                   IOHandler *io_write,
 +                                                   void *opaque)
 +{
 +    QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
 +    aio_set_fd_handler(ctx, cioc->readfd, false, io_read, NULL, NULL, opaque);
 +    aio_set_fd_handler(ctx, cioc->writefd, false, NULL, io_write, NULL, opaque);
 +}
 +
 +
  static GSource *qio_channel_command_create_watch(QIOChannel *ioc,
                                                   GIOCondition condition)
  {
-@@ -XXX,XX +XXX,XX @@ static void qio_channel_command_class_init(ObjectClass *klass,
+     assert(s->io_q.plugged);
-     ioc_klass->io_set_blocking = qio_channel_command_set_blocking;
++    trace_luring_io_unplug(s, s->io_q.blocked, s->io_q.plugged,
-     ioc_klass->io_close = qio_channel_command_close;
++                           s->io_q.in_queue, s->io_q.in_flight);
-     ioc_klass->io_create_watch = qio_channel_command_create_watch;
+     if (--s->io_q.plugged == 0 &&
-+    ioc_klass->io_set_aio_fd_handler = qio_channel_command_set_aio_fd_handler;
+         !s->io_q.blocked && s->io_q.in_queue > 0) {
- }
+         ioq_submit(s);
+@@ -XXX,XX +XXX,XX @@ void luring_io_unplug(BlockDriverState *bs, LuringState *s)
- static const TypeInfo qio_channel_command_info = {
+ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
-diff --git a/io/channel-file.c b/io/channel-file.c
+                             uint64_t offset, int type)
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-file.c
 +++ b/io/channel-file.c
@@ -XXX,XX +XXX,XX @@ static int qio_channel_file_close(QIOChannel *ioc,
  }
 +static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
 +                                                AioContext *ctx,
 +                                                IOHandler *io_read,
 +                                                IOHandler *io_write,
 +                                                void *opaque)
 +{
 +    QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 +    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write, NULL, opaque);
 +}
 +
  static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
                                                GIOCondition condition)
  {
-@@ -XXX,XX +XXX,XX @@ static void qio_channel_file_class_init(ObjectClass *klass,
++    int ret;
-     ioc_klass->io_seek = qio_channel_file_seek;
+     struct io_uring_sqe *sqes = &luringcb->sqeq;
-     ioc_klass->io_close = qio_channel_file_close;
-     ioc_klass->io_create_watch = qio_channel_file_create_watch;
+     switch (type) {
-+    ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
+@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
- }
+     QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, luringcb, next);
- static const TypeInfo qio_channel_file_info = {
+     s->io_q.in_queue++;
-diff --git a/io/channel-socket.c b/io/channel-socket.c
+-
-index XXXXXXX..XXXXXXX 100644
++    trace_luring_do_submit(s, s->io_q.blocked, s->io_q.plugged,
---- a/io/channel-socket.c
++                           s->io_q.in_queue, s->io_q.in_flight);
-+++ b/io/channel-socket.c
+     if (!s->io_q.blocked &&
-@@ -XXX,XX +XXX,XX @@ qio_channel_socket_set_blocking(QIOChannel *ioc,
+         (!s->io_q.plugged ||
-         qemu_set_block(sioc->fd);
+          s->io_q.in_flight + s->io_q.in_queue >= MAX_ENTRIES)) {
-     } else {
+-        return ioq_submit(s);
-         qemu_set_nonblock(sioc->fd);
++        ret = ioq_submit(s);
--#ifdef WIN32
++        trace_luring_do_submit_done(s, ret);
--        WSAEventSelect(sioc->fd, ioc->event,
++        return ret;
 -                       FD_READ | FD_ACCEPT | FD_CLOSE |
 -                       FD_CONNECT | FD_WRITE | FD_OOB);
 -#endif
      }
      return 0;
  }
-@@ -XXX,XX +XXX,XX @@ qio_channel_socket_shutdown(QIOChannel *ioc,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
-     return 0;
+         .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;
      }
@@ -XXX,XX +XXX,XX @@ LuringState *luring_init(Error **errp)
      LuringState *s = g_new0(LuringState, 1);
      struct io_uring *ring = &s->ring;
 +    trace_luring_init_state(s, sizeof(*s));
 +
      rc = io_uring_queue_init(MAX_ENTRIES, ring, 0);
      if (rc < 0) {
          error_setg_errno(errp, errno, "failed to init linux io_uring ring");
@@ -XXX,XX +XXX,XX @@ 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
-+static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc,
+index XXXXXXX..XXXXXXX 100644
-+                                                  AioContext *ctx,
+--- a/block/trace-events
-+                                                  IOHandler *io_read,
++++ b/block/trace-events
-+                                                  IOHandler *io_write,
+@@ -XXX,XX +XXX,XX @@ qmp_block_stream(void *bs) "bs %p"
-+                                                  void *opaque)
+ 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
-+    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
-+    aio_set_fd_handler(ctx, sioc->fd, false, io_read, io_write, NULL, opaque);
++#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 %d"
 +
- static GSource *qio_channel_socket_create_watch(QIOChannel *ioc,
+ # qcow2.c
-                                                 GIOCondition condition)
+ qcow2_add_task(void *co, void *bs, void *pool, const char *action, int cluster_type, uint64_t file_cluster_offset, uint64_t offset, uint64_t bytes, void *qiov, size_t qiov_offset) "co %p bs %p pool %p: %s: cluster_type %d file_cluster_offset %" PRIu64 " offset %" PRIu64 " bytes %" PRIu64 " qiov %p qiov_offset %zu"
- {
+ qcow2_writev_start_req(void *co, int64_t offset, int bytes) "co %p offset 0x%" PRIx64 " bytes %d"
@@ -XXX,XX +XXX,XX @@ static void qio_channel_socket_class_init(ObjectClass *klass,
      ioc_klass->io_set_cork = qio_channel_socket_set_cork;
      ioc_klass->io_set_delay = qio_channel_socket_set_delay;
      ioc_klass->io_create_watch = qio_channel_socket_create_watch;
 +    ioc_klass->io_set_aio_fd_handler = qio_channel_socket_set_aio_fd_handler;
  }
  static const TypeInfo qio_channel_socket_info = {
 diff --git a/io/channel-tls.c b/io/channel-tls.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-tls.c
 +++ b/io/channel-tls.c
@@ -XXX,XX +XXX,XX @@ static int qio_channel_tls_close(QIOChannel *ioc,
      return qio_channel_close(tioc->master, errp);
  }
 +static void qio_channel_tls_set_aio_fd_handler(QIOChannel *ioc,
 +                                               AioContext *ctx,
 +                                               IOHandler *io_read,
 +                                               IOHandler *io_write,
 +                                               void *opaque)
 +{
 +    QIOChannelTLS *tioc = QIO_CHANNEL_TLS(ioc);
 +
 +    qio_channel_set_aio_fd_handler(tioc->master, ctx, io_read, io_write, opaque);
 +}
 +
  static GSource *qio_channel_tls_create_watch(QIOChannel *ioc,
                                               GIOCondition condition)
  {
@@ -XXX,XX +XXX,XX @@ static void qio_channel_tls_class_init(ObjectClass *klass,
      ioc_klass->io_close = qio_channel_tls_close;
      ioc_klass->io_shutdown = qio_channel_tls_shutdown;
      ioc_klass->io_create_watch = qio_channel_tls_create_watch;
 +    ioc_klass->io_set_aio_fd_handler = qio_channel_tls_set_aio_fd_handler;
  }
  static const TypeInfo qio_channel_tls_info = {
 diff --git a/io/channel-watch.c b/io/channel-watch.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-watch.c
 +++ b/io/channel-watch.c
@@ -XXX,XX +XXX,XX @@ GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
      GSource *source;
      QIOChannelSocketSource *ssource;
 +#ifdef WIN32
 +    WSAEventSelect(socket, ioc->event,
 +                   FD_READ | FD_ACCEPT | FD_CLOSE |
 +                   FD_CONNECT | FD_WRITE | FD_OOB);
 +#endif
 +
      source = g_source_new(&qio_channel_socket_source_funcs,
                            sizeof(QIOChannelSocketSource));
      ssource = (QIOChannelSocketSource *)source;
 diff --git a/io/channel.c b/io/channel.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel.c
 +++ b/io/channel.c
@@ -XXX,XX +XXX,XX @@ GSource *qio_channel_create_watch(QIOChannel *ioc,
  }
 +void qio_channel_set_aio_fd_handler(QIOChannel *ioc,
 +                                    AioContext *ctx,
 +                                    IOHandler *io_read,
 +                                    IOHandler *io_write,
 +                                    void *opaque)
 +{
 +    QIOChannelClass *klass = QIO_CHANNEL_GET_CLASS(ioc);
 +
 +    klass->io_set_aio_fd_handler(ioc, ctx, io_read, io_write, opaque);
 +}
 +
  guint qio_channel_add_watch(QIOChannel *ioc,
                              GIOCondition condition,
                              QIOChannelFunc func,
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 21/24] test-aio-multithread: add performance comparison with thread-based mutexes
+[PULL 13/18] block/io_uring: adds userspace completion polling
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Add two implementations of the same benchmark as the previous patch,
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-but using pthreads.  One uses a normal QemuMutex, the other is Linux
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-only and implements a fair mutex based on MCS locks and futexes.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-This shows that the slower performance of the 5-thread case is due to
+Message-id: 20200120141858.587874-11-stefanha@redhat.com
-the fairness of CoMutex, rather than to coroutines.  If fairness does
+Message-Id: <20200120141858.587874-11-stefanha@redhat.com>
 not matter, as is the case with two threads, CoMutex can actually be
 faster than pthreads.
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213181244.16297-4-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/test-aio-multithread.c | 164 +++++++++++++++++++++++++++++++++++++++++++
+ block/io_uring.c | 17 ++++++++++++++++-
-file changed, 164 insertions(+)
+file changed, 16 insertions(+), 1 deletion(-)
-diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
+diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-aio-multithread.c
+--- a/block/io_uring.c
-+++ b/tests/test-aio-multithread.c
++++ b/block/io_uring.c
-@@ -XXX,XX +XXX,XX @@ static void test_multi_co_mutex_2_30(void)
+@@ -XXX,XX +XXX,XX @@ static void qemu_luring_completion_cb(void *opaque)
-     test_multi_co_mutex(2, 30);
+     luring_process_completions_and_submit(s);
  }
-+/* Same test with fair mutexes, for performance comparison.  */
++static bool qemu_luring_poll_cb(void *opaque)
 +{
 +    LuringState *s = opaque;
 +    struct io_uring_cqe *cqes;
 +
-+#ifdef CONFIG_LINUX
++    if (io_uring_peek_cqe(&s->ring, &cqes) == 0) {
-+#include "qemu/futex.h"
++        if (cqes) {
-+
++            luring_process_completions_and_submit(s);
-+/* The nodes for the mutex reside in this structure (on which we try to avoid
++            return true;
 + * false sharing).  The head of the mutex is in the "mutex_head" variable.
 + */
 +static struct {
 +    int next, locked;
 +    int padding[14];
 +} nodes[NUM_CONTEXTS] __attribute__((__aligned__(64)));
 +
 +static int mutex_head = -1;
 +
 +static void mcs_mutex_lock(void)
 +{
 +    int prev;
 +
 +    nodes[id].next = -1;
 +    nodes[id].locked = 1;
 +    prev = atomic_xchg(&mutex_head, id);
 +    if (prev != -1) {
 +        atomic_set(&nodes[prev].next, id);
 +        qemu_futex_wait(&nodes[id].locked, 1);
 +    }
 +}
 +
 +static void mcs_mutex_unlock(void)
 +{
 +    int next;
 +    if (nodes[id].next == -1) {
 +        if (atomic_read(&mutex_head) == id &&
 +            atomic_cmpxchg(&mutex_head, id, -1) == id) {
 +            /* Last item in the list, exit.  */
 +            return;
 +        }
 +        while (atomic_read(&nodes[id].next) == -1) {
 +            /* mcs_mutex_lock did the xchg, but has not updated
 +             * nodes[prev].next yet.
 +             */
 +        }
 +    }
 +
-+    /* Wake up the next in line.  */
++    return false;
 +    next = nodes[id].next;
 +    nodes[next].locked = 0;
 +    qemu_futex_wake(&nodes[next].locked, 1);
 +}
 +
-+static void test_multi_fair_mutex_entry(void *opaque)
+ static void ioq_init(LuringQueue *io_q)
-+{
+ {
-+    while (!atomic_mb_read(&now_stopping)) {
+     QSIMPLEQ_INIT(&io_q->submit_queue);
-+        mcs_mutex_lock();
+@@ -XXX,XX +XXX,XX @@ void luring_attach_aio_context(LuringState *s, AioContext *new_context)
-+        counter++;
+     s->aio_context = new_context;
-+        mcs_mutex_unlock();
+     s->completion_bh = aio_bh_new(new_context, qemu_luring_completion_bh, s);
-+        atomic_inc(&atomic_counter);
+     aio_set_fd_handler(s->aio_context, s->ring.ring_fd, false,
-+    }
+-                       qemu_luring_completion_cb, NULL, NULL, s);
-+    atomic_dec(&running);
++                       qemu_luring_completion_cb, NULL, qemu_luring_poll_cb, s);
 +}
 +
 +static void test_multi_fair_mutex(int threads, int seconds)
 +{
 +    int i;
 +
 +    assert(mutex_head == -1);
 +    counter = 0;
 +    atomic_counter = 0;
 +    now_stopping = false;
 +
 +    create_aio_contexts();
 +    assert(threads <= NUM_CONTEXTS);
 +    running = threads;
 +    for (i = 0; i < threads; i++) {
 +        Coroutine *co1 = qemu_coroutine_create(test_multi_fair_mutex_entry, NULL);
 +        aio_co_schedule(ctx[i], co1);
 +    }
 +
 +    g_usleep(seconds * 1000000);
 +
 +    atomic_mb_set(&now_stopping, true);
 +    while (running > 0) {
 +        g_usleep(100000);
 +    }
 +
 +    join_aio_contexts();
 +    g_test_message("%d iterations/second\n", counter / seconds);
 +    g_assert_cmpint(counter, ==, atomic_counter);
 +}
 +
 +static void test_multi_fair_mutex_1(void)
 +{
 +    test_multi_fair_mutex(NUM_CONTEXTS, 1);
 +}
 +
 +static void test_multi_fair_mutex_10(void)
 +{
 +    test_multi_fair_mutex(NUM_CONTEXTS, 10);
 +}
 +#endif
 +
 +/* Same test with pthread mutexes, for performance comparison and
 + * portability.  */
 +
 +static QemuMutex mutex;
 +
 +static void test_multi_mutex_entry(void *opaque)
 +{
 +    while (!atomic_mb_read(&now_stopping)) {
 +        qemu_mutex_lock(&mutex);
 +        counter++;
 +        qemu_mutex_unlock(&mutex);
 +        atomic_inc(&atomic_counter);
 +    }
 +    atomic_dec(&running);
 +}
 +
 +static void test_multi_mutex(int threads, int seconds)
 +{
 +    int i;
 +
 +    qemu_mutex_init(&mutex);
 +    counter = 0;
 +    atomic_counter = 0;
 +    now_stopping = false;
 +
 +    create_aio_contexts();
 +    assert(threads <= NUM_CONTEXTS);
 +    running = threads;
 +    for (i = 0; i < threads; i++) {
 +        Coroutine *co1 = qemu_coroutine_create(test_multi_mutex_entry, NULL);
 +        aio_co_schedule(ctx[i], co1);
 +    }
 +
 +    g_usleep(seconds * 1000000);
 +
 +    atomic_mb_set(&now_stopping, true);
 +    while (running > 0) {
 +        g_usleep(100000);
 +    }
 +
 +    join_aio_contexts();
 +    g_test_message("%d iterations/second\n", counter / seconds);
 +    g_assert_cmpint(counter, ==, atomic_counter);
 +}
 +
 +static void test_multi_mutex_1(void)
 +{
 +    test_multi_mutex(NUM_CONTEXTS, 1);
 +}
 +
 +static void test_multi_mutex_10(void)
 +{
 +    test_multi_mutex(NUM_CONTEXTS, 10);
 +}
 +
  /* End of tests.  */
  int main(int argc, char **argv)
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
          g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
          g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
          g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
 +#ifdef CONFIG_LINUX
 +        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_1);
 +#endif
 +        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_1);
      } else {
          g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
          g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
          g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
 +#ifdef CONFIG_LINUX
 +        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_10);
 +#endif
 +        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_10);
      }
      return g_test_run();
  }
+ LuringState *luring_init(Error **errp)
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 04/24] test-thread-pool: use generic AioContext infrastructure
+[PULL 14/18] qemu-io: adds option to use aio engine
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Once the thread pool starts using aio_co_wake, it will also need
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-qemu_get_current_aio_context().  Make test-thread-pool create
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-an AioContext with qemu_init_main_loop, so that stubs/iothread.c
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-and tests/iothread.c can provide the rest.
+Message-id: 20200120141858.587874-12-stefanha@redhat.com
+Message-Id: <20200120141858.587874-12-stefanha@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213135235.12274-5-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/test-thread-pool.c | 12 +++---------
+ qemu-io.c | 25 +++++++++++++++++++++----
-file changed, 3 insertions(+), 9 deletions(-)
+file changed, 21 insertions(+), 4 deletions(-)
-diff --git a/tests/test-thread-pool.c b/tests/test-thread-pool.c
+diff --git a/qemu-io.c b/qemu-io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-thread-pool.c
+--- a/qemu-io.c
-+++ b/tests/test-thread-pool.c
++++ b/qemu-io.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void open_help(void)
- #include "qapi/error.h"
+ " -C, -- use copy-on-read\n"
- #include "qemu/timer.h"
+ " -n, -- disable host cache, short for -t none\n"
- #include "qemu/error-report.h"
+ " -U, -- force shared permissions\n"
-+#include "qemu/main-loop.h"
+-" -k, -- use kernel AIO implementation (on Linux only)\n"
++" -k, -- use kernel AIO implementation (Linux only, prefer use of -i)\n"
- static AioContext *ctx;
++" -i, -- use AIO mode (threads, native or io_uring)\n"
- static ThreadPool *pool;
+ " -t, -- use the given cache mode for the image\n"
-@@ -XXX,XX +XXX,XX @@ static void test_cancel_async(void)
+ " -d, -- use the given discard mode for the image\n"
  " -o, -- options to be given to the block driver"
@@ -XXX,XX +XXX,XX @@ static int open_f(BlockBackend *blk, int argc, char **argv)
      QDict *opts;
      bool force_share = false;
 -    while ((c = getopt(argc, argv, "snCro:kt:d:U")) != -1) {
 +    while ((c = getopt(argc, argv, "snCro:ki:t:d:U")) != -1) {
          switch (c) {
          case 's':
              flags |= BDRV_O_SNAPSHOT;
@@ -XXX,XX +XXX,XX @@ 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");
@@ -XXX,XX +XXX,XX @@ 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"
 +"  -k, --native-aio     use kernel AIO implementation\n"
 +"                       (Linux only, prefer use of -i)\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"
@@ -XXX,XX +XXX,XX @@ static QemuOptsList file_opts = {
  int main(int argc, char **argv)
  {
-     int ret;
+     int readonly = 0;
--    Error *local_error = NULL;
+-    const char *sopt = "hVc:d:f:rsnCmkt:T:U";
++    const char *sopt = "hVc:d:f:rsnCmki:t:T:U";
--    init_clocks();
+     const struct option lopt[] = {
--
+         { "help", no_argument, NULL, 'h' },
--    ctx = aio_context_new(&local_error);
+         { "version", no_argument, NULL, 'V' },
 -    if (!ctx) {
 -        error_reportf_err(local_error, "Failed to create AIO Context: ");
 -        exit(1);
 -    }
 +    qemu_init_main_loop(&error_abort);
 +    ctx = qemu_get_current_aio_context();
      pool = aio_get_thread_pool(ctx);
      g_test_init(&argc, &argv, NULL);
 @@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
+         { "copy-on-read", no_argument, NULL, 'C' },
-     ret = g_test_run();
+         { "misalign", no_argument, NULL, 'm' },
+         { "native-aio", no_argument, NULL, 'k' },
--    aio_context_unref(ctx);
++        { "aio", required_argument, NULL, 'i' },
-     return ret;
+         { "discard", required_argument, NULL, 'd' },
- }
+         { "cache", required_argument, NULL, 't' },
          { "trace", required_argument, NULL, 'T' },
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
          case 'k':
              flags |= BDRV_O_NATIVE_AIO;
              break;
 +        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) {
                  error_report("Invalid cache option: %s", optarg);
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 06/24] io: make qio_channel_yield aware of AioContexts
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-Support separate coroutines for reading and writing, and place the
-read/write handlers on the AioContext that the QIOChannel is registered
-with.
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Message-id: 20170213135235.12274-7-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- include/io/channel.h | 47 ++++++++++++++++++++++++++--
- io/channel.c         | 86 +++++++++++++++++++++++++++++++++++++++-------------
-files changed, 109 insertions(+), 24 deletions(-)
-diff --git a/include/io/channel.h b/include/io/channel.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/io/channel.h
-+++ b/include/io/channel.h
-@@ -XXX,XX +XXX,XX @@
- #include "qemu-common.h"
- #include "qom/object.h"
-+#include "qemu/coroutine.h"
- #include "block/aio.h"
- #define TYPE_QIO_CHANNEL "qio-channel"
-@@ -XXX,XX +XXX,XX @@ struct QIOChannel {
-     Object parent;
-     unsigned int features; /* bitmask of QIOChannelFeatures */
-     char *name;
-+    AioContext *ctx;
-+    Coroutine *read_coroutine;
-+    Coroutine *write_coroutine;
- #ifdef _WIN32
-     HANDLE event; /* For use with GSource on Win32 */
- #endif
-@@ -XXX,XX +XXX,XX @@ guint qio_channel_add_watch(QIOChannel *ioc,
- /**
-+ * qio_channel_attach_aio_context:
-+ * @ioc: the channel object
-+ * @ctx: the #AioContext to set the handlers on
-+ *
-+ * Request that qio_channel_yield() sets I/O handlers on
-+ * the given #AioContext.  If @ctx is %NULL, qio_channel_yield()
-+ * uses QEMU's main thread event loop.
-+ *
-+ * You can move a #QIOChannel from one #AioContext to another even if
-+ * I/O handlers are set for a coroutine.  However, #QIOChannel provides
-+ * no synchronization between the calls to qio_channel_yield() and
-+ * qio_channel_attach_aio_context().
-+ *
-+ * Therefore you should first call qio_channel_detach_aio_context()
-+ * to ensure that the coroutine is not entered concurrently.  Then,
-+ * while the coroutine has yielded, call qio_channel_attach_aio_context(),
-+ * and then aio_co_schedule() to place the coroutine on the new
-+ * #AioContext.  The calls to qio_channel_detach_aio_context()
-+ * and qio_channel_attach_aio_context() should be protected with
-+ * aio_context_acquire() and aio_context_release().
-+ */
-+void qio_channel_attach_aio_context(QIOChannel *ioc,
-+                                    AioContext *ctx);
-+
-+/**
-+ * qio_channel_detach_aio_context:
-+ * @ioc: the channel object
-+ *
-+ * Disable any I/O handlers set by qio_channel_yield().  With the
-+ * help of aio_co_schedule(), this allows moving a coroutine that was
-+ * paused by qio_channel_yield() to another context.
-+ */
-+void qio_channel_detach_aio_context(QIOChannel *ioc);
-+
-+/**
-  * qio_channel_yield:
-  * @ioc: the channel object
-  * @condition: the I/O condition to wait for
-  *
-- * Yields execution from the current coroutine until
-- * the condition indicated by @condition becomes
-- * available.
-+ * Yields execution from the current coroutine until the condition
-+ * indicated by @condition becomes available.  @condition must
-+ * be either %G_IO_IN or %G_IO_OUT; it cannot contain both.  In
-+ * addition, no two coroutine can be waiting on the same condition
-+ * and channel at the same time.
-  *
-  * This must only be called from coroutine context
-  */
-diff --git a/io/channel.c b/io/channel.c
-index XXXXXXX..XXXXXXX 100644
---- a/io/channel.c
-+++ b/io/channel.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/osdep.h"
- #include "io/channel.h"
- #include "qapi/error.h"
--#include "qemu/coroutine.h"
-+#include "qemu/main-loop.h"
- bool qio_channel_has_feature(QIOChannel *ioc,
-                              QIOChannelFeature feature)
-@@ -XXX,XX +XXX,XX @@ off_t qio_channel_io_seek(QIOChannel *ioc,
- }
--typedef struct QIOChannelYieldData QIOChannelYieldData;
--struct QIOChannelYieldData {
--    QIOChannel *ioc;
--    Coroutine *co;
--};
-+static void qio_channel_set_aio_fd_handlers(QIOChannel *ioc);
-+static void qio_channel_restart_read(void *opaque)
-+{
-+    QIOChannel *ioc = opaque;
-+    Coroutine *co = ioc->read_coroutine;
-+
-+    ioc->read_coroutine = NULL;
-+    qio_channel_set_aio_fd_handlers(ioc);
-+    aio_co_wake(co);
-+}
--static gboolean qio_channel_yield_enter(QIOChannel *ioc,
--                                        GIOCondition condition,
--                                        gpointer opaque)
-+static void qio_channel_restart_write(void *opaque)
- {
--    QIOChannelYieldData *data = opaque;
--    qemu_coroutine_enter(data->co);
--    return FALSE;
-+    QIOChannel *ioc = opaque;
-+    Coroutine *co = ioc->write_coroutine;
-+
-+    ioc->write_coroutine = NULL;
-+    qio_channel_set_aio_fd_handlers(ioc);
-+    aio_co_wake(co);
- }
-+static void qio_channel_set_aio_fd_handlers(QIOChannel *ioc)
-+{
-+    IOHandler *rd_handler = NULL, *wr_handler = NULL;
-+    AioContext *ctx;
-+
-+    if (ioc->read_coroutine) {
-+        rd_handler = qio_channel_restart_read;
-+    }
-+    if (ioc->write_coroutine) {
-+        wr_handler = qio_channel_restart_write;
-+    }
-+
-+    ctx = ioc->ctx ? ioc->ctx : iohandler_get_aio_context();
-+    qio_channel_set_aio_fd_handler(ioc, ctx, rd_handler, wr_handler, ioc);
-+}
-+
-+void qio_channel_attach_aio_context(QIOChannel *ioc,
-+                                    AioContext *ctx)
-+{
-+    AioContext *old_ctx;
-+    if (ioc->ctx == ctx) {
-+        return;
-+    }
-+
-+    old_ctx = ioc->ctx ? ioc->ctx : iohandler_get_aio_context();
-+    qio_channel_set_aio_fd_handler(ioc, old_ctx, NULL, NULL, NULL);
-+    ioc->ctx = ctx;
-+    qio_channel_set_aio_fd_handlers(ioc);
-+}
-+
-+void qio_channel_detach_aio_context(QIOChannel *ioc)
-+{
-+    ioc->read_coroutine = NULL;
-+    ioc->write_coroutine = NULL;
-+    qio_channel_set_aio_fd_handlers(ioc);
-+    ioc->ctx = NULL;
-+}
- void coroutine_fn qio_channel_yield(QIOChannel *ioc,
-                                     GIOCondition condition)
- {
--    QIOChannelYieldData data;
--
-     assert(qemu_in_coroutine());
--    data.ioc = ioc;
--    data.co = qemu_coroutine_self();
--    qio_channel_add_watch(ioc,
--                          condition,
--                          qio_channel_yield_enter,
--                          &data,
--                          NULL);
-+    if (condition == G_IO_IN) {
-+        assert(!ioc->read_coroutine);
-+        ioc->read_coroutine = qemu_coroutine_self();
-+    } else if (condition == G_IO_OUT) {
-+        assert(!ioc->write_coroutine);
-+        ioc->write_coroutine = qemu_coroutine_self();
-+    } else {
-+        abort();
-+    }
-+    qio_channel_set_aio_fd_handlers(ioc);
-     qemu_coroutine_yield();
- }
---
-.9.3

-[Qemu-devel] [PULL 07/24] nbd: convert to use qio_channel_yield
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-In the client, read the reply headers from a coroutine, switching the
-read side between the "read header" coroutine and the I/O coroutine that
-reads the body of the reply.
-In the server, if the server can read more requests it will create a new
-"read request" coroutine as soon as a request has been read.  Otherwise,
-the new coroutine is created in nbd_request_put.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Message-id: 20170213135235.12274-8-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- block/nbd-client.h |   2 +-
- block/nbd-client.c | 117 ++++++++++++++++++++++++-----------------------------
- nbd/client.c       |   2 +-
- nbd/common.c       |   9 +----
- nbd/server.c       |  94 +++++++++++++-----------------------------
-files changed, 83 insertions(+), 141 deletions(-)
-diff --git a/block/nbd-client.h b/block/nbd-client.h
-index XXXXXXX..XXXXXXX 100644
---- a/block/nbd-client.h
-+++ b/block/nbd-client.h
-@@ -XXX,XX +XXX,XX @@ typedef struct NBDClientSession {
-     CoMutex send_mutex;
-     CoQueue free_sema;
--    Coroutine *send_coroutine;
-+    Coroutine *read_reply_co;
-     int in_flight;
-     Coroutine *recv_coroutine[MAX_NBD_REQUESTS];
-diff --git a/block/nbd-client.c b/block/nbd-client.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/nbd-client.c
-+++ b/block/nbd-client.c
-@@ -XXX,XX +XXX,XX @@
- #define HANDLE_TO_INDEX(bs, handle) ((handle) ^ ((uint64_t)(intptr_t)bs))
- #define INDEX_TO_HANDLE(bs, index)  ((index)  ^ ((uint64_t)(intptr_t)bs))
--static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
-+static void nbd_recv_coroutines_enter_all(BlockDriverState *bs)
- {
-+    NBDClientSession *s = nbd_get_client_session(bs);
-     int i;
-     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
-@@ -XXX,XX +XXX,XX @@ static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
-             qemu_coroutine_enter(s->recv_coroutine[i]);
-         }
-     }
-+    BDRV_POLL_WHILE(bs, s->read_reply_co);
- }
- static void nbd_teardown_connection(BlockDriverState *bs)
-@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
-     qio_channel_shutdown(client->ioc,
-                          QIO_CHANNEL_SHUTDOWN_BOTH,
-                          NULL);
--    nbd_recv_coroutines_enter_all(client);
-+    nbd_recv_coroutines_enter_all(bs);
-     nbd_client_detach_aio_context(bs);
-     object_unref(OBJECT(client->sioc));
-@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
-     client->ioc = NULL;
- }
--static void nbd_reply_ready(void *opaque)
-+static coroutine_fn void nbd_read_reply_entry(void *opaque)
- {
--    BlockDriverState *bs = opaque;
--    NBDClientSession *s = nbd_get_client_session(bs);
-+    NBDClientSession *s = opaque;
-     uint64_t i;
-     int ret;
--    if (!s->ioc) { /* Already closed */
--        return;
--    }
--
--    if (s->reply.handle == 0) {
--        /* No reply already in flight.  Fetch a header.  It is possible
--         * that another thread has done the same thing in parallel, so
--         * the socket is not readable anymore.
--         */
-+    for (;;) {
-+        assert(s->reply.handle == 0);
-         ret = nbd_receive_reply(s->ioc, &s->reply);
--        if (ret == -EAGAIN) {
--            return;
--        }
-         if (ret < 0) {
--            s->reply.handle = 0;
--            goto fail;
-+            break;
-         }
--    }
--    /* There's no need for a mutex on the receive side, because the
--     * handler acts as a synchronization point and ensures that only
--     * one coroutine is called until the reply finishes.  */
--    i = HANDLE_TO_INDEX(s, s->reply.handle);
--    if (i >= MAX_NBD_REQUESTS) {
--        goto fail;
--    }
-+        /* There's no need for a mutex on the receive side, because the
-+         * handler acts as a synchronization point and ensures that only
-+         * one coroutine is called until the reply finishes.
-+         */
-+        i = HANDLE_TO_INDEX(s, s->reply.handle);
-+        if (i >= MAX_NBD_REQUESTS || !s->recv_coroutine[i]) {
-+            break;
-+        }
--    if (s->recv_coroutine[i]) {
--        qemu_coroutine_enter(s->recv_coroutine[i]);
--        return;
-+        /* We're woken up by the recv_coroutine itself.  Note that there
-+         * is no race between yielding and reentering read_reply_co.  This
-+         * is because:
-+         *
-+         * - if recv_coroutine[i] runs on the same AioContext, it is only
-+         *   entered after we yield
-+         *
-+         * - if recv_coroutine[i] runs on a different AioContext, reentering
-+         *   read_reply_co happens through a bottom half, which can only
-+         *   run after we yield.
-+         */
-+        aio_co_wake(s->recv_coroutine[i]);
-+        qemu_coroutine_yield();
-     }
--
--fail:
--    nbd_teardown_connection(bs);
--}
--
--static void nbd_restart_write(void *opaque)
--{
--    BlockDriverState *bs = opaque;
--
--    qemu_coroutine_enter(nbd_get_client_session(bs)->send_coroutine);
-+    s->read_reply_co = NULL;
- }
- static int nbd_co_send_request(BlockDriverState *bs,
-@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
-                                QEMUIOVector *qiov)
- {
-     NBDClientSession *s = nbd_get_client_session(bs);
--    AioContext *aio_context;
-     int rc, ret, i;
-     qemu_co_mutex_lock(&s->send_mutex);
-@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
-         return -EPIPE;
-     }
--    s->send_coroutine = qemu_coroutine_self();
--    aio_context = bdrv_get_aio_context(bs);
--
--    aio_set_fd_handler(aio_context, s->sioc->fd, false,
--                       nbd_reply_ready, nbd_restart_write, NULL, bs);
-     if (qiov) {
-         qio_channel_set_cork(s->ioc, true);
-         rc = nbd_send_request(s->ioc, request);
-@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
-     } else {
-         rc = nbd_send_request(s->ioc, request);
-     }
--    aio_set_fd_handler(aio_context, s->sioc->fd, false,
--                       nbd_reply_ready, NULL, NULL, bs);
--    s->send_coroutine = NULL;
-     qemu_co_mutex_unlock(&s->send_mutex);
-     return rc;
- }
-@@ -XXX,XX +XXX,XX @@ static void nbd_co_receive_reply(NBDClientSession *s,
- {
-     int ret;
--    /* Wait until we're woken up by the read handler.  TODO: perhaps
--     * peek at the next reply and avoid yielding if it's ours?  */
-+    /* Wait until we're woken up by nbd_read_reply_entry.  */
-     qemu_coroutine_yield();
-     *reply = s->reply;
-     if (reply->handle != request->handle ||
-@@ -XXX,XX +XXX,XX @@ static void nbd_coroutine_start(NBDClientSession *s,
-     /* s->recv_coroutine[i] is set as soon as we get the send_lock.  */
- }
--static void nbd_coroutine_end(NBDClientSession *s,
-+static void nbd_coroutine_end(BlockDriverState *bs,
-                               NBDRequest *request)
- {
-+    NBDClientSession *s = nbd_get_client_session(bs);
-     int i = HANDLE_TO_INDEX(s, request->handle);
-+
-     s->recv_coroutine[i] = NULL;
--    if (s->in_flight-- == MAX_NBD_REQUESTS) {
--        qemu_co_queue_next(&s->free_sema);
-+    s->in_flight--;
-+    qemu_co_queue_next(&s->free_sema);
-+
-+    /* Kick the read_reply_co to get the next reply.  */
-+    if (s->read_reply_co) {
-+        aio_co_wake(s->read_reply_co);
-     }
- }
-@@ -XXX,XX +XXX,XX @@ int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
-     } else {
-         nbd_co_receive_reply(client, &request, &reply, qiov);
-     }
--    nbd_coroutine_end(client, &request);
-+    nbd_coroutine_end(bs, &request);
-     return -reply.error;
- }
-@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
-     } else {
-         nbd_co_receive_reply(client, &request, &reply, NULL);
-     }
--    nbd_coroutine_end(client, &request);
-+    nbd_coroutine_end(bs, &request);
-     return -reply.error;
- }
-@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
-     } else {
-         nbd_co_receive_reply(client, &request, &reply, NULL);
-     }
--    nbd_coroutine_end(client, &request);
-+    nbd_coroutine_end(bs, &request);
-     return -reply.error;
- }
-@@ -XXX,XX +XXX,XX @@ int nbd_client_co_flush(BlockDriverState *bs)
-     } else {
-         nbd_co_receive_reply(client, &request, &reply, NULL);
-     }
--    nbd_coroutine_end(client, &request);
-+    nbd_coroutine_end(bs, &request);
-     return -reply.error;
- }
-@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
-     } else {
-         nbd_co_receive_reply(client, &request, &reply, NULL);
-     }
--    nbd_coroutine_end(client, &request);
-+    nbd_coroutine_end(bs, &request);
-     return -reply.error;
- }
- void nbd_client_detach_aio_context(BlockDriverState *bs)
- {
--    aio_set_fd_handler(bdrv_get_aio_context(bs),
--                       nbd_get_client_session(bs)->sioc->fd,
--                       false, NULL, NULL, NULL, NULL);
-+    NBDClientSession *client = nbd_get_client_session(bs);
-+    qio_channel_detach_aio_context(QIO_CHANNEL(client->sioc));
- }
- void nbd_client_attach_aio_context(BlockDriverState *bs,
-                                    AioContext *new_context)
- {
--    aio_set_fd_handler(new_context, nbd_get_client_session(bs)->sioc->fd,
--                       false, nbd_reply_ready, NULL, NULL, bs);
-+    NBDClientSession *client = nbd_get_client_session(bs);
-+    qio_channel_attach_aio_context(QIO_CHANNEL(client->sioc), new_context);
-+    aio_co_schedule(new_context, client->read_reply_co);
- }
- void nbd_client_close(BlockDriverState *bs)
-@@ -XXX,XX +XXX,XX @@ int nbd_client_init(BlockDriverState *bs,
-     /* Now that we're connected, set the socket to be non-blocking and
-      * kick the reply mechanism.  */
-     qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
--
-+    client->read_reply_co = qemu_coroutine_create(nbd_read_reply_entry, client);
-     nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
-     logout("Established connection with NBD server\n");
-diff --git a/nbd/client.c b/nbd/client.c
-index XXXXXXX..XXXXXXX 100644
---- a/nbd/client.c
-+++ b/nbd/client.c
-@@ -XXX,XX +XXX,XX @@ ssize_t nbd_receive_reply(QIOChannel *ioc, NBDReply *reply)
-     ssize_t ret;
-     ret = read_sync(ioc, buf, sizeof(buf));
--    if (ret < 0) {
-+    if (ret <= 0) {
-         return ret;
-     }
-diff --git a/nbd/common.c b/nbd/common.c
-index XXXXXXX..XXXXXXX 100644
---- a/nbd/common.c
-+++ b/nbd/common.c
-@@ -XXX,XX +XXX,XX @@ ssize_t nbd_wr_syncv(QIOChannel *ioc,
-         }
-         if (len == QIO_CHANNEL_ERR_BLOCK) {
-             if (qemu_in_coroutine()) {
--                /* XXX figure out if we can create a variant on
--                 * qio_channel_yield() that works with AIO contexts
--                 * and consider using that in this branch */
--                qemu_coroutine_yield();
--            } else if (done) {
--                /* XXX this is needed by nbd_reply_ready.  */
--                qio_channel_wait(ioc,
--                                 do_read ? G_IO_IN : G_IO_OUT);
-+                qio_channel_yield(ioc, do_read ? G_IO_IN : G_IO_OUT);
-             } else {
-                 return -EAGAIN;
-             }
-diff --git a/nbd/server.c b/nbd/server.c
-index XXXXXXX..XXXXXXX 100644
---- a/nbd/server.c
-+++ b/nbd/server.c
-@@ -XXX,XX +XXX,XX @@ struct NBDClient {
-     CoMutex send_lock;
-     Coroutine *send_coroutine;
--    bool can_read;
--
-     QTAILQ_ENTRY(NBDClient) next;
-     int nb_requests;
-     bool closing;
-@@ -XXX,XX +XXX,XX @@ struct NBDClient {
- /* That's all folks */
--static void nbd_set_handlers(NBDClient *client);
--static void nbd_unset_handlers(NBDClient *client);
--static void nbd_update_can_read(NBDClient *client);
-+static void nbd_client_receive_next_request(NBDClient *client);
- static gboolean nbd_negotiate_continue(QIOChannel *ioc,
-                                        GIOCondition condition,
-@@ -XXX,XX +XXX,XX @@ void nbd_client_put(NBDClient *client)
-          */
-         assert(client->closing);
--        nbd_unset_handlers(client);
-+        qio_channel_detach_aio_context(client->ioc);
-         object_unref(OBJECT(client->sioc));
-         object_unref(OBJECT(client->ioc));
-         if (client->tlscreds) {
-@@ -XXX,XX +XXX,XX @@ static NBDRequestData *nbd_request_get(NBDClient *client)
-     assert(client->nb_requests <= MAX_NBD_REQUESTS - 1);
-     client->nb_requests++;
--    nbd_update_can_read(client);
-     req = g_new0(NBDRequestData, 1);
-     nbd_client_get(client);
-@@ -XXX,XX +XXX,XX @@ static void nbd_request_put(NBDRequestData *req)
-     g_free(req);
-     client->nb_requests--;
--    nbd_update_can_read(client);
-+    nbd_client_receive_next_request(client);
-+
-     nbd_client_put(client);
- }
-@@ -XXX,XX +XXX,XX @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
-     exp->ctx = ctx;
-     QTAILQ_FOREACH(client, &exp->clients, next) {
--        nbd_set_handlers(client);
-+        qio_channel_attach_aio_context(client->ioc, ctx);
-+        if (client->recv_coroutine) {
-+            aio_co_schedule(ctx, client->recv_coroutine);
-+        }
-+        if (client->send_coroutine) {
-+            aio_co_schedule(ctx, client->send_coroutine);
-+        }
-     }
- }
-@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)
-     TRACE("Export %s: Detaching clients from AIO context %p\n", exp->name, exp->ctx);
-     QTAILQ_FOREACH(client, &exp->clients, next) {
--        nbd_unset_handlers(client);
-+        qio_channel_detach_aio_context(client->ioc);
-     }
-     exp->ctx = NULL;
-@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_send_reply(NBDRequestData *req, NBDReply *reply,
-     g_assert(qemu_in_coroutine());
-     qemu_co_mutex_lock(&client->send_lock);
-     client->send_coroutine = qemu_coroutine_self();
--    nbd_set_handlers(client);
-     if (!len) {
-         rc = nbd_send_reply(client->ioc, reply);
-@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_send_reply(NBDRequestData *req, NBDReply *reply,
-     }
-     client->send_coroutine = NULL;
--    nbd_set_handlers(client);
-     qemu_co_mutex_unlock(&client->send_lock);
-     return rc;
- }
-@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_receive_request(NBDRequestData *req,
-     ssize_t rc;
-     g_assert(qemu_in_coroutine());
--    client->recv_coroutine = qemu_coroutine_self();
--    nbd_update_can_read(client);
--
-+    assert(client->recv_coroutine == qemu_coroutine_self());
-     rc = nbd_receive_request(client->ioc, request);
-     if (rc < 0) {
-         if (rc != -EAGAIN) {
-@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_receive_request(NBDRequestData *req,
- out:
-     client->recv_coroutine = NULL;
--    nbd_update_can_read(client);
-+    nbd_client_receive_next_request(client);
-     return rc;
- }
--static void nbd_trip(void *opaque)
-+/* Owns a reference to the NBDClient passed as opaque.  */
-+static coroutine_fn void nbd_trip(void *opaque)
- {
-     NBDClient *client = opaque;
-     NBDExport *exp = client->exp;
-     NBDRequestData *req;
--    NBDRequest request;
-+    NBDRequest request = { 0 };    /* GCC thinks it can be used uninitialized */
-     NBDReply reply;
-     ssize_t ret;
-     int flags;
-     TRACE("Reading request.");
-     if (client->closing) {
-+        nbd_client_put(client);
-         return;
-     }
-@@ -XXX,XX +XXX,XX @@ static void nbd_trip(void *opaque)
- done:
-     nbd_request_put(req);
-+    nbd_client_put(client);
-     return;
- out:
-     nbd_request_put(req);
-     client_close(client);
-+    nbd_client_put(client);
- }
--static void nbd_read(void *opaque)
-+static void nbd_client_receive_next_request(NBDClient *client)
- {
--    NBDClient *client = opaque;
--
--    if (client->recv_coroutine) {
--        qemu_coroutine_enter(client->recv_coroutine);
--    } else {
--        qemu_coroutine_enter(qemu_coroutine_create(nbd_trip, client));
--    }
--}
--
--static void nbd_restart_write(void *opaque)
--{
--    NBDClient *client = opaque;
--
--    qemu_coroutine_enter(client->send_coroutine);
--}
--
--static void nbd_set_handlers(NBDClient *client)
--{
--    if (client->exp && client->exp->ctx) {
--        aio_set_fd_handler(client->exp->ctx, client->sioc->fd, true,
--                           client->can_read ? nbd_read : NULL,
--                           client->send_coroutine ? nbd_restart_write : NULL,
--                           NULL, client);
--    }
--}
--
--static void nbd_unset_handlers(NBDClient *client)
--{
--    if (client->exp && client->exp->ctx) {
--        aio_set_fd_handler(client->exp->ctx, client->sioc->fd, true, NULL,
--                           NULL, NULL, NULL);
--    }
--}
--
--static void nbd_update_can_read(NBDClient *client)
--{
--    bool can_read = client->recv_coroutine ||
--                    client->nb_requests < MAX_NBD_REQUESTS;
--
--    if (can_read != client->can_read) {
--        client->can_read = can_read;
--        nbd_set_handlers(client);
--
--        /* There is no need to invoke aio_notify(), since aio_set_fd_handler()
--         * in nbd_set_handlers() will have taken care of that */
-+    if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS) {
-+        nbd_client_get(client);
-+        client->recv_coroutine = qemu_coroutine_create(nbd_trip, client);
-+        aio_co_schedule(client->exp->ctx, client->recv_coroutine);
-     }
- }
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_co_client_start(void *opaque)
-         goto out;
-     }
-     qemu_co_mutex_init(&client->send_lock);
--    nbd_set_handlers(client);
-     if (exp) {
-         QTAILQ_INSERT_TAIL(&exp->clients, client, next);
-     }
-+
-+    nbd_client_receive_next_request(client);
-+
- out:
-     g_free(data);
- }
-@@ -XXX,XX +XXX,XX @@ void nbd_client_new(NBDExport *exp,
-     object_ref(OBJECT(client->sioc));
-     client->ioc = QIO_CHANNEL(sioc);
-     object_ref(OBJECT(client->ioc));
--    client->can_read = true;
-     client->close = close_fn;
-     data->client = client;
---
-.9.3

-[Qemu-devel] [PULL 08/24] coroutine-lock: reschedule coroutine on the AioContext it was running on
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-As a small step towards the introduction of multiqueue, we want
-coroutines to remain on the same AioContext that started them,
-unless they are moved explicitly with e.g. aio_co_schedule.  This patch
-avoids that coroutines switch AioContext when they use a CoMutex.
-For now it does not make much of a difference, because the CoMutex
-is not thread-safe and the AioContext itself is used to protect the
-CoMutex from concurrent access.  However, this is going to change.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Message-id: 20170213135235.12274-9-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- util/qemu-coroutine-lock.c | 5 ++---
- util/trace-events          | 1 -
-files changed, 2 insertions(+), 4 deletions(-)
-diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/qemu-coroutine-lock.c
-+++ b/util/qemu-coroutine-lock.c
-@@ -XXX,XX +XXX,XX @@
- #include "qemu/coroutine.h"
- #include "qemu/coroutine_int.h"
- #include "qemu/queue.h"
-+#include "block/aio.h"
- #include "trace.h"
- void qemu_co_queue_init(CoQueue *queue)
-@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_run_restart(Coroutine *co)
- static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
- {
--    Coroutine *self = qemu_coroutine_self();
-     Coroutine *next;
-     if (QSIMPLEQ_EMPTY(&queue->entries)) {
-@@ -XXX,XX +XXX,XX @@ static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
-     while ((next = QSIMPLEQ_FIRST(&queue->entries)) != NULL) {
-         QSIMPLEQ_REMOVE_HEAD(&queue->entries, co_queue_next);
--        QSIMPLEQ_INSERT_TAIL(&self->co_queue_wakeup, next, co_queue_next);
--        trace_qemu_co_queue_next(next);
-+        aio_co_wake(next);
-         if (single) {
-             break;
-         }
-diff --git a/util/trace-events b/util/trace-events
-index XXXXXXX..XXXXXXX 100644
---- a/util/trace-events
-+++ b/util/trace-events
-@@ -XXX,XX +XXX,XX @@ qemu_coroutine_terminate(void *co) "self %p"
- # util/qemu-coroutine-lock.c
- qemu_co_queue_run_restart(void *co) "co %p"
--qemu_co_queue_next(void *nxt) "next %p"
- qemu_co_mutex_lock_entry(void *mutex, void *self) "mutex %p self %p"
- qemu_co_mutex_lock_return(void *mutex, void *self) "mutex %p self %p"
- qemu_co_mutex_unlock_entry(void *mutex, void *self) "mutex %p self %p"
---
-.9.3

-[Qemu-devel] [PULL 09/24] blkdebug: reschedule coroutine on the AioContext it is running on
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-Keep the coroutine on the same AioContext.  Without this change,
-there would be a race between yielding the coroutine and reentering it.
-While the race cannot happen now, because the code only runs from a single
-AioContext, this will change with multiqueue support in the block layer.
-While doing the change, replace custom bottom half with aio_co_schedule.
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Message-id: 20170213135235.12274-10-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- block/blkdebug.c | 9 +--------
-file changed, 1 insertion(+), 8 deletions(-)
-diff --git a/block/blkdebug.c b/block/blkdebug.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/blkdebug.c
-+++ b/block/blkdebug.c
-@@ -XXX,XX +XXX,XX @@ out:
-     return ret;
- }
--static void error_callback_bh(void *opaque)
--{
--    Coroutine *co = opaque;
--    qemu_coroutine_enter(co);
--}
--
- static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)
- {
-     BDRVBlkdebugState *s = bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)
-     }
-     if (!immediately) {
--        aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), error_callback_bh,
--                                qemu_coroutine_self());
-+        aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self());
-         qemu_coroutine_yield();
-     }
---
-.9.3

-[Qemu-devel] [PULL 20/24] coroutine-lock: add limited spinning to CoMutex
+[PULL 15/18] qemu-img: adds option to use aio engine for benchmarking
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Running a very small critical section on pthread_mutex_t and CoMutex
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-shows that pthread_mutex_t is much faster because it doesn't actually
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-go to sleep.  What happens is that the critical section is shorter
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-than the latency of entering the kernel and thus FUTEX_WAIT always
+Message-id: 20200120141858.587874-13-stefanha@redhat.com
-fails.  With CoMutex there is no such latency but you still want to
+Message-Id: <20200120141858.587874-13-stefanha@redhat.com>
 avoid wait and wakeup.  So introduce it artificially.
 This only works with one waiters; because CoMutex is fair, it will
 always have more waits and wakeups than a pthread_mutex_t.
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Message-id: 20170213181244.16297-3-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/coroutine.h   |  5 +++++
+ qemu-img-cmds.hx |  4 ++--
- util/qemu-coroutine-lock.c | 51 ++++++++++++++++++++++++++++++++++++++++------
+ qemu-img.c       | 11 ++++++++++-
- util/qemu-coroutine.c      |  2 +-
+ qemu-img.texi    |  5 ++++-
-files changed, 51 insertions(+), 7 deletions(-)
+files changed, 16 insertions(+), 4 deletions(-)
-diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
+diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/coroutine.h
+--- a/qemu-img-cmds.hx
-+++ b/include/qemu/coroutine.h
++++ b/qemu-img-cmds.hx
-@@ -XXX,XX +XXX,XX @@ typedef struct CoMutex {
+@@ -XXX,XX +XXX,XX @@ STEXI
-      */
+ ETEXI
-     unsigned locked;
+ DEF("bench", img_bench,
-+    /* Context that is holding the lock.  Useful to avoid spinning
+-    "bench [-c count] [-d depth] [-f fmt] [--flush-interval=flush_interval] [-n] [--no-drain] [-o offset] [--pattern=pattern] [-q] [-s buffer_size] [-S step_size] [-t cache] [-w] [-U] filename")
-+     * when two coroutines on the same AioContext try to get the lock. :)
++    "bench [-c count] [-d depth] [-f fmt] [--flush-interval=flush_interval] [-n] [--no-drain] [-o offset] [--pattern=pattern] [-q] [-s buffer_size] [-S step_size] [-t cache] [-i aio] [-w] [-U] filename")
-+     */
+ STEXI
-+    AioContext *ctx;
+-@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
-+
++@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-i @var{aio}] [-w] [-U] @var{filename}
-     /* A queue of waiters.  Elements are added atomically in front of
+ ETEXI
-      * from_push.  to_pop is only populated, and popped from, by whoever
-      * is in charge of the next wakeup.  This can be an unlocker or,
+ DEF("check", img_check,
-diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
+diff --git a/qemu-img.c b/qemu-img.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/qemu-coroutine-lock.c
+--- a/qemu-img.c
-+++ b/util/qemu-coroutine-lock.c
++++ b/qemu-img.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)
- #include "qemu-common.h"
+             {"force-share", no_argument, 0, 'U'},
- #include "qemu/coroutine.h"
+             {0, 0, 0, 0}
- #include "qemu/coroutine_int.h"
+         };
-+#include "qemu/processor.h"
+-        c = getopt_long(argc, argv, ":hc:d:f:no:qs:S:t:wU", long_options, NULL);
- #include "qemu/queue.h"
++        c = getopt_long(argc, argv, ":hc:d:f:ni:o:qs:S:t:wU", long_options,
- #include "block/aio.h"
++                        NULL);
- #include "trace.h"
+         if (c == -1) {
@@ -XXX,XX +XXX,XX @@ void qemu_co_mutex_init(CoMutex *mutex)
      memset(mutex, 0, sizeof(*mutex));
  }
 -static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
 +static void coroutine_fn qemu_co_mutex_wake(CoMutex *mutex, Coroutine *co)
 +{
 +    /* Read co before co->ctx; pairs with smp_wmb() in
 +     * qemu_coroutine_enter().
 +     */
 +    smp_read_barrier_depends();
 +    mutex->ctx = co->ctx;
 +    aio_co_wake(co);
 +}
 +
 +static void coroutine_fn qemu_co_mutex_lock_slowpath(AioContext *ctx,
 +                                                     CoMutex *mutex)
  {
      Coroutine *self = qemu_coroutine_self();
      CoWaitRecord w;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
          if (co == self) {
              /* We got the lock ourselves!  */
              assert(to_wake == &w);
 +            mutex->ctx = ctx;
              return;
          }
 -        aio_co_wake(co);
 +        qemu_co_mutex_wake(mutex, co);
      }
      qemu_coroutine_yield();
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
  void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
  {
 +    AioContext *ctx = qemu_get_current_aio_context();
      Coroutine *self = qemu_coroutine_self();
 +    int waiters, i;
 -    if (atomic_fetch_inc(&mutex->locked) == 0) {
 +    /* Running a very small critical section on pthread_mutex_t and CoMutex
 +     * shows that pthread_mutex_t is much faster because it doesn't actually
 +     * go to sleep.  What happens is that the critical section is shorter
 +     * than the latency of entering the kernel and thus FUTEX_WAIT always
 +     * fails.  With CoMutex there is no such latency but you still want to
 +     * avoid wait and wakeup.  So introduce it artificially.
 +     */
 +    i = 0;
 +retry_fast_path:
 +    waiters = atomic_cmpxchg(&mutex->locked, 0, 1);
 +    if (waiters != 0) {
 +        while (waiters == 1 && ++i < 1000) {
 +            if (atomic_read(&mutex->ctx) == ctx) {
 +                break;
 +            }
 +            if (atomic_read(&mutex->locked) == 0) {
 +                goto retry_fast_path;
 +            }
 +            cpu_relax();
 +        }
 +        waiters = atomic_fetch_inc(&mutex->locked);
 +    }
 +
 +    if (waiters == 0) {
          /* Uncontended.  */
          trace_qemu_co_mutex_lock_uncontended(mutex, self);
 +        mutex->ctx = ctx;
      } else {
 -        qemu_co_mutex_lock_slowpath(mutex);
 +        qemu_co_mutex_lock_slowpath(ctx, mutex);
      }
      mutex->holder = self;
      self->locks_held++;
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
      assert(mutex->holder == self);
      assert(qemu_in_coroutine());
 +    mutex->ctx = NULL;
      mutex->holder = NULL;
      self->locks_held--;
      if (atomic_fetch_dec(&mutex->locked) == 1) {
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
          unsigned our_handoff;
          if (to_wake) {
 -            Coroutine *co = to_wake->co;
 -            aio_co_wake(co);
 +            qemu_co_mutex_wake(mutex, to_wake->co);
              break;
          }
+@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)
-diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
+         case 'n':
              flags |= BDRV_O_NATIVE_AIO;
              break;
 +        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':
          {
              offset = cvtnum(optarg);
 diff --git a/qemu-img.texi b/qemu-img.texi
 index XXXXXXX..XXXXXXX 100644
---- a/util/qemu-coroutine.c
+--- a/qemu-img.texi
-+++ b/util/qemu-coroutine.c
++++ b/qemu-img.texi
-@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
+@@ -XXX,XX +XXX,XX @@ Command description:
-     co->ctx = qemu_get_current_aio_context();
+ Amends the image format specific @var{options} for the image file
+ @var{filename}. Not all file formats support this operation.
-     /* Store co->ctx before anything that stores co.  Matches
--     * barrier in aio_co_wake.
+-@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
-+     * barrier in aio_co_wake and qemu_co_mutex_wake.
++@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [-i @var{aio}] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
-      */
-     smp_wmb();
+ Run a simple sequential I/O benchmark on the specified image. If @code{-w} is
  specified, a write test is performed, otherwise a read test is performed.
@@ -XXX,XX +XXX,XX @@ If @code{-n} is specified, the native AIO backend is used if possible. On
  Linux, this option only works if @code{-t none} or @code{-t directsync} is
  specified as well.
 +If @code{-i} is specified, aio option can be used to specify different AIO
 +backends: @var{threads}, @var{native} or @var{io_uring}.
 +
  For write tests, by default a buffer filled with zeros is written. This can be
  overridden with a pattern byte specified by @var{pattern}.
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 18/24] block: document fields protected by AioContext lock
+[PULL 16/18] qemu-nbd: adds option for aio engines
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Acked-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20170213135235.12274-19-pbonzini@redhat.com
+Message-id: 20200120141858.587874-14-stefanha@redhat.com
 Message-Id: <20200120141858.587874-14-stefanha@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/block_int.h      | 64 +++++++++++++++++++++++++-----------------
+ docs/interop/qemu-nbd.rst |  4 ++--
- include/sysemu/block-backend.h | 14 ++++++---
+ qemu-nbd.c                | 12 ++++--------
-files changed, 49 insertions(+), 29 deletions(-)
+files changed, 6 insertions(+), 10 deletions(-)
-diff --git a/include/block/block_int.h b/include/block/block_int.h
+diff --git a/docs/interop/qemu-nbd.rst b/docs/interop/qemu-nbd.rst
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int.h
+--- a/docs/interop/qemu-nbd.rst
-+++ b/include/block/block_int.h
++++ b/docs/interop/qemu-nbd.rst
-@@ -XXX,XX +XXX,XX @@ struct BdrvChild {
+@@ -XXX,XX +XXX,XX @@ driver options if ``--image-opts`` is specified.
-  * copied as well.
-  */
+ .. option:: --aio=AIO
- struct BlockDriverState {
--    int64_t total_sectors; /* if we are reading a disk image, give its
+-  Set the asynchronous I/O mode between ``threads`` (the default)
--                              size in sectors */
+-  and ``native`` (Linux only).
-+    /* Protected by big QEMU lock or read-only after opening.  No special
++  Set the asynchronous I/O mode between ``threads`` (the default),
-+     * locking needed during I/O...
++  ``native`` (Linux only), and ``io_uring`` (Linux 5.1+).
-+     */
-     int open_flags; /* flags used to open the file, re-used for re-open */
+ .. option:: --discard=DISCARD
-     bool read_only; /* if true, the media is read only */
-     bool encrypted; /* if true, the media is encrypted */
+diff --git a/qemu-nbd.c b/qemu-nbd.c
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      bool sg;        /* if true, the device is a /dev/sg* */
      bool probed;    /* if true, format was probed rather than specified */
 -    int copy_on_read; /* if nonzero, copy read backing sectors into image.
 -                         note this is a reference count */
 -
 -    CoQueue flush_queue;            /* Serializing flush queue */
 -    bool active_flush_req;          /* Flush request in flight? */
 -    unsigned int write_gen;         /* Current data generation */
 -    unsigned int flushed_gen;       /* Flushed write generation */
 -
      BlockDriver *drv; /* NULL means no media */
      void *opaque;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      BdrvChild *backing;
      BdrvChild *file;
 -    /* Callback before write request is processed */
 -    NotifierWithReturnList before_write_notifiers;
 -
 -    /* number of in-flight requests; overall and serialising */
 -    unsigned int in_flight;
 -    unsigned int serialising_in_flight;
 -
 -    bool wakeup;
 -
 -    /* Offset after the highest byte written to */
 -    uint64_t wr_highest_offset;
 -
      /* I/O Limits */
      BlockLimits bl;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      QTAILQ_ENTRY(BlockDriverState) bs_list;
      /* element of the list of monitor-owned BDS */
      QTAILQ_ENTRY(BlockDriverState) monitor_list;
 -    QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
      int refcnt;
 -    QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
 -
      /* operation blockers */
      QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX];
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      /* The error object in use for blocking operations on backing_hd */
      Error *backing_blocker;
 +    /* Protected by AioContext lock */
 +
 +    /* If true, copy read backing sectors into image.  Can be >1 if more
 +     * than one client has requested copy-on-read.
 +     */
 +    int copy_on_read;
 +
 +    /* If we are reading a disk image, give its size in sectors.
 +     * Generally read-only; it is written to by load_vmstate and save_vmstate,
 +     * but the block layer is quiescent during those.
 +     */
 +    int64_t total_sectors;
 +
 +    /* Callback before write request is processed */
 +    NotifierWithReturnList before_write_notifiers;
 +
 +    /* number of in-flight requests; overall and serialising */
 +    unsigned int in_flight;
 +    unsigned int serialising_in_flight;
 +
 +    bool wakeup;
 +
 +    /* Offset after the highest byte written to */
 +    uint64_t wr_highest_offset;
 +
      /* threshold limit for writes, in bytes. "High water mark". */
      uint64_t write_threshold_offset;
      NotifierWithReturn write_threshold_notifier;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      /* counter for nested bdrv_io_plug */
      unsigned io_plugged;
 +    QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
 +    CoQueue flush_queue;                  /* Serializing flush queue */
 +    bool active_flush_req;                /* Flush request in flight? */
 +    unsigned int write_gen;               /* Current data generation */
 +    unsigned int flushed_gen;             /* Flushed write generation */
 +
 +    QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
 +
 +    /* do we need to tell the quest if we have a volatile write cache? */
 +    int enable_write_cache;
 +
      int quiesce_counter;
  };
 diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/block-backend.h
+--- a/qemu-nbd.c
-+++ b/include/sysemu/block-backend.h
++++ b/qemu-nbd.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockDevOps {
+@@ -XXX,XX +XXX,XX @@ static void usage(const char *name)
-  * fields that must be public. This is in particular for QLIST_ENTRY() and
+ "                            '[ID_OR_NAME]'\n"
-  * friends so that BlockBackends can be kept in lists outside block-backend.c */
+ "  -n, --nocache             disable host cache\n"
- typedef struct BlockBackendPublic {
+ "      --cache=MODE          set cache mode (none, writeback, ...)\n"
--    /* I/O throttling.
+-"      --aio=MODE            set AIO mode (native or threads)\n"
--     * throttle_state tells us if this BlockBackend has I/O limits configured.
++"      --aio=MODE            set AIO mode (native, io_uring or threads)\n"
--     * io_limits_disabled tells us if they are currently being enforced */
+ "      --discard=MODE        set discard mode (ignore, unmap)\n"
-+    /* I/O throttling has its own locking, but also some fields are
+ "      --detect-zeroes=MODE  set detect-zeroes mode (off, on, unmap)\n"
-+     * protected by the AioContext lock.
+ "      --image-opts          treat FILE as a full set of image options\n"
-+     */
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-+
+                 exit(EXIT_FAILURE);
-+    /* Protected by AioContext lock.  */
+             }
-     CoQueue      throttled_reqs[2];
+             seen_aio = true;
-+
+-            if (!strcmp(optarg, "native")) {
-+    /* Nonzero if the I/O limits are currently being ignored; generally
+-                flags |= BDRV_O_NATIVE_AIO;
-+     * it is zero.  */
+-            } else if (!strcmp(optarg, "threads")) {
-     unsigned int io_limits_disabled;
+-                /* this is the default */
+-            } else {
-     /* The following fields are protected by the ThrottleGroup lock.
+-               error_report("invalid aio mode `%s'", optarg);
--     * See the ThrottleGroup documentation for details. */
+-               exit(EXIT_FAILURE);
-+     * See the ThrottleGroup documentation for details.
++            if (bdrv_parse_aio(optarg, &flags) < 0) {
-+     * throttle_state tells us if I/O limits are configured. */
++                error_report("Invalid aio mode '%s'", optarg);
-     ThrottleState *throttle_state;
++                exit(EXIT_FAILURE);
-     ThrottleTimers throttle_timers;
+             }
-     unsigned       pending_reqs[2];
+             break;
          case QEMU_NBD_OPT_DISCARD:
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 12/24] block: explicitly acquire aiocontext in timers that need it
+[PULL 17/18] tests/qemu-iotests: enable testing with aio options
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
+Message-id: 20200120141858.587874-15-stefanha@redhat.com
-Message-id: 20170213135235.12274-13-pbonzini@redhat.com
+Message-Id: <20200120141858.587874-15-stefanha@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qed.h                 |  3 +++
+ tests/qemu-iotests/check      | 15 ++++++++++++++-
- block/curl.c                |  2 ++
+ tests/qemu-iotests/common.rc  | 14 ++++++++++++++
- block/io.c                  |  5 +++++
+ tests/qemu-iotests/iotests.py | 12 ++++++++++--
- block/iscsi.c               |  8 ++++++--
+files changed, 38 insertions(+), 3 deletions(-)
  block/null.c                |  4 ++++
  block/qed.c                 | 12 ++++++++++++
  block/throttle-groups.c     |  2 ++
  util/aio-posix.c            |  2 --
  util/aio-win32.c            |  2 --
  util/qemu-coroutine-sleep.c |  2 +-
 files changed, 35 insertions(+), 7 deletions(-)
-diff --git a/block/qed.h b/block/qed.h
+diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/check
 +++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ sortme=false
  expunge=true
  have_test_arg=false
  cachemode=false
 +aiomode=false
  tmp="${TEST_DIR}"/$$
  rm -f $tmp.list $tmp.tmp $tmp.sed
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ s/ .*//p
          CACHEMODE_IS_DEFAULT=false
          cachemode=false
          continue
 +    elif $aiomode
 +    then
 +        AIOMODE="$r"
 +        aiomode=false
 +        continue
      fi
      xpand=true
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ testlist options
              cachemode=true
              xpand=false
              ;;
 +        -i)
 +            aiomode=true
 +            xpand=false
 +            ;;
          -T)        # deprecated timestamp option
              xpand=false
              ;;
 -
          -v)
              verbose=true
              xpand=false
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644
---- a/block/qed.h
+--- a/tests/qemu-iotests/common.rc
-+++ b/block/qed.h
++++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ enum {
+@@ -XXX,XX +XXX,XX @@ _default_cache_mode()
-  */
+         return
- typedef void QEDFindClusterFunc(void *opaque, int ret, uint64_t offset, size_t len);
+     fi
+ }
-+void qed_acquire(BDRVQEDState *s);
++_supported_aio_modes()
-+void qed_release(BDRVQEDState *s);
++{
 +    for mode; do
 +        if [ "$mode" = "$AIOMODE" ]; then
 +            return
 +        fi
 +    done
 +    _notrun "not suitable for aio mode: $AIOMODE"
 +}
 +_default_aio_mode()
 +{
 +    AIOMODE="$1"
 +    QEMU_IO="$QEMU_IO --aio $1"
 +}
  _unsupported_imgopts()
  {
 diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/iotests.py
 +++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ test_dir = os.environ.get('TEST_DIR')
  sock_dir = os.environ.get('SOCK_DIR')
  output_dir = os.environ.get('OUTPUT_DIR', '.')
  cachemode = os.environ.get('CACHEMODE')
 +aiomode = os.environ.get('AIOMODE')
  qemu_default_machine = os.environ.get('QEMU_DEFAULT_MACHINE')
  socket_scm_helper = os.environ.get('SOCKET_SCM_HELPER', 'socket_scm_helper')
@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
              options.append('file=%s' % path)
              options.append('format=%s' % format)
              options.append('cache=%s' % cachemode)
 +            options.append('aio=%s' % aiomode)
          if opts:
              options.append(opts)
@@ -XXX,XX +XXX,XX @@ def verify_cache_mode(supported_cache_modes=[]):
      if supported_cache_modes and (cachemode not in supported_cache_modes):
          notrun('not suitable for this cache mode: %s' % cachemode)
 +def verify_aio_mode(supported_aio_modes=[]):
 +    if supported_aio_modes and (aiomode not in supported_aio_modes):
 +        notrun('not suitable for this aio mode: %s' % aiomode)
 +
- /**
+ def supports_quorum():
-  * Generic callback for chaining async callbacks
+     return 'quorum' in qemu_img_pipe('--help')
-  */
-diff --git a/block/curl.c b/block/curl.c
+@@ -XXX,XX +XXX,XX @@ def execute_unittest(output, verbosity, debug):
-index XXXXXXX..XXXXXXX 100644
---- a/block/curl.c
+ def execute_test(test_function=None,
-+++ b/block/curl.c
+                  supported_fmts=[], supported_oses=['linux'],
-@@ -XXX,XX +XXX,XX @@ static void curl_multi_timeout_do(void *arg)
+-                 supported_cache_modes=[], unsupported_fmts=[],
-         return;
+-                 supported_protocols=[], unsupported_protocols=[]):
-     }
++                 supported_cache_modes=[], supported_aio_modes={},
++                 unsupported_fmts=[], supported_protocols=[],
-+    aio_context_acquire(s->aio_context);
++                 unsupported_protocols=[]):
-     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
+     """Run either unittest or script-style tests."""
-     curl_multi_check_completion(s);
+     # We are using TEST_DIR and QEMU_DEFAULT_MACHINE as proxies to
-+    aio_context_release(s->aio_context);
+@@ -XXX,XX +XXX,XX @@ def execute_test(test_function=None,
- #else
+     verify_protocol(supported_protocols, unsupported_protocols)
-     abort();
+     verify_platform(supported_oses)
- #endif
+     verify_cache_mode(supported_cache_modes)
-diff --git a/block/io.c b/block/io.c
++    verify_aio_mode(supported_aio_modes)
-index XXXXXXX..XXXXXXX 100644
---- a/block/io.c
+     if debug:
-+++ b/block/io.c
+         output = sys.stdout
@@ -XXX,XX +XXX,XX @@ void bdrv_aio_cancel(BlockAIOCB *acb)
          if (acb->aiocb_info->get_aio_context) {
              aio_poll(acb->aiocb_info->get_aio_context(acb), true);
          } else if (acb->bs) {
 +            /* qemu_aio_ref and qemu_aio_unref are not thread-safe, so
 +             * assert that we're not using an I/O thread.  Thread-safe
 +             * code should use bdrv_aio_cancel_async exclusively.
 +             */
 +            assert(bdrv_get_aio_context(acb->bs) == qemu_get_aio_context());
              aio_poll(bdrv_get_aio_context(acb->bs), true);
          } else {
              abort();
 diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/iscsi.c
 +++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void iscsi_retry_timer_expired(void *opaque)
      struct IscsiTask *iTask = opaque;
      iTask->complete = 1;
      if (iTask->co) {
 -        qemu_coroutine_enter(iTask->co);
 +        aio_co_wake(iTask->co);
      }
  }
@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)
  {
      IscsiLun *iscsilun = opaque;
 +    aio_context_acquire(iscsilun->aio_context);
      if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
          error_report("iSCSI: NOP timeout. Reconnecting...");
          iscsilun->request_timed_out = true;
      } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
          error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
 -        return;
 +        goto out;
      }
      timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
      iscsi_set_events(iscsilun);
 +
 +out:
 +    aio_context_release(iscsilun->aio_context);
  }
  static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
 diff --git a/block/null.c b/block/null.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/null.c
 +++ b/block/null.c
@@ -XXX,XX +XXX,XX @@ static void null_bh_cb(void *opaque)
  static void null_timer_cb(void *opaque)
  {
      NullAIOCB *acb = opaque;
 +    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 +
 +    aio_context_acquire(ctx);
      acb->common.cb(acb->common.opaque, 0);
 +    aio_context_release(ctx);
      timer_deinit(&acb->timer);
      qemu_aio_unref(acb);
  }
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_need_check_timer_cb(void *opaque)
      trace_qed_need_check_timer_cb(s);
 +    qed_acquire(s);
      qed_plug_allocating_write_reqs(s);
      /* Ensure writes are on disk before clearing flag */
      bdrv_aio_flush(s->bs->file->bs, qed_clear_need_check, s);
 +    qed_release(s);
 +}
 +
 +void qed_acquire(BDRVQEDState *s)
 +{
 +    aio_context_acquire(bdrv_get_aio_context(s->bs));
 +}
 +
 +void qed_release(BDRVQEDState *s)
 +{
 +    aio_context_release(bdrv_get_aio_context(s->bs));
  }
  static void qed_start_need_check_timer(BDRVQEDState *s)
 diff --git a/block/throttle-groups.c b/block/throttle-groups.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/throttle-groups.c
 +++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ static void timer_cb(BlockBackend *blk, bool is_write)
      qemu_mutex_unlock(&tg->lock);
      /* Run the request that was waiting for this timer */
 +    aio_context_acquire(blk_get_aio_context(blk));
      empty_queue = !qemu_co_enter_next(&blkp->throttled_reqs[is_write]);
 +    aio_context_release(blk_get_aio_context(blk));
      /* If the request queue was empty then we have to take care of
       * scheduling the next one */
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
      }
      /* Run our timers */
 -    aio_context_acquire(ctx);
      progress |= timerlistgroup_run_timers(&ctx->tlg);
 -    aio_context_release(ctx);
      return progress;
  }
 diff --git a/util/aio-win32.c b/util/aio-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-win32.c
 +++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
          progress |= aio_dispatch_handlers(ctx, event);
      } while (count > 0);
 -    aio_context_acquire(ctx);
      progress |= timerlistgroup_run_timers(&ctx->tlg);
 -    aio_context_release(ctx);
      return progress;
  }
 diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-sleep.c
 +++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static void co_sleep_cb(void *opaque)
  {
      CoSleepCB *sleep_cb = opaque;
 -    qemu_coroutine_enter(sleep_cb->co);
 +    aio_co_wake(sleep_cb->co);
  }
  void coroutine_fn co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 10/24] qed: introduce qed_aio_start_io and qed_aio_next_io_cb
+[PULL 18/18] tests/qemu-iotests: use AIOMODE with various tests
-From: Paolo Bonzini <pbonzini@redhat.com>
+From: Aarushi Mehta <mehta.aaru20@gmail.com>
-qed_aio_start_io and qed_aio_next_io will not have to acquire/release
+Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
-the AioContext, while qed_aio_next_io_cb will.  Split the functionality
+Acked-by: Stefano Garzarella <sgarzare@redhat.com>
-and gain a little type-safety in the process.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200120141858.587874-16-stefanha@redhat.com
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20200120141858.587874-16-stefanha@redhat.com>
 Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
 Message-id: 20170213135235.12274-11-pbonzini@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qed.c | 39 +++++++++++++++++++++++++--------------
+ tests/qemu-iotests/028 |  2 +-
-file changed, 25 insertions(+), 14 deletions(-)
+ tests/qemu-iotests/058 |  2 +-
+ tests/qemu-iotests/089 |  4 ++--
-diff --git a/block/qed.c b/block/qed.c
+ tests/qemu-iotests/091 |  4 ++--
-index XXXXXXX..XXXXXXX 100644
+ tests/qemu-iotests/109 |  2 +-
---- a/block/qed.c
+ tests/qemu-iotests/147 |  5 +++--
-+++ b/block/qed.c
+ tests/qemu-iotests/181 |  8 ++++----
-@@ -XXX,XX +XXX,XX @@ static CachedL2Table *qed_new_l2_table(BDRVQEDState *s)
+ tests/qemu-iotests/183 |  4 ++--
-     return l2_table;
+ tests/qemu-iotests/185 | 10 +++++-----
- }
+ tests/qemu-iotests/200 |  2 +-
+ tests/qemu-iotests/201 |  8 ++++----
--static void qed_aio_next_io(void *opaque, int ret);
+files changed, 26 insertions(+), 25 deletions(-)
-+static void qed_aio_next_io(QEDAIOCB *acb, int ret);
-+
+diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
-+static void qed_aio_start_io(QEDAIOCB *acb)
+index XXXXXXX..XXXXXXX 100755
-+{
+--- a/tests/qemu-iotests/028
-+    qed_aio_next_io(acb, 0);
++++ b/tests/qemu-iotests/028
-+}
+@@ -XXX,XX +XXX,XX @@ echo block-backup
-+
+ echo
-+static void qed_aio_next_io_cb(void *opaque, int ret)
-+{
+ qemu_comm_method="monitor"
-+    QEDAIOCB *acb = opaque;
+-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk
-+
++_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk
-+    qed_aio_next_io(acb, ret);
+ h=$QEMU_HANDLE
-+}
+ if [ "${VALGRIND_QEMU}" == "y" ]; then
+     QEMU_COMM_TIMEOUT=7
- static void qed_plug_allocating_write_reqs(BDRVQEDState *s)
+diff --git a/tests/qemu-iotests/058 b/tests/qemu-iotests/058
- {
+index XXXXXXX..XXXXXXX 100755
-@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)
+--- a/tests/qemu-iotests/058
++++ b/tests/qemu-iotests/058
-     acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
+@@ -XXX,XX +XXX,XX @@ nbd_snapshot_img="nbd:unix:$nbd_unix_socket"
-     if (acb) {
+ converted_image=$TEST_IMG.converted
--        qed_aio_next_io(acb, 0);
-+        qed_aio_start_io(acb);
+ # Use -f raw instead of -f $IMGFMT for the NBD connection
-     }
+-QEMU_IO_NBD="$QEMU_IO -f raw --cache=$CACHEMODE"
- }
++QEMU_IO_NBD="$QEMU_IO -f raw --cache=$CACHEMODE --aio=$AIOMODE"
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete(QEDAIOCB *acb, int ret)
+ echo
-         QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next);
+ echo "== preparing image =="
-         acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
+diff --git a/tests/qemu-iotests/089 b/tests/qemu-iotests/089
-         if (acb) {
+index XXXXXXX..XXXXXXX 100755
--            qed_aio_next_io(acb, 0);
+--- a/tests/qemu-iotests/089
-+            qed_aio_start_io(acb);
++++ b/tests/qemu-iotests/089
-         } else if (s->header.features & QED_F_NEED_CHECK) {
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write -P 42 0 512' -c 'write -P 23 512 512' \
-             qed_start_need_check_timer(s);
-         }
+ $QEMU_IMG convert -f raw -O $IMGFMT "$TEST_IMG.base" "$TEST_IMG"
-@@ -XXX,XX +XXX,XX @@ static void qed_commit_l2_update(void *opaque, int ret)
-     acb->request.l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset);
+-$QEMU_IO_PROG --cache $CACHEMODE \
-     assert(acb->request.l2_table != NULL);
++$QEMU_IO_PROG --cache $CACHEMODE --aio $AIOMODE \
+          -c 'read -P 42 0 512' -c 'read -P 23 512 512' \
--    qed_aio_next_io(opaque, ret);
+          -c 'read -P 66 1024 512' "json:{
-+    qed_aio_next_io(acb, ret);
+     \"driver\": \"$IMGFMT\",
- }
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write -P 42 0x38000 512' "$TEST_IMG" | _filter_qemu_io
- /**
+ # The "image.filename" part tests whether "a": { "b": "c" } and "a.b": "c" do
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_l2_update(QEDAIOCB *acb, int ret, uint64_t offset)
+ # the same (which they should).
-     if (need_alloc) {
+-$QEMU_IO_PROG --cache $CACHEMODE \
-         /* Write out the whole new L2 table */
++$QEMU_IO_PROG --cache $CACHEMODE --aio $AIOMODE  \
-         qed_write_l2_table(s, &acb->request, 0, s->table_nelems, true,
+      -c 'read -P 42 0x38000 512' "json:{
--                            qed_aio_write_l1_update, acb);
+     \"driver\": \"$IMGFMT\",
-+                           qed_aio_write_l1_update, acb);
+     \"file\": {
-     } else {
+diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
-         /* Write out only the updated part of the L2 table */
+index XXXXXXX..XXXXXXX 100755
-         qed_write_l2_table(s, &acb->request, index, acb->cur_nclusters, false,
+--- a/tests/qemu-iotests/091
--                            qed_aio_next_io, acb);
++++ b/tests/qemu-iotests/091
-+                           qed_aio_next_io_cb, acb);
+@@ -XXX,XX +XXX,XX @@ echo === Starting QEMU VM1 ===
-     }
+ echo
-     return;
+ qemu_comm_method="monitor"
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_main(void *opaque, int ret)
+-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk
-     }
++_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk
+ h1=$QEMU_HANDLE
-     if (acb->find_cluster_ret == QED_CLUSTER_FOUND) {
--        next_fn = qed_aio_next_io;
+ echo
-+        next_fn = qed_aio_next_io_cb;
+ echo === Starting QEMU VM2 ===
-     } else {
+ echo
-         if (s->bs->backing) {
+-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk \
-             next_fn = qed_aio_write_flush_before_l2_update;
++_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk \
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
+              -incoming "exec: cat '${MIG_FIFO}'"
-     if (acb->flags & QED_AIOCB_ZERO) {
+ h2=$QEMU_HANDLE
-         /* Skip ahead if the clusters are already zero */
-         if (acb->find_cluster_ret == QED_CLUSTER_ZERO) {
+diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
--            qed_aio_next_io(acb, 0);
+index XXXXXXX..XXXXXXX 100755
-+            qed_aio_start_io(acb);
+--- a/tests/qemu-iotests/109
-             return;
++++ b/tests/qemu-iotests/109
-         }
+@@ -XXX,XX +XXX,XX @@ run_qemu()
+     local qmp_format="$3"
-@@ -XXX,XX +XXX,XX @@ static void qed_aio_read_data(void *opaque, int ret,
+     local qmp_event="$4"
-     /* Handle zero cluster and backing file reads */
-     if (ret == QED_CLUSTER_ZERO) {
+-    _launch_qemu -drive file="${source_img}",format=raw,cache=${CACHEMODE},id=src
-         qemu_iovec_memset(&acb->cur_qiov, 0, 0, acb->cur_qiov.size);
++    _launch_qemu -drive file="${source_img}",format=raw,cache=${CACHEMODE},aio=${AIOMODE},id=src
--        qed_aio_next_io(acb, 0);
+     _send_qemu_cmd $QEMU_HANDLE "{ 'execute': 'qmp_capabilities' }" "return"
-+        qed_aio_start_io(acb);
-         return;
+     _send_qemu_cmd $QEMU_HANDLE \
-     } else if (ret != QED_CLUSTER_FOUND) {
+diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147
-         qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov,
+index XXXXXXX..XXXXXXX 100755
--                              &acb->backing_qiov, qed_aio_next_io, acb);
+--- a/tests/qemu-iotests/147
-+                              &acb->backing_qiov, qed_aio_next_io_cb, acb);
++++ b/tests/qemu-iotests/147
-         return;
+@@ -XXX,XX +XXX,XX @@ import socket
-     }
+ import stat
+ import time
-     BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+ import iotests
-     bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE,
+-from iotests import cachemode, imgfmt, qemu_img, qemu_nbd, qemu_nbd_early_pipe
-                    &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,
++from iotests import cachemode, aiomode, imgfmt, qemu_img, qemu_nbd, qemu_nbd_early_pipe
--                   qed_aio_next_io, acb);
-+                   qed_aio_next_io_cb, acb);
+ NBD_PORT_START      = 32768
-     return;
+ NBD_PORT_END        = NBD_PORT_START + 1024
+@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):
- err:
+         self.server.add_drive_raw('if=none,id=nbd-export,' +
-@@ -XXX,XX +XXX,XX @@ err:
+                                   'file=%s,' % test_img +
- /**
+                                   'format=%s,' % imgfmt +
-  * Begin next I/O or complete the request
+-                                  'cache=%s' % cachemode)
-  */
++                                  'cache=%s' % cachemode +
--static void qed_aio_next_io(void *opaque, int ret)
++                                  'aio=%s' % aiomode)
-+static void qed_aio_next_io(QEDAIOCB *acb, int ret)
+         self.server.launch()
- {
--    QEDAIOCB *acb = opaque;
+     def tearDown(self):
-     BDRVQEDState *s = acb_to_s(acb);
+diff --git a/tests/qemu-iotests/181 b/tests/qemu-iotests/181
-     QEDFindClusterFunc *io_fn = (acb->flags & QED_AIOCB_WRITE) ?
+index XXXXXXX..XXXXXXX 100755
-                                 qed_aio_write_data : qed_aio_read_data;
+--- a/tests/qemu-iotests/181
-@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *qed_aio_setup(BlockDriverState *bs,
++++ b/tests/qemu-iotests/181
-     qemu_iovec_init(&acb->cur_qiov, qiov->niov);
+@@ -XXX,XX +XXX,XX @@ qemu_comm_method="monitor"
-     /* Start request */
+ if [ "$IMGOPTSSYNTAX" = "true" ]; then
--    qed_aio_next_io(acb, 0);
+     _launch_qemu \
-+    qed_aio_start_io(acb);
+-        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
-     return &acb->common;
++        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk
- }
+ else
+     _launch_qemu \
 -        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
 +        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk
  fi
  src=$QEMU_HANDLE
  if [ "$IMGOPTSSYNTAX" = "true" ]; then
      _launch_qemu \
 -        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
 +        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk \
          -incoming "unix:${MIG_SOCKET}"
  else
      _launch_qemu \
 -        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
 +        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk \
          -incoming "unix:${MIG_SOCKET}"
  fi
  dest=$QEMU_HANDLE
 diff --git a/tests/qemu-iotests/183 b/tests/qemu-iotests/183
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/183
 +++ b/tests/qemu-iotests/183
@@ -XXX,XX +XXX,XX @@ echo
  qemu_comm_method="qmp"
  _launch_qemu \
 -    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  src=$QEMU_HANDLE
  _send_qemu_cmd $src "{ 'execute': 'qmp_capabilities' }" 'return'
  _launch_qemu \
 -    -drive file="${TEST_IMG}.dest",cache=$CACHEMODE,driver=$IMGFMT,id=disk \
 +    -drive file="${TEST_IMG}.dest",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk \
      -incoming "unix:${MIG_SOCKET}"
  dest=$QEMU_HANDLE
  _send_qemu_cmd $dest "{ 'execute': 'qmp_capabilities' }" 'return'
 diff --git a/tests/qemu-iotests/185 b/tests/qemu-iotests/185
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/185
 +++ b/tests/qemu-iotests/185
@@ -XXX,XX +XXX,XX @@ echo
  qemu_comm_method="qmp"
  _launch_qemu \
 -    -drive file="${TEST_IMG}.base",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}.base",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  h=$QEMU_HANDLE
  _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
@@ -XXX,XX +XXX,XX @@ echo === Start active commit job and exit qemu ===
  echo
  _launch_qemu \
 -    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  h=$QEMU_HANDLE
  _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
@@ -XXX,XX +XXX,XX @@ echo === Start mirror job and exit qemu ===
  echo
  _launch_qemu \
 -    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  h=$QEMU_HANDLE
  _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
@@ -XXX,XX +XXX,XX @@ echo === Start backup job and exit qemu ===
  echo
  _launch_qemu \
 -    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  h=$QEMU_HANDLE
  _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
@@ -XXX,XX +XXX,XX @@ echo === Start streaming job and exit qemu ===
  echo
  _launch_qemu \
 -    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
 +    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
  h=$QEMU_HANDLE
  _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 diff --git a/tests/qemu-iotests/200 b/tests/qemu-iotests/200
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/200
 +++ b/tests/qemu-iotests/200
@@ -XXX,XX +XXX,XX @@ echo === Starting QEMU VM ===
  echo
  qemu_comm_method="qmp"
  _launch_qemu -object iothread,id=iothread0 $virtio_scsi \
 -             -drive file="${TEST_IMG}",media=disk,if=none,cache=$CACHEMODE,id=drive_sysdisk,format=$IMGFMT \
 +             -drive file="${TEST_IMG}",media=disk,if=none,cache=$CACHEMODE,aio=$AIOMODE,id=drive_sysdisk,format=$IMGFMT \
               -device scsi-hd,drive=drive_sysdisk,bus=scsi0.0,id=sysdisk,bootindex=0
  h1=$QEMU_HANDLE
 diff --git a/tests/qemu-iotests/201 b/tests/qemu-iotests/201
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/201
 +++ b/tests/qemu-iotests/201
@@ -XXX,XX +XXX,XX @@ qemu_comm_method="monitor"
  if [ "$IMGOPTSSYNTAX" = "true" ]; then
      _launch_qemu \
 -        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
 +        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk
  else
      _launch_qemu \
 -        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
 +        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk
  fi
  src=$QEMU_HANDLE
  if [ "$IMGOPTSSYNTAX" = "true" ]; then
      _launch_qemu \
 -        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
 +        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk \
          -incoming "unix:${MIG_SOCKET}"
  else
      _launch_qemu \
 -        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
 +        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk \
          -incoming "unix:${MIG_SOCKET}"
  fi
  dest=$QEMU_HANDLE
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 11/24] aio: push aio_context_acquire/release down to dispatching
+Deleted patch
-From: Paolo Bonzini <pbonzini@redhat.com>
-The AioContext data structures are now protected by list_lock and/or
-they are walked with FOREACH_RCU primitives.  There is no need anymore
-to acquire the AioContext for the entire duration of aio_dispatch.
-Instead, just acquire it before and after invoking the callbacks.
-The next step is then to push it further down.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
-Message-id: 20170213135235.12274-12-pbonzini@redhat.com
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- util/aio-posix.c | 25 +++++++++++--------------
- util/aio-win32.c | 15 +++++++--------
- util/async.c     |  2 ++
-files changed, 20 insertions(+), 22 deletions(-)
-diff --git a/util/aio-posix.c b/util/aio-posix.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/aio-posix.c
-+++ b/util/aio-posix.c
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
-             (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
-             aio_node_check(ctx, node->is_external) &&
-             node->io_read) {
-+            aio_context_acquire(ctx);
-             node->io_read(node->opaque);
-+            aio_context_release(ctx);
-             /* aio_notify() does not count as progress */
-             if (node->opaque != &ctx->notifier) {
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
-             (revents & (G_IO_OUT | G_IO_ERR)) &&
-             aio_node_check(ctx, node->is_external) &&
-             node->io_write) {
-+            aio_context_acquire(ctx);
-             node->io_write(node->opaque);
-+            aio_context_release(ctx);
-             progress = true;
-         }
-@@ -XXX,XX +XXX,XX @@ bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
-     }
-     /* Run our timers */
-+    aio_context_acquire(ctx);
-     progress |= timerlistgroup_run_timers(&ctx->tlg);
-+    aio_context_release(ctx);
-     return progress;
- }
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-     int64_t timeout;
-     int64_t start = 0;
--    aio_context_acquire(ctx);
--    progress = false;
--
-     /* aio_notify can avoid the expensive event_notifier_set if
-      * everything (file descriptors, bottom halves, timers) will
-      * be re-evaluated before the next blocking poll().  This is
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         start = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-     }
--    if (try_poll_mode(ctx, blocking)) {
--        progress = true;
--    } else {
-+    aio_context_acquire(ctx);
-+    progress = try_poll_mode(ctx, blocking);
-+    aio_context_release(ctx);
-+
-+    if (!progress) {
-         assert(npfd == 0);
-         /* fill pollfds */
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         timeout = blocking ? aio_compute_timeout(ctx) : 0;
-         /* wait until next event */
--        if (timeout) {
--            aio_context_release(ctx);
--        }
-         if (aio_epoll_check_poll(ctx, pollfds, npfd, timeout)) {
-             AioHandler epoll_handler;
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         } else  {
-             ret = qemu_poll_ns(pollfds, npfd, timeout);
-         }
--        if (timeout) {
--            aio_context_acquire(ctx);
--        }
-     }
-     if (blocking) {
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         progress = true;
-     }
--    aio_context_release(ctx);
--
-     return progress;
- }
-diff --git a/util/aio-win32.c b/util/aio-win32.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/aio-win32.c
-+++ b/util/aio-win32.c
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
-             (revents || event_notifier_get_handle(node->e) == event) &&
-             node->io_notify) {
-             node->pfd.revents = 0;
-+            aio_context_acquire(ctx);
-             node->io_notify(node->e);
-+            aio_context_release(ctx);
-             /* aio_notify() does not count as progress */
-             if (node->e != &ctx->notifier) {
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
-             (node->io_read || node->io_write)) {
-             node->pfd.revents = 0;
-             if ((revents & G_IO_IN) && node->io_read) {
-+                aio_context_acquire(ctx);
-                 node->io_read(node->opaque);
-+                aio_context_release(ctx);
-                 progress = true;
-             }
-             if ((revents & G_IO_OUT) && node->io_write) {
-+                aio_context_acquire(ctx);
-                 node->io_write(node->opaque);
-+                aio_context_release(ctx);
-                 progress = true;
-             }
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-     int count;
-     int timeout;
--    aio_context_acquire(ctx);
-     progress = false;
-     /* aio_notify can avoid the expensive event_notifier_set if
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         timeout = blocking && !have_select_revents
-             ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
--        if (timeout) {
--            aio_context_release(ctx);
--        }
-         ret = WaitForMultipleObjects(count, events, FALSE, timeout);
-         if (blocking) {
-             assert(first);
-             atomic_sub(&ctx->notify_me, 2);
-         }
--        if (timeout) {
--            aio_context_acquire(ctx);
--        }
-         if (first) {
-             aio_notify_accept(ctx);
-@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
-         progress |= aio_dispatch_handlers(ctx, event);
-     } while (count > 0);
-+    aio_context_acquire(ctx);
-     progress |= timerlistgroup_run_timers(&ctx->tlg);
--
-     aio_context_release(ctx);
-     return progress;
- }
-diff --git a/util/async.c b/util/async.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/async.c
-+++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
-                 ret = 1;
-             }
-             bh->idle = 0;
-+            aio_context_acquire(ctx);
-             aio_bh_call(bh);
-+            aio_context_release(ctx);
-         }
-         if (bh->deleted) {
-             deleted = true;
---
-.9.3

The following changes since commit 5dae13cd71f0755a1395b5a4cde635b8a6ee3f58:

Merge remote-tracking branch 'remotes/rth/tags/pull-or-20170214' into staging (2017-02-14 09:55:48 +0000)

are available in the git repository at:

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to decc18f33adecb1316437a47fff0cf0a7665906a:

coroutine-lock: make CoRwlock thread-safe and fair (2017-02-16 17:17:34 +0000)

----------------------------------------------------------------

Paolo Bonzini (24):
  block: move AioContext, QEMUTimer, main-loop to libqemuutil
  aio: introduce aio_co_schedule and aio_co_wake
  block-backend: allow blk_prw from coroutine context
  test-thread-pool: use generic AioContext infrastructure
  io: add methods to set I/O handlers on AioContext
  io: make qio_channel_yield aware of AioContexts
  nbd: convert to use qio_channel_yield
  coroutine-lock: reschedule coroutine on the AioContext it was running
    on
  blkdebug: reschedule coroutine on the AioContext it is running on
  qed: introduce qed_aio_start_io and qed_aio_next_io_cb
  aio: push aio_context_acquire/release down to dispatching
  block: explicitly acquire aiocontext in timers that need it
  block: explicitly acquire aiocontext in callbacks that need it
  block: explicitly acquire aiocontext in bottom halves that need it
  block: explicitly acquire aiocontext in aio callbacks that need it
  aio-posix: partially inline aio_dispatch into aio_poll
  async: remove unnecessary inc/dec pairs
  block: document fields protected by AioContext lock
  coroutine-lock: make CoMutex thread-safe
  coroutine-lock: add limited spinning to CoMutex
  test-aio-multithread: add performance comparison with thread-based
    mutexes
  coroutine-lock: place CoMutex before CoQueue in header
  coroutine-lock: add mutex argument to CoQueue APIs
  coroutine-lock: make CoRwlock thread-safe and fair

-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

AioContext is fairly self contained, the only dependency is QEMUTimer but
that in turn doesn't need anything else.  So move them out of block-obj-y
to avoid introducing a dependency from io/ to block-obj-y.

main-loop and its dependency iohandler also need to be moved, because
later in this series io/ will call iohandler_get_aio_context.

[Changed copyright "the QEMU team" to "other QEMU contributors" as
suggested by Daniel Berrange and agreed by Paolo.
--Stefan]

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-2-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 Makefile.objs                       |  4 ---
 stubs/Makefile.objs                 |  1 +
 tests/Makefile.include              | 11 ++++----
 util/Makefile.objs                  |  6 +++-
 block/io.c                          | 29 -------------------
 stubs/linux-aio.c                   | 32 +++++++++++++++++++++
 stubs/set-fd-handler.c              | 11 --------
 aio-posix.c => util/aio-posix.c     |  2 +-
 aio-win32.c => util/aio-win32.c     |  0
 util/aiocb.c                        | 55 +++++++++++++++++++++++++++++++++++++
 async.c => util/async.c             |  3 +-
 iohandler.c => util/iohandler.c     |  0
 main-loop.c => util/main-loop.c     |  0
 qemu-timer.c => util/qemu-timer.c   |  0
 thread-pool.c => util/thread-pool.c |  2 +-
 trace-events                        | 11 --------
 util/trace-events                   | 11 ++++++++
 17 files changed, 114 insertions(+), 64 deletions(-)
 create mode 100644 stubs/linux-aio.c
 rename aio-posix.c => util/aio-posix.c (99%)
 rename aio-win32.c => util/aio-win32.c (100%)
 create mode 100644 util/aiocb.c
 rename async.c => util/async.c (99%)
 rename iohandler.c => util/iohandler.c (100%)
 rename main-loop.c => util/main-loop.c (100%)
 rename qemu-timer.c => util/qemu-timer.c (100%)
 rename thread-pool.c => util/thread-pool.c (99%)

diff --git a/Makefile.objs b/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -XXX,XX +XXX,XX @@ chardev-obj-y = chardev/
 #######################################################################
 # block-obj-y is code used by both qemu system emulation and qemu-img
 
-block-obj-y = async.o thread-pool.o
 block-obj-y += nbd/
 block-obj-y += block.o blockjob.o
-block-obj-y += main-loop.o iohandler.o qemu-timer.o
-block-obj-$(CONFIG_POSIX) += aio-posix.o
-block-obj-$(CONFIG_WIN32) += aio-win32.o
 block-obj-y += block/
 block-obj-y += qemu-io-cmds.o
 block-obj-$(CONFIG_REPLICATION) += replication.o
diff --git a/stubs/Makefile.objs b/stubs/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/stubs/Makefile.objs
+++ b/stubs/Makefile.objs
@@ -XXX,XX +XXX,XX @@ stub-obj-y += get-vm-name.o
 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-y += machine-init-done.o
 stub-obj-y += migr-blocker.o
 stub-obj-y += monitor.o
diff --git a/tests/Makefile.include b/tests/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ check-unit-y += tests/test-visitor-serialization$(EXESUF)
 check-unit-y += tests/test-iov$(EXESUF)
 gcov-files-test-iov-y = util/iov.c
 check-unit-y += tests/test-aio$(EXESUF)
+gcov-files-test-aio-y = util/async.c util/qemu-timer.o
+gcov-files-test-aio-$(CONFIG_WIN32) += util/aio-win32.c
+gcov-files-test-aio-$(CONFIG_POSIX) += util/aio-posix.c
 check-unit-y += tests/test-throttle$(EXESUF)
 gcov-files-test-aio-$(CONFIG_WIN32) = aio-win32.c
 gcov-files-test-aio-$(CONFIG_POSIX) = aio-posix.c
@@ -XXX,XX +XXX,XX @@ tests/check-qjson$(EXESUF): tests/check-qjson.o $(test-util-obj-y)
 tests/check-qom-interface$(EXESUF): tests/check-qom-interface.o $(test-qom-obj-y)
 tests/check-qom-proplist$(EXESUF): tests/check-qom-proplist.o $(test-qom-obj-y)
 
-tests/test-char$(EXESUF): tests/test-char.o qemu-timer.o \
-	$(test-util-obj-y) $(qtest-obj-y) $(test-block-obj-y) $(chardev-obj-y)
+tests/test-char$(EXESUF): tests/test-char.o $(test-util-obj-y) $(qtest-obj-y) $(test-io-obj-y) $(chardev-obj-y)
 tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
 tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
 tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
@@ -XXX,XX +XXX,XX @@ tests/test-vmstate$(EXESUF): tests/test-vmstate.o \
 	migration/vmstate.o migration/qemu-file.o \
         migration/qemu-file-channel.o migration/qjson.o \
 	$(test-io-obj-y)
-tests/test-timed-average$(EXESUF): tests/test-timed-average.o qemu-timer.o \
-	$(test-util-obj-y)
+tests/test-timed-average$(EXESUF): tests/test-timed-average.o $(test-util-obj-y)
 tests/test-base64$(EXESUF): tests/test-base64.o \
 	libqemuutil.a libqemustub.a
 tests/ptimer-test$(EXESUF): tests/ptimer-test.o tests/ptimer-test-stubs.o hw/core/ptimer.o libqemustub.a
@@ -XXX,XX +XXX,XX @@ tests/usb-hcd-ehci-test$(EXESUF): tests/usb-hcd-ehci-test.o $(libqos-usb-obj-y)
 tests/usb-hcd-xhci-test$(EXESUF): tests/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
 tests/pc-cpu-test$(EXESUF): tests/pc-cpu-test.o
 tests/postcopy-test$(EXESUF): tests/postcopy-test.o
-tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o qemu-timer.o \
+tests/vhost-user-test$(EXESUF): tests/vhost-user-test.o $(test-util-obj-y) \
 	$(qtest-obj-y) $(test-io-obj-y) $(libqos-virtio-obj-y) $(libqos-pc-obj-y) \
 	$(chardev-obj-y)
 tests/qemu-iotests/socket_scm_helper$(EXESUF): tests/qemu-iotests/socket_scm_helper.o
diff --git a/util/Makefile.objs b/util/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/util/Makefile.objs
+++ b/util/Makefile.objs
@@ -XXX,XX +XXX,XX @@
 util-obj-y = osdep.o cutils.o unicode.o qemu-timer-common.o
 util-obj-y += bufferiszero.o
 util-obj-y += lockcnt.o
+util-obj-y += aiocb.o async.o thread-pool.o qemu-timer.o
+util-obj-y += main-loop.o iohandler.o
+util-obj-$(CONFIG_POSIX) += aio-posix.o
 util-obj-$(CONFIG_POSIX) += compatfd.o
 util-obj-$(CONFIG_POSIX) += event_notifier-posix.o
 util-obj-$(CONFIG_POSIX) += mmap-alloc.o
 util-obj-$(CONFIG_POSIX) += oslib-posix.o
 util-obj-$(CONFIG_POSIX) += qemu-openpty.o
 util-obj-$(CONFIG_POSIX) += qemu-thread-posix.o
-util-obj-$(CONFIG_WIN32) += event_notifier-win32.o
 util-obj-$(CONFIG_POSIX) += memfd.o
+util-obj-$(CONFIG_WIN32) += aio-win32.o
+util-obj-$(CONFIG_WIN32) += event_notifier-win32.o
 util-obj-$(CONFIG_WIN32) += oslib-win32.o
 util-obj-$(CONFIG_WIN32) += qemu-thread-win32.o
 util-obj-y += envlist.o path.o module.o
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
     return &acb->common;
 }
 
-void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
-                   BlockCompletionFunc *cb, void *opaque)
-{
-    BlockAIOCB *acb;
-
-    acb = g_malloc(aiocb_info->aiocb_size);
-    acb->aiocb_info = aiocb_info;
-    acb->bs = bs;
-    acb->cb = cb;
-    acb->opaque = opaque;
-    acb->refcnt = 1;
-    return acb;
-}
-
-void qemu_aio_ref(void *p)
-{
-    BlockAIOCB *acb = p;
-    acb->refcnt++;
-}
-
-void qemu_aio_unref(void *p)
-{
-    BlockAIOCB *acb = p;
-    assert(acb->refcnt > 0);
-    if (--acb->refcnt == 0) {
-        g_free(acb);
-    }
-}
-
 /**************************************************************/
 /* Coroutine block device emulation */
 
diff --git a/stubs/linux-aio.c b/stubs/linux-aio.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/stubs/linux-aio.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Linux native AIO 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 laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
+{
+    abort();
+}
+
+void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
+{
+    abort();
+}
+
+LinuxAioState *laio_init(void)
+{
+    abort();
+}
+
+void laio_cleanup(LinuxAioState *s)
+{
+    abort();
+}
diff --git a/stubs/set-fd-handler.c b/stubs/set-fd-handler.c
index XXXXXXX..XXXXXXX 100644
--- a/stubs/set-fd-handler.c
+++ b/stubs/set-fd-handler.c
@@ -XXX,XX +XXX,XX @@ void qemu_set_fd_handler(int fd,
 {
     abort();
 }
-
-void aio_set_fd_handler(AioContext *ctx,
-                        int fd,
-                        bool is_external,
-                        IOHandler *io_read,
-                        IOHandler *io_write,
-                        AioPollFn *io_poll,
-                        void *opaque)
-{
-    abort();
-}
diff --git a/aio-posix.c b/util/aio-posix.c
similarity index 99%
rename from aio-posix.c
rename to util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/rcu_queue.h"
 #include "qemu/sockets.h"
 #include "qemu/cutils.h"
-#include "trace-root.h"
+#include "trace.h"
 #ifdef CONFIG_EPOLL_CREATE1
 #include <sys/epoll.h>
 #endif
diff --git a/aio-win32.c b/util/aio-win32.c
similarity index 100%
rename from aio-win32.c
rename to util/aio-win32.c
diff --git a/util/aiocb.c b/util/aiocb.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/util/aiocb.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * BlockAIOCB allocation
+ *
+ * Copyright (c) 2003-2017 Fabrice Bellard and other QEMU contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+#include "block/aio.h"
+
+void *qemu_aio_get(const AIOCBInfo *aiocb_info, BlockDriverState *bs,
+                   BlockCompletionFunc *cb, void *opaque)
+{
+    BlockAIOCB *acb;
+
+    acb = g_malloc(aiocb_info->aiocb_size);
+    acb->aiocb_info = aiocb_info;
+    acb->bs = bs;
+    acb->cb = cb;
+    acb->opaque = opaque;
+    acb->refcnt = 1;
+    return acb;
+}
+
+void qemu_aio_ref(void *p)
+{
+    BlockAIOCB *acb = p;
+    acb->refcnt++;
+}
+
+void qemu_aio_unref(void *p)
+{
+    BlockAIOCB *acb = p;
+    assert(acb->refcnt > 0);
+    if (--acb->refcnt == 0) {
+        g_free(acb);
+    }
+}
diff --git a/async.c b/util/async.c
similarity index 99%
rename from async.c
rename to util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@
 /*
- * QEMU System Emulator
+ * Data plane event loop
  *
  * Copyright (c) 2003-2008 Fabrice Bellard
+ * Copyright (c) 2009-2017 QEMU contributors
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
diff --git a/iohandler.c b/util/iohandler.c
similarity index 100%
rename from iohandler.c
rename to util/iohandler.c
diff --git a/main-loop.c b/util/main-loop.c
similarity index 100%
rename from main-loop.c
rename to util/main-loop.c
diff --git a/qemu-timer.c b/util/qemu-timer.c
similarity index 100%
rename from qemu-timer.c
rename to util/qemu-timer.c
diff --git a/thread-pool.c b/util/thread-pool.c
similarity index 99%
rename from thread-pool.c
rename to util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/queue.h"
 #include "qemu/thread.h"
 #include "qemu/coroutine.h"
-#include "trace-root.h"
+#include "trace.h"
 #include "block/thread-pool.h"
 #include "qemu/main-loop.h"
 
diff --git a/trace-events b/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/trace-events
+++ b/trace-events
@@ -XXX,XX +XXX,XX @@
 #
 # The <format-string> should be a sprintf()-compatible format string.
 
-# aio-posix.c
-run_poll_handlers_begin(void *ctx, int64_t max_ns) "ctx %p max_ns %"PRId64
-run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
-poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
-
-# thread-pool.c
-thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
-thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
-thread_pool_cancel(void *req, void *opaque) "req %p opaque %p"
-
 # ioport.c
 cpu_in(unsigned int addr, char size, unsigned int val) "addr %#x(%c) value %u"
 cpu_out(unsigned int addr, char size, unsigned int val) "addr %#x(%c) value %u"
diff --git a/util/trace-events b/util/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/util/trace-events
+++ b/util/trace-events
@@ -XXX,XX +XXX,XX @@
 # See docs/tracing.txt for syntax documentation.
 
+# util/aio-posix.c
+run_poll_handlers_begin(void *ctx, int64_t max_ns) "ctx %p max_ns %"PRId64
+run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
+poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
+poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
+
+# util/thread-pool.c
+thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
+thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
+thread_pool_cancel(void *req, void *opaque) "req %p opaque %p"
+
 # util/buffer.c
 buffer_resize(const char *buf, size_t olen, size_t len) "%s: old %zd, new %zd"
 buffer_move_empty(const char *buf, size_t len, const char *from) "%s: %zd bytes from %s"
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

aio_co_wake provides the infrastructure to start a coroutine on a "home"
AioContext.  It will be used by CoMutex and CoQueue, so that coroutines
don't jump from one context to another when they go to sleep on a
mutex or waitqueue.  However, it can also be used as a more efficient
alternative to one-shot bottom halves, and saves the effort of tracking
which AioContext a coroutine is running on.

aio_co_schedule is the part of aio_co_wake that starts a coroutine
on a remove AioContext, but it is also useful to implement e.g.
bdrv_set_aio_context callbacks.

The implementation of aio_co_schedule is based on a lock-free
multiple-producer, single-consumer queue.  The multiple producers use
cmpxchg to add to a LIFO stack.  The consumer (a per-AioContext bottom
half) grabs all items added so far, inverts the list to make it FIFO,
and goes through it one item at a time until it's empty.  The data
structure was inspired by OSv, which uses it in the very code we'll
"port" to QEMU for the thread-safe CoMutex.

Most of the new code is really tests.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-3-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/Makefile.include       |   8 +-
 include/block/aio.h          |  32 +++++++
 include/qemu/coroutine_int.h |  11 ++-
 tests/iothread.h             |  25 +++++
 tests/iothread.c             |  91 ++++++++++++++++++
 tests/test-aio-multithread.c | 213 +++++++++++++++++++++++++++++++++++++++++++
 util/async.c                 |  65 +++++++++++++
 util/qemu-coroutine.c        |   8 ++
 util/trace-events            |   4 +
 9 files changed, 453 insertions(+), 4 deletions(-)
 create mode 100644 tests/iothread.h
 create mode 100644 tests/iothread.c
 create mode 100644 tests/test-aio-multithread.c

diff --git a/tests/Makefile.include b/tests/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ check-unit-y += tests/test-aio$(EXESUF)
 gcov-files-test-aio-y = util/async.c util/qemu-timer.o
 gcov-files-test-aio-$(CONFIG_WIN32) += util/aio-win32.c
 gcov-files-test-aio-$(CONFIG_POSIX) += util/aio-posix.c
+check-unit-y += tests/test-aio-multithread$(EXESUF)
+gcov-files-test-aio-multithread-y = $(gcov-files-test-aio-y)
+gcov-files-test-aio-multithread-y += util/qemu-coroutine.c tests/iothread.c
 check-unit-y += tests/test-throttle$(EXESUF)
-gcov-files-test-aio-$(CONFIG_WIN32) = aio-win32.c
-gcov-files-test-aio-$(CONFIG_POSIX) = aio-posix.c
 check-unit-y += tests/test-thread-pool$(EXESUF)
 gcov-files-test-thread-pool-y = thread-pool.c
 gcov-files-test-hbitmap-y = util/hbitmap.c
@@ -XXX,XX +XXX,XX @@ test-qapi-obj-y = tests/test-qapi-visit.o tests/test-qapi-types.o \
 	$(test-qom-obj-y)
 test-crypto-obj-y = $(crypto-obj-y) $(test-qom-obj-y)
 test-io-obj-y = $(io-obj-y) $(test-crypto-obj-y)
-test-block-obj-y = $(block-obj-y) $(test-io-obj-y)
+test-block-obj-y = $(block-obj-y) $(test-io-obj-y) tests/iothread.o
 
 tests/check-qint$(EXESUF): tests/check-qint.o $(test-util-obj-y)
 tests/check-qstring$(EXESUF): tests/check-qstring.o $(test-util-obj-y)
@@ -XXX,XX +XXX,XX @@ tests/check-qom-proplist$(EXESUF): tests/check-qom-proplist.o $(test-qom-obj-y)
 tests/test-char$(EXESUF): tests/test-char.o $(test-util-obj-y) $(qtest-obj-y) $(test-io-obj-y) $(chardev-obj-y)
 tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
 tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
+tests/test-aio-multithread$(EXESUF): tests/test-aio-multithread.o $(test-block-obj-y)
 tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
 tests/test-blockjob$(EXESUF): tests/test-blockjob.o $(test-block-obj-y) $(test-util-obj-y)
 tests/test-blockjob-txn$(EXESUF): tests/test-blockjob-txn.o $(test-block-obj-y) $(test-util-obj-y)
diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ typedef void QEMUBHFunc(void *opaque);
 typedef bool AioPollFn(void *opaque);
 typedef void IOHandler(void *opaque);
 
+struct Coroutine;
 struct ThreadPool;
 struct LinuxAioState;
 
@@ -XXX,XX +XXX,XX @@ struct AioContext {
     bool notified;
     EventNotifier notifier;
 
+    QSLIST_HEAD(, Coroutine) scheduled_coroutines;
+    QEMUBH *co_schedule_bh;
+
     /* Thread pool for performing work and receiving completion callbacks.
      * Has its own locking.
      */
@@ -XXX,XX +XXX,XX @@ static inline bool aio_node_check(AioContext *ctx, bool is_external)
 }
 
 /**
+ * aio_co_schedule:
+ * @ctx: the aio context
+ * @co: the coroutine
+ *
+ * Start a coroutine on a remote AioContext.
+ *
+ * The coroutine must not be entered by anyone else while aio_co_schedule()
+ * is active.  In addition the coroutine must have yielded unless ctx
+ * is the context in which the coroutine is running (i.e. the value of
+ * qemu_get_current_aio_context() from the coroutine itself).
+ */
+void aio_co_schedule(AioContext *ctx, struct Coroutine *co);
+
+/**
+ * aio_co_wake:
+ * @co: the coroutine
+ *
+ * Restart a coroutine on the AioContext where it was running last, thus
+ * preventing coroutines from jumping from one context to another when they
+ * go to sleep.
+ *
+ * aio_co_wake may be executed either in coroutine or non-coroutine
+ * context.  The coroutine must not be entered by anyone else while
+ * aio_co_wake() is active.
+ */
+void aio_co_wake(struct Coroutine *co);
+
+/**
  * Return the AioContext whose event loop runs in the current thread.
  *
  * If called from an IOThread this will be the IOThread's AioContext.  If
diff --git a/include/qemu/coroutine_int.h b/include/qemu/coroutine_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine_int.h
+++ b/include/qemu/coroutine_int.h
@@ -XXX,XX +XXX,XX @@ struct Coroutine {
     CoroutineEntry *entry;
     void *entry_arg;
     Coroutine *caller;
+
+    /* Only used when the coroutine has terminated.  */
     QSLIST_ENTRY(Coroutine) pool_next;
+
     size_t locks_held;
 
-    /* Coroutines that should be woken up when we yield or terminate */
+    /* Coroutines that should be woken up when we yield or terminate.
+     * Only used when the coroutine is running.
+     */
     QSIMPLEQ_HEAD(, Coroutine) co_queue_wakeup;
+
+    /* Only used when the coroutine has yielded.  */
+    AioContext *ctx;
     QSIMPLEQ_ENTRY(Coroutine) co_queue_next;
+    QSLIST_ENTRY(Coroutine) co_scheduled_next;
 };
 
 Coroutine *qemu_coroutine_new(void);
diff --git a/tests/iothread.h b/tests/iothread.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/iothread.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Event loop thread implementation for unit tests
+ *
+ * Copyright Red Hat Inc., 2013, 2016
+ *
+ * Authors:
+ *  Stefan Hajnoczi   <stefanha@redhat.com>
+ *  Paolo Bonzini     <pbonzini@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+#ifndef TEST_IOTHREAD_H
+#define TEST_IOTHREAD_H
+
+#include "block/aio.h"
+#include "qemu/thread.h"
+
+typedef struct IOThread IOThread;
+
+IOThread *iothread_new(void);
+void iothread_join(IOThread *iothread);
+AioContext *iothread_get_aio_context(IOThread *iothread);
+
+#endif
diff --git a/tests/iothread.c b/tests/iothread.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/iothread.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Event loop thread implementation for unit tests
+ *
+ * Copyright Red Hat Inc., 2013, 2016
+ *
+ * Authors:
+ *  Stefan Hajnoczi   <stefanha@redhat.com>
+ *  Paolo Bonzini     <pbonzini@redhat.com>
+ *
+ * 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 "qapi/error.h"
+#include "block/aio.h"
+#include "qemu/main-loop.h"
+#include "qemu/rcu.h"
+#include "iothread.h"
+
+struct IOThread {
+    AioContext *ctx;
+
+    QemuThread thread;
+    QemuMutex init_done_lock;
+    QemuCond init_done_cond;    /* is thread initialization done? */
+    bool stopping;
+};
+
+static __thread IOThread *my_iothread;
+
+AioContext *qemu_get_current_aio_context(void)
+{
+    return my_iothread ? my_iothread->ctx : qemu_get_aio_context();
+}
+
+static void *iothread_run(void *opaque)
+{
+    IOThread *iothread = opaque;
+
+    rcu_register_thread();
+
+    my_iothread = iothread;
+    qemu_mutex_lock(&iothread->init_done_lock);
+    iothread->ctx = aio_context_new(&error_abort);
+    qemu_cond_signal(&iothread->init_done_cond);
+    qemu_mutex_unlock(&iothread->init_done_lock);
+
+    while (!atomic_read(&iothread->stopping)) {
+        aio_poll(iothread->ctx, true);
+    }
+
+    rcu_unregister_thread();
+    return NULL;
+}
+
+void iothread_join(IOThread *iothread)
+{
+    iothread->stopping = true;
+    aio_notify(iothread->ctx);
+    qemu_thread_join(&iothread->thread);
+    qemu_cond_destroy(&iothread->init_done_cond);
+    qemu_mutex_destroy(&iothread->init_done_lock);
+    aio_context_unref(iothread->ctx);
+    g_free(iothread);
+}
+
+IOThread *iothread_new(void)
+{
+    IOThread *iothread = g_new0(IOThread, 1);
+
+    qemu_mutex_init(&iothread->init_done_lock);
+    qemu_cond_init(&iothread->init_done_cond);
+    qemu_thread_create(&iothread->thread, NULL, iothread_run,
+                       iothread, QEMU_THREAD_JOINABLE);
+
+    /* Wait for initialization to complete */
+    qemu_mutex_lock(&iothread->init_done_lock);
+    while (iothread->ctx == NULL) {
+        qemu_cond_wait(&iothread->init_done_cond,
+                       &iothread->init_done_lock);
+    }
+    qemu_mutex_unlock(&iothread->init_done_lock);
+    return iothread;
+}
+
+AioContext *iothread_get_aio_context(IOThread *iothread)
+{
+    return iothread->ctx;
+}
diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/test-aio-multithread.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * AioContext multithreading tests
+ *
+ * Copyright Red Hat, Inc. 2016
+ *
+ * Authors:
+ *  Paolo Bonzini    <pbonzini@redhat.com>
+ *
+ * This work is licensed under the terms of the GNU LGPL, version 2 or later.
+ * See the COPYING.LIB file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include <glib.h>
+#include "block/aio.h"
+#include "qapi/error.h"
+#include "qemu/coroutine.h"
+#include "qemu/thread.h"
+#include "qemu/error-report.h"
+#include "iothread.h"
+
+/* AioContext management */
+
+#define NUM_CONTEXTS 5
+
+static IOThread *threads[NUM_CONTEXTS];
+static AioContext *ctx[NUM_CONTEXTS];
+static __thread int id = -1;
+
+static QemuEvent done_event;
+
+/* Run a function synchronously on a remote iothread. */
+
+typedef struct CtxRunData {
+    QEMUBHFunc *cb;
+    void *arg;
+} CtxRunData;
+
+static void ctx_run_bh_cb(void *opaque)
+{
+    CtxRunData *data = opaque;
+
+    data->cb(data->arg);
+    qemu_event_set(&done_event);
+}
+
+static void ctx_run(int i, QEMUBHFunc *cb, void *opaque)
+{
+    CtxRunData data = {
+        .cb = cb,
+        .arg = opaque
+    };
+
+    qemu_event_reset(&done_event);
+    aio_bh_schedule_oneshot(ctx[i], ctx_run_bh_cb, &data);
+    qemu_event_wait(&done_event);
+}
+
+/* Starting the iothreads. */
+
+static void set_id_cb(void *opaque)
+{
+    int *i = opaque;
+
+    id = *i;
+}
+
+static void create_aio_contexts(void)
+{
+    int i;
+
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        threads[i] = iothread_new();
+        ctx[i] = iothread_get_aio_context(threads[i]);
+    }
+
+    qemu_event_init(&done_event, false);
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        ctx_run(i, set_id_cb, &i);
+    }
+}
+
+/* Stopping the iothreads. */
+
+static void join_aio_contexts(void)
+{
+    int i;
+
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        aio_context_ref(ctx[i]);
+    }
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        iothread_join(threads[i]);
+    }
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        aio_context_unref(ctx[i]);
+    }
+    qemu_event_destroy(&done_event);
+}
+
+/* Basic test for the stuff above. */
+
+static void test_lifecycle(void)
+{
+    create_aio_contexts();
+    join_aio_contexts();
+}
+
+/* aio_co_schedule test.  */
+
+static Coroutine *to_schedule[NUM_CONTEXTS];
+
+static bool now_stopping;
+
+static int count_retry;
+static int count_here;
+static int count_other;
+
+static bool schedule_next(int n)
+{
+    Coroutine *co;
+
+    co = atomic_xchg(&to_schedule[n], NULL);
+    if (!co) {
+        atomic_inc(&count_retry);
+        return false;
+    }
+
+    if (n == id) {
+        atomic_inc(&count_here);
+    } else {
+        atomic_inc(&count_other);
+    }
+
+    aio_co_schedule(ctx[n], co);
+    return true;
+}
+
+static void finish_cb(void *opaque)
+{
+    schedule_next(id);
+}
+
+static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
+{
+    g_assert(to_schedule[id] == NULL);
+    atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
+
+    while (!atomic_mb_read(&now_stopping)) {
+        int n;
+
+        n = g_test_rand_int_range(0, NUM_CONTEXTS);
+        schedule_next(n);
+        qemu_coroutine_yield();
+
+        g_assert(to_schedule[id] == NULL);
+        atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
+    }
+}
+
+
+static void test_multi_co_schedule(int seconds)
+{
+    int i;
+
+    count_here = count_other = count_retry = 0;
+    now_stopping = false;
+
+    create_aio_contexts();
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        Coroutine *co1 = qemu_coroutine_create(test_multi_co_schedule_entry, NULL);
+        aio_co_schedule(ctx[i], co1);
+    }
+
+    g_usleep(seconds * 1000000);
+
+    atomic_mb_set(&now_stopping, true);
+    for (i = 0; i < NUM_CONTEXTS; i++) {
+        ctx_run(i, finish_cb, NULL);
+        to_schedule[i] = NULL;
+    }
+
+    join_aio_contexts();
+    g_test_message("scheduled %d, queued %d, retry %d, total %d\n",
+                  count_other, count_here, count_retry,
+                  count_here + count_other + count_retry);
+}
+
+static void test_multi_co_schedule_1(void)
+{
+    test_multi_co_schedule(1);
+}
+
+static void test_multi_co_schedule_10(void)
+{
+    test_multi_co_schedule(10);
+}
+
+/* End of tests.  */
+
+int main(int argc, char **argv)
+{
+    init_clocks();
+
+    g_test_init(&argc, &argv, NULL);
+    g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
+    if (g_test_quick()) {
+        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
+    } else {
+        g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
+    }
+    return g_test_run();
+}
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/main-loop.h"
 #include "qemu/atomic.h"
 #include "block/raw-aio.h"
+#include "qemu/coroutine_int.h"
+#include "trace.h"
 
 /***********************************************************/
 /* bottom halves (can be seen as timers which expire ASAP) */
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
     }
 #endif
 
+    assert(QSLIST_EMPTY(&ctx->scheduled_coroutines));
+    qemu_bh_delete(ctx->co_schedule_bh);
+
     qemu_lockcnt_lock(&ctx->list_lock);
     assert(!qemu_lockcnt_count(&ctx->list_lock));
     while (ctx->first_bh) {
@@ -XXX,XX +XXX,XX @@ static bool event_notifier_poll(void *opaque)
     return atomic_read(&ctx->notified);
 }
 
+static void co_schedule_bh_cb(void *opaque)
+{
+    AioContext *ctx = opaque;
+    QSLIST_HEAD(, Coroutine) straight, reversed;
+
+    QSLIST_MOVE_ATOMIC(&reversed, &ctx->scheduled_coroutines);
+    QSLIST_INIT(&straight);
+
+    while (!QSLIST_EMPTY(&reversed)) {
+        Coroutine *co = QSLIST_FIRST(&reversed);
+        QSLIST_REMOVE_HEAD(&reversed, co_scheduled_next);
+        QSLIST_INSERT_HEAD(&straight, co, co_scheduled_next);
+    }
+
+    while (!QSLIST_EMPTY(&straight)) {
+        Coroutine *co = QSLIST_FIRST(&straight);
+        QSLIST_REMOVE_HEAD(&straight, co_scheduled_next);
+        trace_aio_co_schedule_bh_cb(ctx, co);
+        qemu_coroutine_enter(co);
+    }
+}
+
 AioContext *aio_context_new(Error **errp)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
     }
     g_source_set_can_recurse(&ctx->source, true);
     qemu_lockcnt_init(&ctx->list_lock);
+
+    ctx->co_schedule_bh = aio_bh_new(ctx, co_schedule_bh_cb, ctx);
+    QSLIST_INIT(&ctx->scheduled_coroutines);
+
     aio_set_event_notifier(ctx, &ctx->notifier,
                            false,
                            (EventNotifierHandler *)
@@ -XXX,XX +XXX,XX @@ fail:
     return NULL;
 }
 
+void aio_co_schedule(AioContext *ctx, Coroutine *co)
+{
+    trace_aio_co_schedule(ctx, co);
+    QSLIST_INSERT_HEAD_ATOMIC(&ctx->scheduled_coroutines,
+                              co, co_scheduled_next);
+    qemu_bh_schedule(ctx->co_schedule_bh);
+}
+
+void aio_co_wake(struct Coroutine *co)
+{
+    AioContext *ctx;
+
+    /* Read coroutine before co->ctx.  Matches smp_wmb in
+     * qemu_coroutine_enter.
+     */
+    smp_read_barrier_depends();
+    ctx = atomic_read(&co->ctx);
+
+    if (ctx != qemu_get_current_aio_context()) {
+        aio_co_schedule(ctx, co);
+        return;
+    }
+
+    if (qemu_in_coroutine()) {
+        Coroutine *self = qemu_coroutine_self();
+        assert(self != co);
+        QSIMPLEQ_INSERT_TAIL(&self->co_queue_wakeup, co, co_queue_next);
+    } else {
+        aio_context_acquire(ctx);
+        qemu_coroutine_enter(co);
+        aio_context_release(ctx);
+    }
+}
+
 void aio_context_ref(AioContext *ctx)
 {
     g_source_ref(&ctx->source);
diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine.c
+++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/atomic.h"
 #include "qemu/coroutine.h"
 #include "qemu/coroutine_int.h"
+#include "block/aio.h"
 
 enum {
     POOL_BATCH_SIZE = 64,
@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
     }
 
     co->caller = self;
+    co->ctx = qemu_get_current_aio_context();
+
+    /* Store co->ctx before anything that stores co.  Matches
+     * barrier in aio_co_wake.
+     */
+    smp_wmb();
+
     ret = qemu_coroutine_switch(self, co, COROUTINE_ENTER);
 
     qemu_co_queue_run_restart(co);
diff --git a/util/trace-events b/util/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/util/trace-events
+++ b/util/trace-events
@@ -XXX,XX +XXX,XX @@ run_poll_handlers_end(void *ctx, bool progress) "ctx %p progress %d"
 poll_shrink(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
 poll_grow(void *ctx, int64_t old, int64_t new) "ctx %p old %"PRId64" new %"PRId64
 
+# util/async.c
+aio_co_schedule(void *ctx, void *co) "ctx %p co %p"
+aio_co_schedule_bh_cb(void *ctx, void *co) "ctx %p co %p"
+
 # util/thread-pool.c
 thread_pool_submit(void *pool, void *req, void *opaque) "pool %p req %p opaque %p"
 thread_pool_complete(void *pool, void *req, void *opaque, int ret) "pool %p req %p opaque %p ret %d"
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

qcow2_create2 calls this.  Do not run a nested event loop, as that
breaks when aio_co_wake tries to queue the coroutine on the co_queue_wakeup
list of the currently running one.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-4-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
 {
     QEMUIOVector qiov;
     struct iovec iov;
-    Coroutine *co;
     BlkRwCo rwco;
 
     iov = (struct iovec) {
@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
         .ret    = NOT_DONE,
     };
 
-    co = qemu_coroutine_create(co_entry, &rwco);
-    qemu_coroutine_enter(co);
-    BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
+    if (qemu_in_coroutine()) {
+        /* Fast-path if already in coroutine context */
+        co_entry(&rwco);
+    } else {
+        Coroutine *co = qemu_coroutine_create(co_entry, &rwco);
+        qemu_coroutine_enter(co);
+        BDRV_POLL_WHILE(blk_bs(blk), rwco.ret == NOT_DONE);
+    }
 
     return rwco.ret;
 }
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Once the thread pool starts using aio_co_wake, it will also need
qemu_get_current_aio_context().  Make test-thread-pool create
an AioContext with qemu_init_main_loop, so that stubs/iothread.c
and tests/iothread.c can provide the rest.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-5-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/test-thread-pool.c | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/tests/test-thread-pool.c b/tests/test-thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-thread-pool.c
+++ b/tests/test-thread-pool.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "qemu/timer.h"
 #include "qemu/error-report.h"
+#include "qemu/main-loop.h"
 
 static AioContext *ctx;
 static ThreadPool *pool;
@@ -XXX,XX +XXX,XX @@ static void test_cancel_async(void)
 int main(int argc, char **argv)
 {
     int ret;
-    Error *local_error = NULL;
 
-    init_clocks();
-
-    ctx = aio_context_new(&local_error);
-    if (!ctx) {
-        error_reportf_err(local_error, "Failed to create AIO Context: ");
-        exit(1);
-    }
+    qemu_init_main_loop(&error_abort);
+    ctx = qemu_get_current_aio_context();
     pool = aio_get_thread_pool(ctx);
 
     g_test_init(&argc, &argv, NULL);
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
 
     ret = g_test_run();
 
-    aio_context_unref(ctx);
     return ret;
 }
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This is in preparation for making qio_channel_yield work on
AioContexts other than the main one.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-6-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/io/channel.h | 25 +++++++++++++++++++++++++
 io/channel-command.c | 13 +++++++++++++
 io/channel-file.c    | 11 +++++++++++
 io/channel-socket.c  | 16 +++++++++++-----
 io/channel-tls.c     | 12 ++++++++++++
 io/channel-watch.c   |  6 ++++++
 io/channel.c         | 11 +++++++++++
 7 files changed, 89 insertions(+), 5 deletions(-)

diff --git a/include/io/channel.h b/include/io/channel.h
index XXXXXXX..XXXXXXX 100644
--- a/include/io/channel.h
+++ b/include/io/channel.h
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu-common.h"
 #include "qom/object.h"
+#include "block/aio.h"
 
 #define TYPE_QIO_CHANNEL "qio-channel"
 #define QIO_CHANNEL(obj)                                    \
@@ -XXX,XX +XXX,XX @@ struct QIOChannelClass {
                      off_t offset,
                      int whence,
                      Error **errp);
+    void (*io_set_aio_fd_handler)(QIOChannel *ioc,
+                                  AioContext *ctx,
+                                  IOHandler *io_read,
+                                  IOHandler *io_write,
+                                  void *opaque);
 };
 
 /* General I/O handling functions */
@@ -XXX,XX +XXX,XX @@ void qio_channel_yield(QIOChannel *ioc,
 void qio_channel_wait(QIOChannel *ioc,
                       GIOCondition condition);
 
+/**
+ * qio_channel_set_aio_fd_handler:
+ * @ioc: the channel object
+ * @ctx: the AioContext to set the handlers on
+ * @io_read: the read handler
+ * @io_write: the write handler
+ * @opaque: the opaque value passed to the handler
+ *
+ * This is used internally by qio_channel_yield().  It can
+ * be used by channel implementations to forward the handlers
+ * to another channel (e.g. from #QIOChannelTLS to the
+ * underlying socket).
+ */
+void qio_channel_set_aio_fd_handler(QIOChannel *ioc,
+                                    AioContext *ctx,
+                                    IOHandler *io_read,
+                                    IOHandler *io_write,
+                                    void *opaque);
+
 #endif /* QIO_CHANNEL_H */
diff --git a/io/channel-command.c b/io/channel-command.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-command.c
+++ b/io/channel-command.c
@@ -XXX,XX +XXX,XX @@ static int qio_channel_command_close(QIOChannel *ioc,
 }
 
 
+static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
+                                                   AioContext *ctx,
+                                                   IOHandler *io_read,
+                                                   IOHandler *io_write,
+                                                   void *opaque)
+{
+    QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
+    aio_set_fd_handler(ctx, cioc->readfd, false, io_read, NULL, NULL, opaque);
+    aio_set_fd_handler(ctx, cioc->writefd, false, NULL, io_write, NULL, opaque);
+}
+
+
 static GSource *qio_channel_command_create_watch(QIOChannel *ioc,
                                                  GIOCondition condition)
 {
@@ -XXX,XX +XXX,XX @@ static void qio_channel_command_class_init(ObjectClass *klass,
     ioc_klass->io_set_blocking = qio_channel_command_set_blocking;
     ioc_klass->io_close = qio_channel_command_close;
     ioc_klass->io_create_watch = qio_channel_command_create_watch;
+    ioc_klass->io_set_aio_fd_handler = qio_channel_command_set_aio_fd_handler;
 }
 
 static const TypeInfo qio_channel_command_info = {
diff --git a/io/channel-file.c b/io/channel-file.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-file.c
+++ b/io/channel-file.c
@@ -XXX,XX +XXX,XX @@ static int qio_channel_file_close(QIOChannel *ioc,
 }
 
 
+static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
+                                                AioContext *ctx,
+                                                IOHandler *io_read,
+                                                IOHandler *io_write,
+                                                void *opaque)
+{
+    QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
+    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write, NULL, opaque);
+}
+
 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
                                               GIOCondition condition)
 {
@@ -XXX,XX +XXX,XX @@ static void qio_channel_file_class_init(ObjectClass *klass,
     ioc_klass->io_seek = qio_channel_file_seek;
     ioc_klass->io_close = qio_channel_file_close;
     ioc_klass->io_create_watch = qio_channel_file_create_watch;
+    ioc_klass->io_set_aio_fd_handler = qio_channel_file_set_aio_fd_handler;
 }
 
 static const TypeInfo qio_channel_file_info = {
diff --git a/io/channel-socket.c b/io/channel-socket.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-socket.c
+++ b/io/channel-socket.c
@@ -XXX,XX +XXX,XX @@ qio_channel_socket_set_blocking(QIOChannel *ioc,
         qemu_set_block(sioc->fd);
     } else {
         qemu_set_nonblock(sioc->fd);
-#ifdef WIN32
-        WSAEventSelect(sioc->fd, ioc->event,
-                       FD_READ | FD_ACCEPT | FD_CLOSE |
-                       FD_CONNECT | FD_WRITE | FD_OOB);
-#endif
     }
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ qio_channel_socket_shutdown(QIOChannel *ioc,
     return 0;
 }
 
+static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc,
+                                                  AioContext *ctx,
+                                                  IOHandler *io_read,
+                                                  IOHandler *io_write,
+                                                  void *opaque)
+{
+    QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
+    aio_set_fd_handler(ctx, sioc->fd, false, io_read, io_write, NULL, opaque);
+}
+
 static GSource *qio_channel_socket_create_watch(QIOChannel *ioc,
                                                 GIOCondition condition)
 {
@@ -XXX,XX +XXX,XX @@ static void qio_channel_socket_class_init(ObjectClass *klass,
     ioc_klass->io_set_cork = qio_channel_socket_set_cork;
     ioc_klass->io_set_delay = qio_channel_socket_set_delay;
     ioc_klass->io_create_watch = qio_channel_socket_create_watch;
+    ioc_klass->io_set_aio_fd_handler = qio_channel_socket_set_aio_fd_handler;
 }
 
 static const TypeInfo qio_channel_socket_info = {
diff --git a/io/channel-tls.c b/io/channel-tls.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-tls.c
+++ b/io/channel-tls.c
@@ -XXX,XX +XXX,XX @@ static int qio_channel_tls_close(QIOChannel *ioc,
     return qio_channel_close(tioc->master, errp);
 }
 
+static void qio_channel_tls_set_aio_fd_handler(QIOChannel *ioc,
+                                               AioContext *ctx,
+                                               IOHandler *io_read,
+                                               IOHandler *io_write,
+                                               void *opaque)
+{
+    QIOChannelTLS *tioc = QIO_CHANNEL_TLS(ioc);
+
+    qio_channel_set_aio_fd_handler(tioc->master, ctx, io_read, io_write, opaque);
+}
+
 static GSource *qio_channel_tls_create_watch(QIOChannel *ioc,
                                              GIOCondition condition)
 {
@@ -XXX,XX +XXX,XX @@ static void qio_channel_tls_class_init(ObjectClass *klass,
     ioc_klass->io_close = qio_channel_tls_close;
     ioc_klass->io_shutdown = qio_channel_tls_shutdown;
     ioc_klass->io_create_watch = qio_channel_tls_create_watch;
+    ioc_klass->io_set_aio_fd_handler = qio_channel_tls_set_aio_fd_handler;
 }
 
 static const TypeInfo qio_channel_tls_info = {
diff --git a/io/channel-watch.c b/io/channel-watch.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-watch.c
+++ b/io/channel-watch.c
@@ -XXX,XX +XXX,XX @@ GSource *qio_channel_create_socket_watch(QIOChannel *ioc,
     GSource *source;
     QIOChannelSocketSource *ssource;
 
+#ifdef WIN32
+    WSAEventSelect(socket, ioc->event,
+                   FD_READ | FD_ACCEPT | FD_CLOSE |
+                   FD_CONNECT | FD_WRITE | FD_OOB);
+#endif
+
     source = g_source_new(&qio_channel_socket_source_funcs,
                           sizeof(QIOChannelSocketSource));
     ssource = (QIOChannelSocketSource *)source;
diff --git a/io/channel.c b/io/channel.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel.c
+++ b/io/channel.c
@@ -XXX,XX +XXX,XX @@ GSource *qio_channel_create_watch(QIOChannel *ioc,
 }
 
 
+void qio_channel_set_aio_fd_handler(QIOChannel *ioc,
+                                    AioContext *ctx,
+                                    IOHandler *io_read,
+                                    IOHandler *io_write,
+                                    void *opaque)
+{
+    QIOChannelClass *klass = QIO_CHANNEL_GET_CLASS(ioc);
+
+    klass->io_set_aio_fd_handler(ioc, ctx, io_read, io_write, opaque);
+}
+
 guint qio_channel_add_watch(QIOChannel *ioc,
                             GIOCondition condition,
                             QIOChannelFunc func,
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Support separate coroutines for reading and writing, and place the
read/write handlers on the AioContext that the QIOChannel is registered
with.

Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213135235.12274-7-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/io/channel.h | 47 ++++++++++++++++++++++++++--
 io/channel.c         | 86 +++++++++++++++++++++++++++++++++++++++-------------
 2 files changed, 109 insertions(+), 24 deletions(-)

diff --git a/include/io/channel.h b/include/io/channel.h
index XXXXXXX..XXXXXXX 100644
--- a/include/io/channel.h
+++ b/include/io/channel.h
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu-common.h"
 #include "qom/object.h"
+#include "qemu/coroutine.h"
 #include "block/aio.h"
 
 #define TYPE_QIO_CHANNEL "qio-channel"
@@ -XXX,XX +XXX,XX @@ struct QIOChannel {
     Object parent;
     unsigned int features; /* bitmask of QIOChannelFeatures */
     char *name;
+    AioContext *ctx;
+    Coroutine *read_coroutine;
+    Coroutine *write_coroutine;
 #ifdef _WIN32
     HANDLE event; /* For use with GSource on Win32 */
 #endif
@@ -XXX,XX +XXX,XX @@ guint qio_channel_add_watch(QIOChannel *ioc,
 
 
 /**
+ * qio_channel_attach_aio_context:
+ * @ioc: the channel object
+ * @ctx: the #AioContext to set the handlers on
+ *
+ * Request that qio_channel_yield() sets I/O handlers on
+ * the given #AioContext.  If @ctx is %NULL, qio_channel_yield()
+ * uses QEMU's main thread event loop.
+ *
+ * You can move a #QIOChannel from one #AioContext to another even if
+ * I/O handlers are set for a coroutine.  However, #QIOChannel provides
+ * no synchronization between the calls to qio_channel_yield() and
+ * qio_channel_attach_aio_context().
+ *
+ * Therefore you should first call qio_channel_detach_aio_context()
+ * to ensure that the coroutine is not entered concurrently.  Then,
+ * while the coroutine has yielded, call qio_channel_attach_aio_context(),
+ * and then aio_co_schedule() to place the coroutine on the new
+ * #AioContext.  The calls to qio_channel_detach_aio_context()
+ * and qio_channel_attach_aio_context() should be protected with
+ * aio_context_acquire() and aio_context_release().
+ */
+void qio_channel_attach_aio_context(QIOChannel *ioc,
+                                    AioContext *ctx);
+
+/**
+ * qio_channel_detach_aio_context:
+ * @ioc: the channel object
+ *
+ * Disable any I/O handlers set by qio_channel_yield().  With the
+ * help of aio_co_schedule(), this allows moving a coroutine that was
+ * paused by qio_channel_yield() to another context.
+ */
+void qio_channel_detach_aio_context(QIOChannel *ioc);
+
+/**
  * qio_channel_yield:
  * @ioc: the channel object
  * @condition: the I/O condition to wait for
  *
- * Yields execution from the current coroutine until
- * the condition indicated by @condition becomes
- * available.
+ * Yields execution from the current coroutine until the condition
+ * indicated by @condition becomes available.  @condition must
+ * be either %G_IO_IN or %G_IO_OUT; it cannot contain both.  In
+ * addition, no two coroutine can be waiting on the same condition
+ * and channel at the same time.
  *
  * This must only be called from coroutine context
  */
diff --git a/io/channel.c b/io/channel.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel.c
+++ b/io/channel.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "io/channel.h"
 #include "qapi/error.h"
-#include "qemu/coroutine.h"
+#include "qemu/main-loop.h"
 
 bool qio_channel_has_feature(QIOChannel *ioc,
                              QIOChannelFeature feature)
@@ -XXX,XX +XXX,XX @@ off_t qio_channel_io_seek(QIOChannel *ioc,
 }
 
 
-typedef struct QIOChannelYieldData QIOChannelYieldData;
-struct QIOChannelYieldData {
-    QIOChannel *ioc;
-    Coroutine *co;
-};
+static void qio_channel_set_aio_fd_handlers(QIOChannel *ioc);
 
+static void qio_channel_restart_read(void *opaque)
+{
+    QIOChannel *ioc = opaque;
+    Coroutine *co = ioc->read_coroutine;
+
+    ioc->read_coroutine = NULL;
+    qio_channel_set_aio_fd_handlers(ioc);
+    aio_co_wake(co);
+}
 
-static gboolean qio_channel_yield_enter(QIOChannel *ioc,
-                                        GIOCondition condition,
-                                        gpointer opaque)
+static void qio_channel_restart_write(void *opaque)
 {
-    QIOChannelYieldData *data = opaque;
-    qemu_coroutine_enter(data->co);
-    return FALSE;
+    QIOChannel *ioc = opaque;
+    Coroutine *co = ioc->write_coroutine;
+
+    ioc->write_coroutine = NULL;
+    qio_channel_set_aio_fd_handlers(ioc);
+    aio_co_wake(co);
 }
 
+static void qio_channel_set_aio_fd_handlers(QIOChannel *ioc)
+{
+    IOHandler *rd_handler = NULL, *wr_handler = NULL;
+    AioContext *ctx;
+
+    if (ioc->read_coroutine) {
+        rd_handler = qio_channel_restart_read;
+    }
+    if (ioc->write_coroutine) {
+        wr_handler = qio_channel_restart_write;
+    }
+
+    ctx = ioc->ctx ? ioc->ctx : iohandler_get_aio_context();
+    qio_channel_set_aio_fd_handler(ioc, ctx, rd_handler, wr_handler, ioc);
+}
+
+void qio_channel_attach_aio_context(QIOChannel *ioc,
+                                    AioContext *ctx)
+{
+    AioContext *old_ctx;
+    if (ioc->ctx == ctx) {
+        return;
+    }
+
+    old_ctx = ioc->ctx ? ioc->ctx : iohandler_get_aio_context();
+    qio_channel_set_aio_fd_handler(ioc, old_ctx, NULL, NULL, NULL);
+    ioc->ctx = ctx;
+    qio_channel_set_aio_fd_handlers(ioc);
+}
+
+void qio_channel_detach_aio_context(QIOChannel *ioc)
+{
+    ioc->read_coroutine = NULL;
+    ioc->write_coroutine = NULL;
+    qio_channel_set_aio_fd_handlers(ioc);
+    ioc->ctx = NULL;
+}
 
 void coroutine_fn qio_channel_yield(QIOChannel *ioc,
                                     GIOCondition condition)
 {
-    QIOChannelYieldData data;
-
     assert(qemu_in_coroutine());
-    data.ioc = ioc;
-    data.co = qemu_coroutine_self();
-    qio_channel_add_watch(ioc,
-                          condition,
-                          qio_channel_yield_enter,
-                          &data,
-                          NULL);
+    if (condition == G_IO_IN) {
+        assert(!ioc->read_coroutine);
+        ioc->read_coroutine = qemu_coroutine_self();
+    } else if (condition == G_IO_OUT) {
+        assert(!ioc->write_coroutine);
+        ioc->write_coroutine = qemu_coroutine_self();
+    } else {
+        abort();
+    }
+    qio_channel_set_aio_fd_handlers(ioc);
     qemu_coroutine_yield();
 }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

In the client, read the reply headers from a coroutine, switching the
read side between the "read header" coroutine and the I/O coroutine that
reads the body of the reply.

In the server, if the server can read more requests it will create a new
"read request" coroutine as soon as a request has been read.  Otherwise,
the new coroutine is created in nbd_request_put.

diff --git a/block/nbd-client.h b/block/nbd-client.h
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd-client.h
+++ b/block/nbd-client.h
@@ -XXX,XX +XXX,XX @@ typedef struct NBDClientSession {
 
     CoMutex send_mutex;
     CoQueue free_sema;
-    Coroutine *send_coroutine;
+    Coroutine *read_reply_co;
     int in_flight;
 
     Coroutine *recv_coroutine[MAX_NBD_REQUESTS];
diff --git a/block/nbd-client.c b/block/nbd-client.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd-client.c
+++ b/block/nbd-client.c
@@ -XXX,XX +XXX,XX @@
 #define HANDLE_TO_INDEX(bs, handle) ((handle) ^ ((uint64_t)(intptr_t)bs))
 #define INDEX_TO_HANDLE(bs, index)  ((index)  ^ ((uint64_t)(intptr_t)bs))
 
-static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
+static void nbd_recv_coroutines_enter_all(BlockDriverState *bs)
 {
+    NBDClientSession *s = nbd_get_client_session(bs);
     int i;
 
     for (i = 0; i < MAX_NBD_REQUESTS; i++) {
@@ -XXX,XX +XXX,XX @@ static void nbd_recv_coroutines_enter_all(NBDClientSession *s)
             qemu_coroutine_enter(s->recv_coroutine[i]);
         }
     }
+    BDRV_POLL_WHILE(bs, s->read_reply_co);
 }
 
 static void nbd_teardown_connection(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
     qio_channel_shutdown(client->ioc,
                          QIO_CHANNEL_SHUTDOWN_BOTH,
                          NULL);
-    nbd_recv_coroutines_enter_all(client);
+    nbd_recv_coroutines_enter_all(bs);
 
     nbd_client_detach_aio_context(bs);
     object_unref(OBJECT(client->sioc));
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
     client->ioc = NULL;
 }
 
-static void nbd_reply_ready(void *opaque)
+static coroutine_fn void nbd_read_reply_entry(void *opaque)
 {
-    BlockDriverState *bs = opaque;
-    NBDClientSession *s = nbd_get_client_session(bs);
+    NBDClientSession *s = opaque;
     uint64_t i;
     int ret;
 
-    if (!s->ioc) { /* Already closed */
-        return;
-    }
-
-    if (s->reply.handle == 0) {
-        /* No reply already in flight.  Fetch a header.  It is possible
-         * that another thread has done the same thing in parallel, so
-         * the socket is not readable anymore.
-         */
+    for (;;) {
+        assert(s->reply.handle == 0);
         ret = nbd_receive_reply(s->ioc, &s->reply);
-        if (ret == -EAGAIN) {
-            return;
-        }
         if (ret < 0) {
-            s->reply.handle = 0;
-            goto fail;
+            break;
         }
-    }
 
-    /* There's no need for a mutex on the receive side, because the
-     * handler acts as a synchronization point and ensures that only
-     * one coroutine is called until the reply finishes.  */
-    i = HANDLE_TO_INDEX(s, s->reply.handle);
-    if (i >= MAX_NBD_REQUESTS) {
-        goto fail;
-    }
+        /* There's no need for a mutex on the receive side, because the
+         * handler acts as a synchronization point and ensures that only
+         * one coroutine is called until the reply finishes.
+         */
+        i = HANDLE_TO_INDEX(s, s->reply.handle);
+        if (i >= MAX_NBD_REQUESTS || !s->recv_coroutine[i]) {
+            break;
+        }
 
-    if (s->recv_coroutine[i]) {
-        qemu_coroutine_enter(s->recv_coroutine[i]);
-        return;
+        /* We're woken up by the recv_coroutine itself.  Note that there
+         * is no race between yielding and reentering read_reply_co.  This
+         * is because:
+         *
+         * - if recv_coroutine[i] runs on the same AioContext, it is only
+         *   entered after we yield
+         *
+         * - if recv_coroutine[i] runs on a different AioContext, reentering
+         *   read_reply_co happens through a bottom half, which can only
+         *   run after we yield.
+         */
+        aio_co_wake(s->recv_coroutine[i]);
+        qemu_coroutine_yield();
     }
-
-fail:
-    nbd_teardown_connection(bs);
-}
-
-static void nbd_restart_write(void *opaque)
-{
-    BlockDriverState *bs = opaque;
-
-    qemu_coroutine_enter(nbd_get_client_session(bs)->send_coroutine);
+    s->read_reply_co = NULL;
 }
 
 static int nbd_co_send_request(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
                                QEMUIOVector *qiov)
 {
     NBDClientSession *s = nbd_get_client_session(bs);
-    AioContext *aio_context;
     int rc, ret, i;
 
     qemu_co_mutex_lock(&s->send_mutex);
@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
         return -EPIPE;
     }
 
-    s->send_coroutine = qemu_coroutine_self();
-    aio_context = bdrv_get_aio_context(bs);
-
-    aio_set_fd_handler(aio_context, s->sioc->fd, false,
-                       nbd_reply_ready, nbd_restart_write, NULL, bs);
     if (qiov) {
         qio_channel_set_cork(s->ioc, true);
         rc = nbd_send_request(s->ioc, request);
@@ -XXX,XX +XXX,XX @@ static int nbd_co_send_request(BlockDriverState *bs,
     } else {
         rc = nbd_send_request(s->ioc, request);
     }
-    aio_set_fd_handler(aio_context, s->sioc->fd, false,
-                       nbd_reply_ready, NULL, NULL, bs);
-    s->send_coroutine = NULL;
     qemu_co_mutex_unlock(&s->send_mutex);
     return rc;
 }
@@ -XXX,XX +XXX,XX @@ static void nbd_co_receive_reply(NBDClientSession *s,
 {
     int ret;
 
-    /* Wait until we're woken up by the read handler.  TODO: perhaps
-     * peek at the next reply and avoid yielding if it's ours?  */
+    /* Wait until we're woken up by nbd_read_reply_entry.  */
     qemu_coroutine_yield();
     *reply = s->reply;
     if (reply->handle != request->handle ||
@@ -XXX,XX +XXX,XX @@ static void nbd_coroutine_start(NBDClientSession *s,
     /* s->recv_coroutine[i] is set as soon as we get the send_lock.  */
 }
 
-static void nbd_coroutine_end(NBDClientSession *s,
+static void nbd_coroutine_end(BlockDriverState *bs,
                               NBDRequest *request)
 {
+    NBDClientSession *s = nbd_get_client_session(bs);
     int i = HANDLE_TO_INDEX(s, request->handle);
+
     s->recv_coroutine[i] = NULL;
-    if (s->in_flight-- == MAX_NBD_REQUESTS) {
-        qemu_co_queue_next(&s->free_sema);
+    s->in_flight--;
+    qemu_co_queue_next(&s->free_sema);
+
+    /* Kick the read_reply_co to get the next reply.  */
+    if (s->read_reply_co) {
+        aio_co_wake(s->read_reply_co);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ int nbd_client_co_preadv(BlockDriverState *bs, uint64_t offset,
     } else {
         nbd_co_receive_reply(client, &request, &reply, qiov);
     }
-    nbd_coroutine_end(client, &request);
+    nbd_coroutine_end(bs, &request);
     return -reply.error;
 }
 
@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pwritev(BlockDriverState *bs, uint64_t offset,
     } else {
         nbd_co_receive_reply(client, &request, &reply, NULL);
     }
-    nbd_coroutine_end(client, &request);
+    nbd_coroutine_end(bs, &request);
     return -reply.error;
 }
 
@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset,
     } else {
         nbd_co_receive_reply(client, &request, &reply, NULL);
     }
-    nbd_coroutine_end(client, &request);
+    nbd_coroutine_end(bs, &request);
     return -reply.error;
 }
 
@@ -XXX,XX +XXX,XX @@ int nbd_client_co_flush(BlockDriverState *bs)
     } else {
         nbd_co_receive_reply(client, &request, &reply, NULL);
     }
-    nbd_coroutine_end(client, &request);
+    nbd_coroutine_end(bs, &request);
     return -reply.error;
 }
 
@@ -XXX,XX +XXX,XX @@ int nbd_client_co_pdiscard(BlockDriverState *bs, int64_t offset, int count)
     } else {
         nbd_co_receive_reply(client, &request, &reply, NULL);
     }
-    nbd_coroutine_end(client, &request);
+    nbd_coroutine_end(bs, &request);
     return -reply.error;
 
 }
 
 void nbd_client_detach_aio_context(BlockDriverState *bs)
 {
-    aio_set_fd_handler(bdrv_get_aio_context(bs),
-                       nbd_get_client_session(bs)->sioc->fd,
-                       false, NULL, NULL, NULL, NULL);
+    NBDClientSession *client = nbd_get_client_session(bs);
+    qio_channel_detach_aio_context(QIO_CHANNEL(client->sioc));
 }
 
 void nbd_client_attach_aio_context(BlockDriverState *bs,
                                    AioContext *new_context)
 {
-    aio_set_fd_handler(new_context, nbd_get_client_session(bs)->sioc->fd,
-                       false, nbd_reply_ready, NULL, NULL, bs);
+    NBDClientSession *client = nbd_get_client_session(bs);
+    qio_channel_attach_aio_context(QIO_CHANNEL(client->sioc), new_context);
+    aio_co_schedule(new_context, client->read_reply_co);
 }
 
 void nbd_client_close(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ int nbd_client_init(BlockDriverState *bs,
     /* Now that we're connected, set the socket to be non-blocking and
      * kick the reply mechanism.  */
     qio_channel_set_blocking(QIO_CHANNEL(sioc), false, NULL);
-
+    client->read_reply_co = qemu_coroutine_create(nbd_read_reply_entry, client);
     nbd_client_attach_aio_context(bs, bdrv_get_aio_context(bs));
 
     logout("Established connection with NBD server\n");
diff --git a/nbd/client.c b/nbd/client.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/client.c
+++ b/nbd/client.c
@@ -XXX,XX +XXX,XX @@ ssize_t nbd_receive_reply(QIOChannel *ioc, NBDReply *reply)
     ssize_t ret;
 
     ret = read_sync(ioc, buf, sizeof(buf));
-    if (ret < 0) {
+    if (ret <= 0) {
         return ret;
     }
 
diff --git a/nbd/common.c b/nbd/common.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/common.c
+++ b/nbd/common.c
@@ -XXX,XX +XXX,XX @@ ssize_t nbd_wr_syncv(QIOChannel *ioc,
         }
         if (len == QIO_CHANNEL_ERR_BLOCK) {
             if (qemu_in_coroutine()) {
-                /* XXX figure out if we can create a variant on
-                 * qio_channel_yield() that works with AIO contexts
-                 * and consider using that in this branch */
-                qemu_coroutine_yield();
-            } else if (done) {
-                /* XXX this is needed by nbd_reply_ready.  */
-                qio_channel_wait(ioc,
-                                 do_read ? G_IO_IN : G_IO_OUT);
+                qio_channel_yield(ioc, do_read ? G_IO_IN : G_IO_OUT);
             } else {
                 return -EAGAIN;
             }
diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ struct NBDClient {
     CoMutex send_lock;
     Coroutine *send_coroutine;
 
-    bool can_read;
-
     QTAILQ_ENTRY(NBDClient) next;
     int nb_requests;
     bool closing;
@@ -XXX,XX +XXX,XX @@ struct NBDClient {
 
 /* That's all folks */
 
-static void nbd_set_handlers(NBDClient *client);
-static void nbd_unset_handlers(NBDClient *client);
-static void nbd_update_can_read(NBDClient *client);
+static void nbd_client_receive_next_request(NBDClient *client);
 
 static gboolean nbd_negotiate_continue(QIOChannel *ioc,
                                        GIOCondition condition,
@@ -XXX,XX +XXX,XX @@ void nbd_client_put(NBDClient *client)
          */
         assert(client->closing);
 
-        nbd_unset_handlers(client);
+        qio_channel_detach_aio_context(client->ioc);
         object_unref(OBJECT(client->sioc));
         object_unref(OBJECT(client->ioc));
         if (client->tlscreds) {
@@ -XXX,XX +XXX,XX @@ static NBDRequestData *nbd_request_get(NBDClient *client)
 
     assert(client->nb_requests <= MAX_NBD_REQUESTS - 1);
     client->nb_requests++;
-    nbd_update_can_read(client);
 
     req = g_new0(NBDRequestData, 1);
     nbd_client_get(client);
@@ -XXX,XX +XXX,XX @@ static void nbd_request_put(NBDRequestData *req)
     g_free(req);
 
     client->nb_requests--;
-    nbd_update_can_read(client);
+    nbd_client_receive_next_request(client);
+
     nbd_client_put(client);
 }
 
@@ -XXX,XX +XXX,XX @@ static void blk_aio_attached(AioContext *ctx, void *opaque)
     exp->ctx = ctx;
 
     QTAILQ_FOREACH(client, &exp->clients, next) {
-        nbd_set_handlers(client);
+        qio_channel_attach_aio_context(client->ioc, ctx);
+        if (client->recv_coroutine) {
+            aio_co_schedule(ctx, client->recv_coroutine);
+        }
+        if (client->send_coroutine) {
+            aio_co_schedule(ctx, client->send_coroutine);
+        }
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)
     TRACE("Export %s: Detaching clients from AIO context %p\n", exp->name, exp->ctx);
 
     QTAILQ_FOREACH(client, &exp->clients, next) {
-        nbd_unset_handlers(client);
+        qio_channel_detach_aio_context(client->ioc);
     }
 
     exp->ctx = NULL;
@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_send_reply(NBDRequestData *req, NBDReply *reply,
     g_assert(qemu_in_coroutine());
     qemu_co_mutex_lock(&client->send_lock);
     client->send_coroutine = qemu_coroutine_self();
-    nbd_set_handlers(client);
 
     if (!len) {
         rc = nbd_send_reply(client->ioc, reply);
@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_send_reply(NBDRequestData *req, NBDReply *reply,
     }
 
     client->send_coroutine = NULL;
-    nbd_set_handlers(client);
     qemu_co_mutex_unlock(&client->send_lock);
     return rc;
 }
@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_receive_request(NBDRequestData *req,
     ssize_t rc;
 
     g_assert(qemu_in_coroutine());
-    client->recv_coroutine = qemu_coroutine_self();
-    nbd_update_can_read(client);
-
+    assert(client->recv_coroutine == qemu_coroutine_self());
     rc = nbd_receive_request(client->ioc, request);
     if (rc < 0) {
         if (rc != -EAGAIN) {
@@ -XXX,XX +XXX,XX @@ static ssize_t nbd_co_receive_request(NBDRequestData *req,
 
 out:
     client->recv_coroutine = NULL;
-    nbd_update_can_read(client);
+    nbd_client_receive_next_request(client);
 
     return rc;
 }
 
-static void nbd_trip(void *opaque)
+/* Owns a reference to the NBDClient passed as opaque.  */
+static coroutine_fn void nbd_trip(void *opaque)
 {
     NBDClient *client = opaque;
     NBDExport *exp = client->exp;
     NBDRequestData *req;
-    NBDRequest request;
+    NBDRequest request = { 0 };    /* GCC thinks it can be used uninitialized */
     NBDReply reply;
     ssize_t ret;
     int flags;
 
     TRACE("Reading request.");
     if (client->closing) {
+        nbd_client_put(client);
         return;
     }
 
@@ -XXX,XX +XXX,XX @@ static void nbd_trip(void *opaque)
 
 done:
     nbd_request_put(req);
+    nbd_client_put(client);
     return;
 
 out:
     nbd_request_put(req);
     client_close(client);
+    nbd_client_put(client);
 }
 
-static void nbd_read(void *opaque)
+static void nbd_client_receive_next_request(NBDClient *client)
 {
-    NBDClient *client = opaque;
-
-    if (client->recv_coroutine) {
-        qemu_coroutine_enter(client->recv_coroutine);
-    } else {
-        qemu_coroutine_enter(qemu_coroutine_create(nbd_trip, client));
-    }
-}
-
-static void nbd_restart_write(void *opaque)
-{
-    NBDClient *client = opaque;
-
-    qemu_coroutine_enter(client->send_coroutine);
-}
-
-static void nbd_set_handlers(NBDClient *client)
-{
-    if (client->exp && client->exp->ctx) {
-        aio_set_fd_handler(client->exp->ctx, client->sioc->fd, true,
-                           client->can_read ? nbd_read : NULL,
-                           client->send_coroutine ? nbd_restart_write : NULL,
-                           NULL, client);
-    }
-}
-
-static void nbd_unset_handlers(NBDClient *client)
-{
-    if (client->exp && client->exp->ctx) {
-        aio_set_fd_handler(client->exp->ctx, client->sioc->fd, true, NULL,
-                           NULL, NULL, NULL);
-    }
-}
-
-static void nbd_update_can_read(NBDClient *client)
-{
-    bool can_read = client->recv_coroutine ||
-                    client->nb_requests < MAX_NBD_REQUESTS;
-
-    if (can_read != client->can_read) {
-        client->can_read = can_read;
-        nbd_set_handlers(client);
-
-        /* There is no need to invoke aio_notify(), since aio_set_fd_handler()
-         * in nbd_set_handlers() will have taken care of that */
+    if (!client->recv_coroutine && client->nb_requests < MAX_NBD_REQUESTS) {
+        nbd_client_get(client);
+        client->recv_coroutine = qemu_coroutine_create(nbd_trip, client);
+        aio_co_schedule(client->exp->ctx, client->recv_coroutine);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_co_client_start(void *opaque)
         goto out;
     }
     qemu_co_mutex_init(&client->send_lock);
-    nbd_set_handlers(client);
 
     if (exp) {
         QTAILQ_INSERT_TAIL(&exp->clients, client, next);
     }
+
+    nbd_client_receive_next_request(client);
+
 out:
     g_free(data);
 }
@@ -XXX,XX +XXX,XX @@ void nbd_client_new(NBDExport *exp,
     object_ref(OBJECT(client->sioc));
     client->ioc = QIO_CHANNEL(sioc);
     object_ref(OBJECT(client->ioc));
-    client->can_read = true;
     client->close = close_fn;
 
     data->client = client;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

As a small step towards the introduction of multiqueue, we want
coroutines to remain on the same AioContext that started them,
unless they are moved explicitly with e.g. aio_co_schedule.  This patch
avoids that coroutines switch AioContext when they use a CoMutex.
For now it does not make much of a difference, because the CoMutex
is not thread-safe and the AioContext itself is used to protect the
CoMutex from concurrent access.  However, this is going to change.

diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-lock.c
+++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/coroutine.h"
 #include "qemu/coroutine_int.h"
 #include "qemu/queue.h"
+#include "block/aio.h"
 #include "trace.h"
 
 void qemu_co_queue_init(CoQueue *queue)
@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_run_restart(Coroutine *co)
 
 static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
 {
-    Coroutine *self = qemu_coroutine_self();
     Coroutine *next;
 
     if (QSIMPLEQ_EMPTY(&queue->entries)) {
@@ -XXX,XX +XXX,XX @@ static bool qemu_co_queue_do_restart(CoQueue *queue, bool single)
 
     while ((next = QSIMPLEQ_FIRST(&queue->entries)) != NULL) {
         QSIMPLEQ_REMOVE_HEAD(&queue->entries, co_queue_next);
-        QSIMPLEQ_INSERT_TAIL(&self->co_queue_wakeup, next, co_queue_next);
-        trace_qemu_co_queue_next(next);
+        aio_co_wake(next);
         if (single) {
             break;
         }
diff --git a/util/trace-events b/util/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/util/trace-events
+++ b/util/trace-events
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_terminate(void *co) "self %p"
 
 # util/qemu-coroutine-lock.c
 qemu_co_queue_run_restart(void *co) "co %p"
-qemu_co_queue_next(void *nxt) "next %p"
 qemu_co_mutex_lock_entry(void *mutex, void *self) "mutex %p self %p"
 qemu_co_mutex_lock_return(void *mutex, void *self) "mutex %p self %p"
 qemu_co_mutex_unlock_entry(void *mutex, void *self) "mutex %p self %p"
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Keep the coroutine on the same AioContext.  Without this change,
there would be a race between yielding the coroutine and reentering it.
While the race cannot happen now, because the code only runs from a single
AioContext, this will change with multiqueue support in the block layer.

While doing the change, replace custom bottom half with aio_co_schedule.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 20170213135235.12274-10-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/blkdebug.c | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/block/blkdebug.c b/block/blkdebug.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blkdebug.c
+++ b/block/blkdebug.c
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static void error_callback_bh(void *opaque)
-{
-    Coroutine *co = opaque;
-    qemu_coroutine_enter(co);
-}
-
 static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)
 {
     BDRVBlkdebugState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int inject_error(BlockDriverState *bs, BlkdebugRule *rule)
     }
 
     if (!immediately) {
-        aio_bh_schedule_oneshot(bdrv_get_aio_context(bs), error_callback_bh,
-                                qemu_coroutine_self());
+        aio_co_schedule(qemu_get_current_aio_context(), qemu_coroutine_self());
         qemu_coroutine_yield();
     }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

qed_aio_start_io and qed_aio_next_io will not have to acquire/release
the AioContext, while qed_aio_next_io_cb will.  Split the functionality
and gain a little type-safety in the process.

diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static CachedL2Table *qed_new_l2_table(BDRVQEDState *s)
     return l2_table;
 }
 
-static void qed_aio_next_io(void *opaque, int ret);
+static void qed_aio_next_io(QEDAIOCB *acb, int ret);
+
+static void qed_aio_start_io(QEDAIOCB *acb)
+{
+    qed_aio_next_io(acb, 0);
+}
+
+static void qed_aio_next_io_cb(void *opaque, int ret)
+{
+    QEDAIOCB *acb = opaque;
+
+    qed_aio_next_io(acb, ret);
+}
 
 static void qed_plug_allocating_write_reqs(BDRVQEDState *s)
 {
@@ -XXX,XX +XXX,XX @@ static void qed_unplug_allocating_write_reqs(BDRVQEDState *s)
 
     acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
     if (acb) {
-        qed_aio_next_io(acb, 0);
+        qed_aio_start_io(acb);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete(QEDAIOCB *acb, int ret)
         QSIMPLEQ_REMOVE_HEAD(&s->allocating_write_reqs, next);
         acb = QSIMPLEQ_FIRST(&s->allocating_write_reqs);
         if (acb) {
-            qed_aio_next_io(acb, 0);
+            qed_aio_start_io(acb);
         } else if (s->header.features & QED_F_NEED_CHECK) {
             qed_start_need_check_timer(s);
         }
@@ -XXX,XX +XXX,XX @@ static void qed_commit_l2_update(void *opaque, int ret)
     acb->request.l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset);
     assert(acb->request.l2_table != NULL);
 
-    qed_aio_next_io(opaque, ret);
+    qed_aio_next_io(acb, ret);
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_l2_update(QEDAIOCB *acb, int ret, uint64_t offset)
     if (need_alloc) {
         /* Write out the whole new L2 table */
         qed_write_l2_table(s, &acb->request, 0, s->table_nelems, true,
-                            qed_aio_write_l1_update, acb);
+                           qed_aio_write_l1_update, acb);
     } else {
         /* Write out only the updated part of the L2 table */
         qed_write_l2_table(s, &acb->request, index, acb->cur_nclusters, false,
-                            qed_aio_next_io, acb);
+                           qed_aio_next_io_cb, acb);
     }
     return;
 
@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_main(void *opaque, int ret)
     }
 
     if (acb->find_cluster_ret == QED_CLUSTER_FOUND) {
-        next_fn = qed_aio_next_io;
+        next_fn = qed_aio_next_io_cb;
     } else {
         if (s->bs->backing) {
             next_fn = qed_aio_write_flush_before_l2_update;
@@ -XXX,XX +XXX,XX @@ static void qed_aio_write_alloc(QEDAIOCB *acb, size_t len)
     if (acb->flags & QED_AIOCB_ZERO) {
         /* Skip ahead if the clusters are already zero */
         if (acb->find_cluster_ret == QED_CLUSTER_ZERO) {
-            qed_aio_next_io(acb, 0);
+            qed_aio_start_io(acb);
             return;
         }
 
@@ -XXX,XX +XXX,XX @@ static void qed_aio_read_data(void *opaque, int ret,
     /* Handle zero cluster and backing file reads */
     if (ret == QED_CLUSTER_ZERO) {
         qemu_iovec_memset(&acb->cur_qiov, 0, 0, acb->cur_qiov.size);
-        qed_aio_next_io(acb, 0);
+        qed_aio_start_io(acb);
         return;
     } else if (ret != QED_CLUSTER_FOUND) {
         qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov,
-                              &acb->backing_qiov, qed_aio_next_io, acb);
+                              &acb->backing_qiov, qed_aio_next_io_cb, acb);
         return;
     }
 
     BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
     bdrv_aio_readv(bs->file, offset / BDRV_SECTOR_SIZE,
                    &acb->cur_qiov, acb->cur_qiov.size / BDRV_SECTOR_SIZE,
-                   qed_aio_next_io, acb);
+                   qed_aio_next_io_cb, acb);
     return;
 
 err:
@@ -XXX,XX +XXX,XX @@ err:
 /**
  * Begin next I/O or complete the request
  */
-static void qed_aio_next_io(void *opaque, int ret)
+static void qed_aio_next_io(QEDAIOCB *acb, int ret)
 {
-    QEDAIOCB *acb = opaque;
     BDRVQEDState *s = acb_to_s(acb);
     QEDFindClusterFunc *io_fn = (acb->flags & QED_AIOCB_WRITE) ?
                                 qed_aio_write_data : qed_aio_read_data;
@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *qed_aio_setup(BlockDriverState *bs,
     qemu_iovec_init(&acb->cur_qiov, qiov->niov);
 
     /* Start request */
-    qed_aio_next_io(acb, 0);
+    qed_aio_start_io(acb);
     return &acb->common;
 }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

The AioContext data structures are now protected by list_lock and/or
they are walked with FOREACH_RCU primitives.  There is no need anymore
to acquire the AioContext for the entire duration of aio_dispatch.
Instead, just acquire it before and after invoking the callbacks.
The next step is then to push it further down.

diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
             (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
             aio_node_check(ctx, node->is_external) &&
             node->io_read) {
+            aio_context_acquire(ctx);
             node->io_read(node->opaque);
+            aio_context_release(ctx);
 
             /* aio_notify() does not count as progress */
             if (node->opaque != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
             (revents & (G_IO_OUT | G_IO_ERR)) &&
             aio_node_check(ctx, node->is_external) &&
             node->io_write) {
+            aio_context_acquire(ctx);
             node->io_write(node->opaque);
+            aio_context_release(ctx);
             progress = true;
         }
 
@@ -XXX,XX +XXX,XX @@ bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
     }
 
     /* Run our timers */
+    aio_context_acquire(ctx);
     progress |= timerlistgroup_run_timers(&ctx->tlg);
+    aio_context_release(ctx);
 
     return progress;
 }
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     int64_t timeout;
     int64_t start = 0;
 
-    aio_context_acquire(ctx);
-    progress = false;
-
     /* aio_notify can avoid the expensive event_notifier_set if
      * everything (file descriptors, bottom halves, timers) will
      * be re-evaluated before the next blocking poll().  This is
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         start = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     }
 
-    if (try_poll_mode(ctx, blocking)) {
-        progress = true;
-    } else {
+    aio_context_acquire(ctx);
+    progress = try_poll_mode(ctx, blocking);
+    aio_context_release(ctx);
+
+    if (!progress) {
         assert(npfd == 0);
 
         /* fill pollfds */
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         timeout = blocking ? aio_compute_timeout(ctx) : 0;
 
         /* wait until next event */
-        if (timeout) {
-            aio_context_release(ctx);
-        }
         if (aio_epoll_check_poll(ctx, pollfds, npfd, timeout)) {
             AioHandler epoll_handler;
 
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         } else  {
             ret = qemu_poll_ns(pollfds, npfd, timeout);
         }
-        if (timeout) {
-            aio_context_acquire(ctx);
-        }
     }
 
     if (blocking) {
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         progress = true;
     }
 
-    aio_context_release(ctx);
-
     return progress;
 }
 
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
             (revents || event_notifier_get_handle(node->e) == event) &&
             node->io_notify) {
             node->pfd.revents = 0;
+            aio_context_acquire(ctx);
             node->io_notify(node->e);
+            aio_context_release(ctx);
 
             /* aio_notify() does not count as progress */
             if (node->e != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
             (node->io_read || node->io_write)) {
             node->pfd.revents = 0;
             if ((revents & G_IO_IN) && node->io_read) {
+                aio_context_acquire(ctx);
                 node->io_read(node->opaque);
+                aio_context_release(ctx);
                 progress = true;
             }
             if ((revents & G_IO_OUT) && node->io_write) {
+                aio_context_acquire(ctx);
                 node->io_write(node->opaque);
+                aio_context_release(ctx);
                 progress = true;
             }
 
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     int count;
     int timeout;
 
-    aio_context_acquire(ctx);
     progress = false;
 
     /* aio_notify can avoid the expensive event_notifier_set if
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
 
         timeout = blocking && !have_select_revents
             ? qemu_timeout_ns_to_ms(aio_compute_timeout(ctx)) : 0;
-        if (timeout) {
-            aio_context_release(ctx);
-        }
         ret = WaitForMultipleObjects(count, events, FALSE, timeout);
         if (blocking) {
             assert(first);
             atomic_sub(&ctx->notify_me, 2);
         }
-        if (timeout) {
-            aio_context_acquire(ctx);
-        }
 
         if (first) {
             aio_notify_accept(ctx);
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         progress |= aio_dispatch_handlers(ctx, event);
     } while (count > 0);
 
+    aio_context_acquire(ctx);
     progress |= timerlistgroup_run_timers(&ctx->tlg);
-
     aio_context_release(ctx);
     return progress;
 }
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
                 ret = 1;
             }
             bh->idle = 0;
+            aio_context_acquire(ctx);
             aio_bh_call(bh);
+            aio_context_release(ctx);
         }
         if (bh->deleted) {
             deleted = true;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 20170213135235.12274-13-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qed.h                 |  3 +++
 block/curl.c                |  2 ++
 block/io.c                  |  5 +++++
 block/iscsi.c               |  8 ++++++--
 block/null.c                |  4 ++++
 block/qed.c                 | 12 ++++++++++++
 block/throttle-groups.c     |  2 ++
 util/aio-posix.c            |  2 --
 util/aio-win32.c            |  2 --
 util/qemu-coroutine-sleep.c |  2 +-
 10 files changed, 35 insertions(+), 7 deletions(-)

diff --git a/block/qed.h b/block/qed.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.h
+++ b/block/qed.h
@@ -XXX,XX +XXX,XX @@ enum {
  */
 typedef void QEDFindClusterFunc(void *opaque, int ret, uint64_t offset, size_t len);
 
+void qed_acquire(BDRVQEDState *s);
+void qed_release(BDRVQEDState *s);
+
 /**
  * Generic callback for chaining async callbacks
  */
diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static void curl_multi_timeout_do(void *arg)
         return;
     }
 
+    aio_context_acquire(s->aio_context);
     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
 
     curl_multi_check_completion(s);
+    aio_context_release(s->aio_context);
 #else
     abort();
 #endif
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_aio_cancel(BlockAIOCB *acb)
         if (acb->aiocb_info->get_aio_context) {
             aio_poll(acb->aiocb_info->get_aio_context(acb), true);
         } else if (acb->bs) {
+            /* qemu_aio_ref and qemu_aio_unref are not thread-safe, so
+             * assert that we're not using an I/O thread.  Thread-safe
+             * code should use bdrv_aio_cancel_async exclusively.
+             */
+            assert(bdrv_get_aio_context(acb->bs) == qemu_get_aio_context());
             aio_poll(bdrv_get_aio_context(acb->bs), true);
         } else {
             abort();
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void iscsi_retry_timer_expired(void *opaque)
     struct IscsiTask *iTask = opaque;
     iTask->complete = 1;
     if (iTask->co) {
-        qemu_coroutine_enter(iTask->co);
+        aio_co_wake(iTask->co);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void iscsi_nop_timed_event(void *opaque)
 {
     IscsiLun *iscsilun = opaque;
 
+    aio_context_acquire(iscsilun->aio_context);
     if (iscsi_get_nops_in_flight(iscsilun->iscsi) >= MAX_NOP_FAILURES) {
         error_report("iSCSI: NOP timeout. Reconnecting...");
         iscsilun->request_timed_out = true;
     } else if (iscsi_nop_out_async(iscsilun->iscsi, NULL, NULL, 0, NULL) != 0) {
         error_report("iSCSI: failed to sent NOP-Out. Disabling NOP messages.");
-        return;
+        goto out;
     }
 
     timer_mod(iscsilun->nop_timer, qemu_clock_get_ms(QEMU_CLOCK_REALTIME) + NOP_INTERVAL);
     iscsi_set_events(iscsilun);
+
+out:
+    aio_context_release(iscsilun->aio_context);
 }
 
 static void iscsi_readcapacity_sync(IscsiLun *iscsilun, Error **errp)
diff --git a/block/null.c b/block/null.c
index XXXXXXX..XXXXXXX 100644
--- a/block/null.c
+++ b/block/null.c
@@ -XXX,XX +XXX,XX @@ static void null_bh_cb(void *opaque)
 static void null_timer_cb(void *opaque)
 {
     NullAIOCB *acb = opaque;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
+
+    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, 0);
+    aio_context_release(ctx);
     timer_deinit(&acb->timer);
     qemu_aio_unref(acb);
 }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_need_check_timer_cb(void *opaque)
 
     trace_qed_need_check_timer_cb(s);
 
+    qed_acquire(s);
     qed_plug_allocating_write_reqs(s);
 
     /* Ensure writes are on disk before clearing flag */
     bdrv_aio_flush(s->bs->file->bs, qed_clear_need_check, s);
+    qed_release(s);
+}
+
+void qed_acquire(BDRVQEDState *s)
+{
+    aio_context_acquire(bdrv_get_aio_context(s->bs));
+}
+
+void qed_release(BDRVQEDState *s)
+{
+    aio_context_release(bdrv_get_aio_context(s->bs));
 }
 
 static void qed_start_need_check_timer(BDRVQEDState *s)
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ static void timer_cb(BlockBackend *blk, bool is_write)
     qemu_mutex_unlock(&tg->lock);
 
     /* Run the request that was waiting for this timer */
+    aio_context_acquire(blk_get_aio_context(blk));
     empty_queue = !qemu_co_enter_next(&blkp->throttled_reqs[is_write]);
+    aio_context_release(blk_get_aio_context(blk));
 
     /* If the request queue was empty then we have to take care of
      * scheduling the next one */
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
     }
 
     /* Run our timers */
-    aio_context_acquire(ctx);
     progress |= timerlistgroup_run_timers(&ctx->tlg);
-    aio_context_release(ctx);
 
     return progress;
 }
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         progress |= aio_dispatch_handlers(ctx, event);
     } while (count > 0);
 
-    aio_context_acquire(ctx);
     progress |= timerlistgroup_run_timers(&ctx->tlg);
-    aio_context_release(ctx);
     return progress;
 }
 
diff --git a/util/qemu-coroutine-sleep.c b/util/qemu-coroutine-sleep.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-sleep.c
+++ b/util/qemu-coroutine-sleep.c
@@ -XXX,XX +XXX,XX @@ static void co_sleep_cb(void *opaque)
 {
     CoSleepCB *sleep_cb = opaque;
 
-    qemu_coroutine_enter(sleep_cb->co);
+    aio_co_wake(sleep_cb->co);
 }
 
 void coroutine_fn co_aio_sleep_ns(AioContext *ctx, QEMUClockType type,
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This covers both file descriptor callbacks and polling callbacks,
since they execute related code.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 20170213135235.12274-14-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/curl.c          | 16 +++++++++++++---
 block/iscsi.c         |  4 ++++
 block/linux-aio.c     |  4 ++++
 block/nfs.c           |  6 ++++++
 block/sheepdog.c      | 29 +++++++++++++++--------------
 block/ssh.c           | 29 +++++++++--------------------
 block/win32-aio.c     | 10 ++++++----
 hw/block/virtio-blk.c |  5 ++++-
 hw/scsi/virtio-scsi.c |  6 ++++++
 util/aio-posix.c      |  7 -------
 util/aio-win32.c      |  6 ------
 11 files changed, 67 insertions(+), 55 deletions(-)

diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static void curl_multi_check_completion(BDRVCURLState *s)
     }
 }
 
-static void curl_multi_do(void *arg)
+static void curl_multi_do_locked(CURLState *s)
 {
-    CURLState *s = (CURLState *)arg;
     CURLSocket *socket, *next_socket;
     int running;
     int r;
@@ -XXX,XX +XXX,XX @@ static void curl_multi_do(void *arg)
     }
 }
 
+static void curl_multi_do(void *arg)
+{
+    CURLState *s = (CURLState *)arg;
+
+    aio_context_acquire(s->s->aio_context);
+    curl_multi_do_locked(s);
+    aio_context_release(s->s->aio_context);
+}
+
 static void curl_multi_read(void *arg)
 {
     CURLState *s = (CURLState *)arg;
 
-    curl_multi_do(arg);
+    aio_context_acquire(s->s->aio_context);
+    curl_multi_do_locked(s);
     curl_multi_check_completion(s->s);
+    aio_context_release(s->s->aio_context);
 }
 
 static void curl_multi_timeout_do(void *arg)
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ iscsi_process_read(void *arg)
     IscsiLun *iscsilun = arg;
     struct iscsi_context *iscsi = iscsilun->iscsi;
 
+    aio_context_acquire(iscsilun->aio_context);
     iscsi_service(iscsi, POLLIN);
     iscsi_set_events(iscsilun);
+    aio_context_release(iscsilun->aio_context);
 }
 
 static void
@@ -XXX,XX +XXX,XX @@ iscsi_process_write(void *arg)
     IscsiLun *iscsilun = arg;
     struct iscsi_context *iscsi = iscsilun->iscsi;
 
+    aio_context_acquire(iscsilun->aio_context);
     iscsi_service(iscsi, POLLOUT);
     iscsi_set_events(iscsilun);
+    aio_context_release(iscsilun->aio_context);
 }
 
 static int64_t sector_lun2qemu(int64_t sector, IscsiLun *iscsilun)
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_completion_cb(EventNotifier *e)
     LinuxAioState *s = container_of(e, LinuxAioState, e);
 
     if (event_notifier_test_and_clear(&s->e)) {
+        aio_context_acquire(s->aio_context);
         qemu_laio_process_completions_and_submit(s);
+        aio_context_release(s->aio_context);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
         return false;
     }
 
+    aio_context_acquire(s->aio_context);
     qemu_laio_process_completions_and_submit(s);
+    aio_context_release(s->aio_context);
     return true;
 }
 
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static void nfs_set_events(NFSClient *client)
 static void nfs_process_read(void *arg)
 {
     NFSClient *client = arg;
+
+    aio_context_acquire(client->aio_context);
     nfs_service(client->context, POLLIN);
     nfs_set_events(client);
+    aio_context_release(client->aio_context);
 }
 
 static void nfs_process_write(void *arg)
 {
     NFSClient *client = arg;
+
+    aio_context_acquire(client->aio_context);
     nfs_service(client->context, POLLOUT);
     nfs_set_events(client);
+    aio_context_release(client->aio_context);
 }
 
 static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int send_co_req(int sockfd, SheepdogReq *hdr, void *data,
     return ret;
 }
 
-static void restart_co_req(void *opaque)
-{
-    Coroutine *co = opaque;
-
-    qemu_coroutine_enter(co);
-}
-
 typedef struct SheepdogReqCo {
     int sockfd;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ typedef struct SheepdogReqCo {
     unsigned int *rlen;
     int ret;
     bool finished;
+    Coroutine *co;
 } SheepdogReqCo;
 
+static void restart_co_req(void *opaque)
+{
+    SheepdogReqCo *srco = opaque;
+
+    aio_co_wake(srco->co);
+}
+
 static coroutine_fn void do_co_req(void *opaque)
 {
     int ret;
-    Coroutine *co;
     SheepdogReqCo *srco = opaque;
     int sockfd = srco->sockfd;
     SheepdogReq *hdr = srco->hdr;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void do_co_req(void *opaque)
     unsigned int *wlen = srco->wlen;
     unsigned int *rlen = srco->rlen;
 
-    co = qemu_coroutine_self();
+    srco->co = qemu_coroutine_self();
     aio_set_fd_handler(srco->aio_context, sockfd, false,
-                       NULL, restart_co_req, NULL, co);
+                       NULL, restart_co_req, NULL, srco);
 
     ret = send_co_req(sockfd, hdr, data, wlen);
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void do_co_req(void *opaque)
     }
 
     aio_set_fd_handler(srco->aio_context, sockfd, false,
-                       restart_co_req, NULL, NULL, co);
+                       restart_co_req, NULL, NULL, srco);
 
     ret = qemu_co_recv(sockfd, hdr, sizeof(*hdr));
     if (ret != sizeof(*hdr)) {
@@ -XXX,XX +XXX,XX @@ out:
     aio_set_fd_handler(srco->aio_context, sockfd, false,
                        NULL, NULL, NULL, NULL);
 
+    srco->co = NULL;
     srco->ret = ret;
     srco->finished = true;
     if (srco->bs) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn aio_read_response(void *opaque)
          * We've finished all requests which belong to the AIOCB, so
          * we can switch back to sd_co_readv/writev now.
          */
-        qemu_coroutine_enter(acb->coroutine);
+        aio_co_wake(acb->coroutine);
     }
 
     return;
@@ -XXX,XX +XXX,XX @@ static void co_read_response(void *opaque)
         s->co_recv = qemu_coroutine_create(aio_read_response, opaque);
     }
 
-    qemu_coroutine_enter(s->co_recv);
+    aio_co_wake(s->co_recv);
 }
 
 static void co_write_request(void *opaque)
 {
     BDRVSheepdogState *s = opaque;
 
-    qemu_coroutine_enter(s->co_send);
+    aio_co_wake(s->co_send);
 }
 
 /*
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static void restart_coroutine(void *opaque)
 
     DPRINTF("co=%p", co);
 
-    qemu_coroutine_enter(co);
+    aio_co_wake(co);
 }
 
-static coroutine_fn void set_fd_handler(BDRVSSHState *s, BlockDriverState *bs)
+/* A non-blocking call returned EAGAIN, so yield, ensuring the
+ * handlers are set up so that we'll be rescheduled when there is an
+ * interesting event on the socket.
+ */
+static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
 {
     int r;
     IOHandler *rd_handler = NULL, *wr_handler = NULL;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void set_fd_handler(BDRVSSHState *s, BlockDriverState *bs)
 
     aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
                        false, rd_handler, wr_handler, NULL, co);
-}
-
-static coroutine_fn void clear_fd_handler(BDRVSSHState *s,
-                                          BlockDriverState *bs)
-{
-    DPRINTF("s->sock=%d", s->sock);
-    aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
-                       false, NULL, NULL, NULL, NULL);
-}
-
-/* A non-blocking call returned EAGAIN, so yield, ensuring the
- * handlers are set up so that we'll be rescheduled when there is an
- * interesting event on the socket.
- */
-static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
-{
-    set_fd_handler(s, bs);
     qemu_coroutine_yield();
-    clear_fd_handler(s, bs);
+    DPRINTF("s->sock=%d - back", s->sock);
+    aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock, false,
+                       NULL, NULL, NULL, NULL);
 }
 
 /* SFTP has a function `libssh2_sftp_seek64' which seeks to a position
diff --git a/block/win32-aio.c b/block/win32-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/win32-aio.c
+++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ struct QEMUWin32AIOState {
     HANDLE hIOCP;
     EventNotifier e;
     int count;
-    bool is_aio_context_attached;
+    AioContext *aio_ctx;
 };
 
 typedef struct QEMUWin32AIOCB {
@@ -XXX,XX +XXX,XX @@ static void win32_aio_process_completion(QEMUWin32AIOState *s,
     }
 
 
+    aio_context_acquire(s->aio_ctx);
     waiocb->common.cb(waiocb->common.opaque, ret);
+    aio_context_release(s->aio_ctx);
     qemu_aio_unref(waiocb);
 }
 
@@ -XXX,XX +XXX,XX @@ void win32_aio_detach_aio_context(QEMUWin32AIOState *aio,
                                   AioContext *old_context)
 {
     aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL);
-    aio->is_aio_context_attached = false;
+    aio->aio_ctx = NULL;
 }
 
 void win32_aio_attach_aio_context(QEMUWin32AIOState *aio,
                                   AioContext *new_context)
 {
-    aio->is_aio_context_attached = true;
+    aio->aio_ctx = new_context;
     aio_set_event_notifier(new_context, &aio->e, false,
                            win32_aio_completion_cb, NULL);
 }
@@ -XXX,XX +XXX,XX @@ out_free_state:
 
 void win32_aio_cleanup(QEMUWin32AIOState *aio)
 {
-    assert(!aio->is_aio_context_attached);
+    assert(!aio->aio_ctx);
     CloseHandle(aio->hIOCP);
     event_notifier_cleanup(&aio->e);
     g_free(aio);
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_ioctl_complete(void *opaque, int status)
 {
     VirtIOBlockIoctlReq *ioctl_req = opaque;
     VirtIOBlockReq *req = ioctl_req->req;
-    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
     struct virtio_scsi_inhdr *scsi;
     struct sg_io_hdr *hdr;
 
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
     VirtIOBlockReq *req;
     MultiReqBuffer mrb = {};
 
+    aio_context_acquire(blk_get_aio_context(s->blk));
     blk_io_plug(s->blk);
 
     do {
@@ -XXX,XX +XXX,XX @@ void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
     }
 
     blk_io_unplug(s->blk);
+    aio_context_release(blk_get_aio_context(s->blk));
 }
 
 static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi.c
+++ b/hw/scsi/virtio-scsi.c
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_ctrl_vq(VirtIOSCSI *s, VirtQueue *vq)
 {
     VirtIOSCSIReq *req;
 
+    virtio_scsi_acquire(s);
     while ((req = virtio_scsi_pop_req(s, vq))) {
         virtio_scsi_handle_ctrl_req(s, req);
     }
+    virtio_scsi_release(s);
 }
 
 static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
 
     QTAILQ_HEAD(, VirtIOSCSIReq) reqs = QTAILQ_HEAD_INITIALIZER(reqs);
 
+    virtio_scsi_acquire(s);
     do {
         virtio_queue_set_notification(vq, 0);
 
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_handle_cmd_vq(VirtIOSCSI *s, VirtQueue *vq)
     QTAILQ_FOREACH_SAFE(req, &reqs, next, next) {
         virtio_scsi_handle_cmd_req_submit(s, req);
     }
+    virtio_scsi_release(s);
 }
 
 static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
@@ -XXX,XX +XXX,XX @@ out:
 
 void virtio_scsi_handle_event_vq(VirtIOSCSI *s, VirtQueue *vq)
 {
+    virtio_scsi_acquire(s);
     if (s->events_dropped) {
         virtio_scsi_push_event(s, NULL, VIRTIO_SCSI_T_NO_EVENT, 0);
     }
+    virtio_scsi_release(s);
 }
 
 static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
             (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
             aio_node_check(ctx, node->is_external) &&
             node->io_read) {
-            aio_context_acquire(ctx);
             node->io_read(node->opaque);
-            aio_context_release(ctx);
 
             /* aio_notify() does not count as progress */
             if (node->opaque != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
             (revents & (G_IO_OUT | G_IO_ERR)) &&
             aio_node_check(ctx, node->is_external) &&
             node->io_write) {
-            aio_context_acquire(ctx);
             node->io_write(node->opaque);
-            aio_context_release(ctx);
             progress = true;
         }
 
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         start = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     }
 
-    aio_context_acquire(ctx);
     progress = try_poll_mode(ctx, blocking);
-    aio_context_release(ctx);
-
     if (!progress) {
         assert(npfd == 0);
 
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
             (revents || event_notifier_get_handle(node->e) == event) &&
             node->io_notify) {
             node->pfd.revents = 0;
-            aio_context_acquire(ctx);
             node->io_notify(node->e);
-            aio_context_release(ctx);
 
             /* aio_notify() does not count as progress */
             if (node->e != &ctx->notifier) {
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
             (node->io_read || node->io_write)) {
             node->pfd.revents = 0;
             if ((revents & G_IO_IN) && node->io_read) {
-                aio_context_acquire(ctx);
                 node->io_read(node->opaque);
-                aio_context_release(ctx);
                 progress = true;
             }
             if ((revents & G_IO_OUT) && node->io_write) {
-                aio_context_acquire(ctx);
                 node->io_write(node->opaque);
-                aio_context_release(ctx);
                 progress = true;
             }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 20170213135235.12274-15-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/archipelago.c   |  3 +++
 block/blkreplay.c     |  2 +-
 block/block-backend.c |  6 ++++++
 block/curl.c          | 26 ++++++++++++++++++--------
 block/gluster.c       |  9 +--------
 block/io.c            |  6 +++++-
 block/iscsi.c         |  6 +++++-
 block/linux-aio.c     | 15 +++++++++------
 block/nfs.c           |  3 ++-
 block/null.c          |  4 ++++
 block/qed.c           |  3 +++
 block/rbd.c           |  4 ++++
 dma-helpers.c         |  2 ++
 hw/block/virtio-blk.c |  2 ++
 hw/scsi/scsi-bus.c    |  2 ++
 util/async.c          |  4 ++--
 util/thread-pool.c    |  2 ++
 17 files changed, 71 insertions(+), 28 deletions(-)

diff --git a/block/archipelago.c b/block/archipelago.c
index XXXXXXX..XXXXXXX 100644
--- a/block/archipelago.c
+++ b/block/archipelago.c
@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
 {
     AIORequestData *reqdata = (AIORequestData *) opaque;
     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
+    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
 
+    aio_context_acquire(ctx);
     aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
+    aio_context_release(ctx);
     aio_cb->status = 0;
 
     qemu_aio_unref(aio_cb);
diff --git a/block/blkreplay.c b/block/blkreplay.c
index XXXXXXX..XXXXXXX 100755
--- a/block/blkreplay.c
+++ b/block/blkreplay.c
@@ -XXX,XX +XXX,XX @@ static int64_t blkreplay_getlength(BlockDriverState *bs)
 static void blkreplay_bh_cb(void *opaque)
 {
     Request *req = opaque;
-    qemu_coroutine_enter(req->co);
+    aio_co_wake(req->co);
     qemu_bh_delete(req->bh);
     g_free(req);
 }
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
 static void error_callback_bh(void *opaque)
 {
     struct BlockBackendAIOCB *acb = opaque;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 
     bdrv_dec_in_flight(acb->common.bs);
+    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, acb->ret);
+    aio_context_release(ctx);
     qemu_aio_unref(acb);
 }
 
@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete(BlkAioEmAIOCB *acb)
 static void blk_aio_complete_bh(void *opaque)
 {
     BlkAioEmAIOCB *acb = opaque;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 
     assert(acb->has_returned);
+    aio_context_acquire(ctx);
     blk_aio_complete(acb);
+    aio_context_release(ctx);
 }
 
 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
 {
     CURLState *state;
     int running;
+    int ret = -EINPROGRESS;
 
     CURLAIOCB *acb = p;
-    BDRVCURLState *s = acb->common.bs->opaque;
+    BlockDriverState *bs = acb->common.bs;
+    BDRVCURLState *s = bs->opaque;
+    AioContext *ctx = bdrv_get_aio_context(bs);
 
     size_t start = acb->sector_num * BDRV_SECTOR_SIZE;
     size_t end;
 
+    aio_context_acquire(ctx);
+
     // In case we have the requested data already (e.g. read-ahead),
     // we can just call the callback and be done.
     switch (curl_find_buf(s, start, acb->nb_sectors * BDRV_SECTOR_SIZE, acb)) {
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
             qemu_aio_unref(acb);
             // fall through
         case FIND_RET_WAIT:
-            return;
+            goto out;
         default:
             break;
     }
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
     // No cache found, so let's start a new request
     state = curl_init_state(acb->common.bs, s);
     if (!state) {
-        acb->common.cb(acb->common.opaque, -EIO);
-        qemu_aio_unref(acb);
-        return;
+        ret = -EIO;
+        goto out;
     }
 
     acb->start = 0;
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
     state->orig_buf = g_try_malloc(state->buf_len);
     if (state->buf_len && state->orig_buf == NULL) {
         curl_clean_state(state);
-        acb->common.cb(acb->common.opaque, -ENOMEM);
-        qemu_aio_unref(acb);
-        return;
+        ret = -ENOMEM;
+        goto out;
     }
     state->acb[0] = acb;
 
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
 
     /* Tell curl it needs to kick things off */
     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
+
+out:
+    if (ret != -EINPROGRESS) {
+        acb->common.cb(acb->common.opaque, ret);
+        qemu_aio_unref(acb);
+    }
+    aio_context_release(ctx);
 }
 
 static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static struct glfs *qemu_gluster_init(BlockdevOptionsGluster *gconf,
     return qemu_gluster_glfs_init(gconf, errp);
 }
 
-static void qemu_gluster_complete_aio(void *opaque)
-{
-    GlusterAIOCB *acb = (GlusterAIOCB *)opaque;
-
-    qemu_coroutine_enter(acb->coroutine);
-}
-
 /*
  * AIO callback routine called from GlusterFS thread.
  */
@@ -XXX,XX +XXX,XX @@ static void gluster_finish_aiocb(struct glfs_fd *fd, ssize_t ret, void *arg)
         acb->ret = -EIO; /* Partial read/write - fail it */
     }
 
-    aio_bh_schedule_oneshot(acb->aio_context, qemu_gluster_complete_aio, acb);
+    aio_co_schedule(acb->aio_context, acb->coroutine);
 }
 
 static void qemu_gluster_parse_flags(int bdrv_flags, int *open_flags)
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
     bdrv_dec_in_flight(bs);
     bdrv_drained_begin(bs);
     data->done = true;
-    qemu_coroutine_enter(co);
+    aio_co_wake(co);
 }
 
 static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_complete(BlockAIOCBCoroutine *acb)
 static void bdrv_co_em_bh(void *opaque)
 {
     BlockAIOCBCoroutine *acb = opaque;
+    BlockDriverState *bs = acb->common.bs;
+    AioContext *ctx = bdrv_get_aio_context(bs);
 
     assert(!acb->need_bh);
+    aio_context_acquire(ctx);
     bdrv_co_complete(acb);
+    aio_context_release(ctx);
 }
 
 static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine *acb)
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void
 iscsi_bh_cb(void *p)
 {
     IscsiAIOCB *acb = p;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 
     qemu_bh_delete(acb->bh);
 
     g_free(acb->buf);
     acb->buf = NULL;
 
+    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, acb->status);
+    aio_context_release(ctx);
 
     if (acb->task != NULL) {
         scsi_free_scsi_task(acb->task);
@@ -XXX,XX +XXX,XX @@ iscsi_schedule_bh(IscsiAIOCB *acb)
 static void iscsi_co_generic_bh_cb(void *opaque)
 {
     struct IscsiTask *iTask = opaque;
+
     iTask->complete = 1;
-    qemu_coroutine_enter(iTask->co);
+    aio_co_wake(iTask->co);
 }
 
 static void iscsi_retry_timer_expired(void *opaque)
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ struct LinuxAioState {
     io_context_t ctx;
     EventNotifier e;
 
-    /* io queue for submit at batch */
+    /* io queue for submit at batch.  Protected by AioContext lock. */
     LaioQueue io_q;
 
-    /* I/O completion processing */
+    /* I/O completion processing.  Only runs in I/O thread.  */
     QEMUBH *completion_bh;
     int event_idx;
     int event_max;
@@ -XXX,XX +XXX,XX @@ static inline ssize_t io_event_ret(struct io_event *ev)
  */
 static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
 {
+    LinuxAioState *s = laiocb->ctx;
     int ret;
 
     ret = laiocb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
     }
 
     laiocb->ret = ret;
+    aio_context_acquire(s->aio_context);
     if (laiocb->co) {
         /* If the coroutine is already entered it must be in ioq_submit() and
          * will notice laio->ret has been filled in when it eventually runs
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
         laiocb->common.cb(laiocb->common.opaque, ret);
         qemu_aio_unref(laiocb);
     }
+    aio_context_release(s->aio_context);
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completions(LinuxAioState *s)
 static void qemu_laio_process_completions_and_submit(LinuxAioState *s)
 {
     qemu_laio_process_completions(s);
+
+    aio_context_acquire(s->aio_context);
     if (!s->io_q.plugged && !QSIMPLEQ_EMPTY(&s->io_q.pending)) {
         ioq_submit(s);
     }
+    aio_context_release(s->aio_context);
 }
 
 static void qemu_laio_completion_bh(void *opaque)
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_completion_cb(EventNotifier *e)
     LinuxAioState *s = container_of(e, LinuxAioState, e);
 
     if (event_notifier_test_and_clear(&s->e)) {
-        aio_context_acquire(s->aio_context);
         qemu_laio_process_completions_and_submit(s);
-        aio_context_release(s->aio_context);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
         return false;
     }
 
-    aio_context_acquire(s->aio_context);
     qemu_laio_process_completions_and_submit(s);
-    aio_context_release(s->aio_context);
     return true;
 }
 
@@ -XXX,XX +XXX,XX @@ void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
 {
     aio_set_event_notifier(old_context, &s->e, false, NULL, NULL);
     qemu_bh_delete(s->completion_bh);
+    s->aio_context = NULL;
 }
 
 void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static void nfs_co_init_task(BlockDriverState *bs, NFSRPC *task)
 static void nfs_co_generic_bh_cb(void *opaque)
 {
     NFSRPC *task = opaque;
+
     task->complete = 1;
-    qemu_coroutine_enter(task->co);
+    aio_co_wake(task->co);
 }
 
 static void
diff --git a/block/null.c b/block/null.c
index XXXXXXX..XXXXXXX 100644
--- a/block/null.c
+++ b/block/null.c
@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo null_aiocb_info = {
 static void null_bh_cb(void *opaque)
 {
     NullAIOCB *acb = opaque;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
+
+    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, 0);
+    aio_context_release(ctx);
     qemu_aio_unref(acb);
 }
 
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_update_l2_table(BDRVQEDState *s, QEDTable *table, int index,
 static void qed_aio_complete_bh(void *opaque)
 {
     QEDAIOCB *acb = opaque;
+    BDRVQEDState *s = acb_to_s(acb);
     BlockCompletionFunc *cb = acb->common.cb;
     void *user_opaque = acb->common.opaque;
     int ret = acb->bh_ret;
@@ -XXX,XX +XXX,XX @@ static void qed_aio_complete_bh(void *opaque)
     qemu_aio_unref(acb);
 
     /* Invoke callback */
+    qed_acquire(s);
     cb(user_opaque, ret);
+    qed_release(s);
 }
 
 static void qed_aio_complete(QEDAIOCB *acb, int ret)
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ shutdown:
 static void qemu_rbd_complete_aio(RADOSCB *rcb)
 {
     RBDAIOCB *acb = rcb->acb;
+    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
     int64_t r;
 
     r = rcb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_complete_aio(RADOSCB *rcb)
         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
     }
     qemu_vfree(acb->bounce);
+
+    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret));
+    aio_context_release(ctx);
 
     qemu_aio_unref(acb);
 }
diff --git a/dma-helpers.c b/dma-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/dma-helpers.c
+++ b/dma-helpers.c
@@ -XXX,XX +XXX,XX @@ static void dma_blk_cb(void *opaque, int ret)
                                 QEMU_ALIGN_DOWN(dbs->iov.size, dbs->align));
     }
 
+    aio_context_acquire(dbs->ctx);
     dbs->acb = dbs->io_func(dbs->offset, &dbs->iov,
                             dma_blk_cb, dbs, dbs->io_func_opaque);
+    aio_context_release(dbs->ctx);
     assert(dbs->acb);
 }
 
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_dma_restart_bh(void *opaque)
 
     s->rq = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     while (req) {
         VirtIOBlockReq *next = req->next;
         if (virtio_blk_handle_request(req, &mrb)) {
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_dma_restart_bh(void *opaque)
     if (mrb.num_reqs) {
         virtio_blk_submit_multireq(s->blk, &mrb);
     }
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
 }
 
 static void virtio_blk_dma_restart_cb(void *opaque, int running,
diff --git a/hw/scsi/scsi-bus.c b/hw/scsi/scsi-bus.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/scsi-bus.c
+++ b/hw/scsi/scsi-bus.c
@@ -XXX,XX +XXX,XX @@ static void scsi_dma_restart_bh(void *opaque)
     qemu_bh_delete(s->bh);
     s->bh = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.blk));
     QTAILQ_FOREACH_SAFE(req, &s->requests, next, next) {
         scsi_req_ref(req);
         if (req->retry) {
@@ -XXX,XX +XXX,XX @@ static void scsi_dma_restart_bh(void *opaque)
         }
         scsi_req_unref(req);
     }
+    aio_context_release(blk_get_aio_context(s->conf.blk));
 }
 
 void scsi_req_retry(SCSIRequest *req)
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
                 ret = 1;
             }
             bh->idle = 0;
-            aio_context_acquire(ctx);
             aio_bh_call(bh);
-            aio_context_release(ctx);
         }
         if (bh->deleted) {
             deleted = true;
@@ -XXX,XX +XXX,XX @@ static void co_schedule_bh_cb(void *opaque)
         Coroutine *co = QSLIST_FIRST(&straight);
         QSLIST_REMOVE_HEAD(&straight, co_scheduled_next);
         trace_aio_co_schedule_bh_cb(ctx, co);
+        aio_context_acquire(ctx);
         qemu_coroutine_enter(co);
+        aio_context_release(ctx);
     }
 }
 
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ static void thread_pool_completion_bh(void *opaque)
     ThreadPool *pool = opaque;
     ThreadPoolElement *elem, *next;
 
+    aio_context_acquire(pool->ctx);
 restart:
     QLIST_FOREACH_SAFE(elem, &pool->head, all, next) {
         if (elem->state != THREAD_DONE) {
@@ -XXX,XX +XXX,XX @@ restart:
             qemu_aio_unref(elem);
         }
     }
+    aio_context_release(pool->ctx);
 }
 
 static void thread_pool_cancel(BlockAIOCB *acb)
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Daniel P. Berrange <berrange@redhat.com>
Message-id: 20170213135235.12274-16-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/archipelago.c    |  3 ---
 block/block-backend.c  |  7 -------
 block/curl.c           |  2 +-
 block/io.c             |  6 +-----
 block/iscsi.c          |  3 ---
 block/linux-aio.c      |  5 +----
 block/mirror.c         | 12 +++++++++---
 block/null.c           |  8 --------
 block/qed-cluster.c    |  2 ++
 block/qed-table.c      | 12 ++++++++++--
 block/qed.c            |  4 ++--
 block/rbd.c            |  4 ----
 block/win32-aio.c      |  3 ---
 hw/block/virtio-blk.c  | 12 +++++++++++-
 hw/scsi/scsi-disk.c    | 15 +++++++++++++++
 hw/scsi/scsi-generic.c | 20 +++++++++++++++++---
 util/thread-pool.c     |  4 +++-
 17 files changed, 72 insertions(+), 50 deletions(-)

diff --git a/block/archipelago.c b/block/archipelago.c
index XXXXXXX..XXXXXXX 100644
--- a/block/archipelago.c
+++ b/block/archipelago.c
@@ -XXX,XX +XXX,XX @@ static void qemu_archipelago_complete_aio(void *opaque)
 {
     AIORequestData *reqdata = (AIORequestData *) opaque;
     ArchipelagoAIOCB *aio_cb = (ArchipelagoAIOCB *) reqdata->aio_cb;
-    AioContext *ctx = bdrv_get_aio_context(aio_cb->common.bs);
 
-    aio_context_acquire(ctx);
     aio_cb->common.cb(aio_cb->common.opaque, aio_cb->ret);
-    aio_context_release(ctx);
     aio_cb->status = 0;
 
     qemu_aio_unref(aio_cb);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_make_zero(BlockBackend *blk, BdrvRequestFlags flags)
 static void error_callback_bh(void *opaque)
 {
     struct BlockBackendAIOCB *acb = opaque;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 
     bdrv_dec_in_flight(acb->common.bs);
-    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, acb->ret);
-    aio_context_release(ctx);
     qemu_aio_unref(acb);
 }
 
@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete(BlkAioEmAIOCB *acb)
 static void blk_aio_complete_bh(void *opaque)
 {
     BlkAioEmAIOCB *acb = opaque;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-
     assert(acb->has_returned);
-    aio_context_acquire(ctx);
     blk_aio_complete(acb);
-    aio_context_release(ctx);
 }
 
 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static void curl_readv_bh_cb(void *p)
     curl_multi_socket_action(s->multi, CURL_SOCKET_TIMEOUT, 0, &running);
 
 out:
+    aio_context_release(ctx);
     if (ret != -EINPROGRESS) {
         acb->common.cb(acb->common.opaque, ret);
         qemu_aio_unref(acb);
     }
-    aio_context_release(ctx);
 }
 
 static BlockAIOCB *curl_aio_readv(BlockDriverState *bs,
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_io_em_complete(void *opaque, int ret)
     CoroutineIOCompletion *co = opaque;
 
     co->ret = ret;
-    qemu_coroutine_enter(co->coroutine);
+    aio_co_wake(co->coroutine);
 }
 
 static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_complete(BlockAIOCBCoroutine *acb)
 static void bdrv_co_em_bh(void *opaque)
 {
     BlockAIOCBCoroutine *acb = opaque;
-    BlockDriverState *bs = acb->common.bs;
-    AioContext *ctx = bdrv_get_aio_context(bs);
 
     assert(!acb->need_bh);
-    aio_context_acquire(ctx);
     bdrv_co_complete(acb);
-    aio_context_release(ctx);
 }
 
 static void bdrv_co_maybe_schedule_bh(BlockAIOCBCoroutine *acb)
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static void
 iscsi_bh_cb(void *p)
 {
     IscsiAIOCB *acb = p;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
 
     qemu_bh_delete(acb->bh);
 
     g_free(acb->buf);
     acb->buf = NULL;
 
-    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, acb->status);
-    aio_context_release(ctx);
 
     if (acb->task != NULL) {
         scsi_free_scsi_task(acb->task);
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ static inline ssize_t io_event_ret(struct io_event *ev)
  */
 static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
 {
-    LinuxAioState *s = laiocb->ctx;
     int ret;
 
     ret = laiocb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
     }
 
     laiocb->ret = ret;
-    aio_context_acquire(s->aio_context);
     if (laiocb->co) {
         /* If the coroutine is already entered it must be in ioq_submit() and
          * will notice laio->ret has been filled in when it eventually runs
@@ -XXX,XX +XXX,XX @@ static void qemu_laio_process_completion(struct qemu_laiocb *laiocb)
          * that!
          */
         if (!qemu_coroutine_entered(laiocb->co)) {
-            qemu_coroutine_enter(laiocb->co);
+            aio_co_wake(laiocb->co);
         }
     } else {
         laiocb->common.cb(laiocb->common.opaque, ret);
         qemu_aio_unref(laiocb);
     }
-    aio_context_release(s->aio_context);
 }
 
 /**
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static void mirror_write_complete(void *opaque, int ret)
 {
     MirrorOp *op = opaque;
     MirrorBlockJob *s = op->s;
+
+    aio_context_acquire(blk_get_aio_context(s->common.blk));
     if (ret < 0) {
         BlockErrorAction action;
 
@@ -XXX,XX +XXX,XX @@ static void mirror_write_complete(void *opaque, int ret)
         }
     }
     mirror_iteration_done(op, ret);
+    aio_context_release(blk_get_aio_context(s->common.blk));
 }
 
 static void mirror_read_complete(void *opaque, int ret)
 {
     MirrorOp *op = opaque;
     MirrorBlockJob *s = op->s;
+
+    aio_context_acquire(blk_get_aio_context(s->common.blk));
     if (ret < 0) {
         BlockErrorAction action;
 
@@ -XXX,XX +XXX,XX @@ static void mirror_read_complete(void *opaque, int ret)
         }
 
         mirror_iteration_done(op, ret);
-        return;
+    } else {
+        blk_aio_pwritev(s->target, op->sector_num * BDRV_SECTOR_SIZE, &op->qiov,
+                        0, mirror_write_complete, op);
     }
-    blk_aio_pwritev(s->target, op->sector_num * BDRV_SECTOR_SIZE, &op->qiov,
-                    0, mirror_write_complete, op);
+    aio_context_release(blk_get_aio_context(s->common.blk));
 }
 
 static inline void mirror_clip_sectors(MirrorBlockJob *s,
diff --git a/block/null.c b/block/null.c
index XXXXXXX..XXXXXXX 100644
--- a/block/null.c
+++ b/block/null.c
@@ -XXX,XX +XXX,XX @@ static const AIOCBInfo null_aiocb_info = {
 static void null_bh_cb(void *opaque)
 {
     NullAIOCB *acb = opaque;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-
-    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, 0);
-    aio_context_release(ctx);
     qemu_aio_unref(acb);
 }
 
 static void null_timer_cb(void *opaque)
 {
     NullAIOCB *acb = opaque;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
-
-    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, 0);
-    aio_context_release(ctx);
     timer_deinit(&acb->timer);
     qemu_aio_unref(acb);
 }
diff --git a/block/qed-cluster.c b/block/qed-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed-cluster.c
+++ b/block/qed-cluster.c
@@ -XXX,XX +XXX,XX @@ static void qed_find_cluster_cb(void *opaque, int ret)
     unsigned int index;
     unsigned int n;
 
+    qed_acquire(s);
     if (ret) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static void qed_find_cluster_cb(void *opaque, int ret)
 
 out:
     find_cluster_cb->cb(find_cluster_cb->opaque, ret, offset, len);
+    qed_release(s);
     g_free(find_cluster_cb);
 }
 
diff --git a/block/qed-table.c b/block/qed-table.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed-table.c
+++ b/block/qed-table.c
@@ -XXX,XX +XXX,XX @@ static void qed_read_table_cb(void *opaque, int ret)
 {
     QEDReadTableCB *read_table_cb = opaque;
     QEDTable *table = read_table_cb->table;
+    BDRVQEDState *s = read_table_cb->s;
     int noffsets = read_table_cb->qiov.size / sizeof(uint64_t);
     int i;
 
@@ -XXX,XX +XXX,XX @@ static void qed_read_table_cb(void *opaque, int ret)
     }
 
     /* Byteswap offsets */
+    qed_acquire(s);
     for (i = 0; i < noffsets; i++) {
         table->offsets[i] = le64_to_cpu(table->offsets[i]);
     }
+    qed_release(s);
 
 out:
     /* Completion */
-    trace_qed_read_table_cb(read_table_cb->s, read_table_cb->table, ret);
+    trace_qed_read_table_cb(s, read_table_cb->table, ret);
     gencb_complete(&read_table_cb->gencb, ret);
 }
 
@@ -XXX,XX +XXX,XX @@ typedef struct {
 static void qed_write_table_cb(void *opaque, int ret)
 {
     QEDWriteTableCB *write_table_cb = opaque;
+    BDRVQEDState *s = write_table_cb->s;
 
-    trace_qed_write_table_cb(write_table_cb->s,
+    trace_qed_write_table_cb(s,
                              write_table_cb->orig_table,
                              write_table_cb->flush,
                              ret);
@@ -XXX,XX +XXX,XX @@ static void qed_write_table_cb(void *opaque, int ret)
     if (write_table_cb->flush) {
         /* We still need to flush first */
         write_table_cb->flush = false;
+        qed_acquire(s);
         bdrv_aio_flush(write_table_cb->s->bs, qed_write_table_cb,
                        write_table_cb);
+        qed_release(s);
         return;
     }
 
@@ -XXX,XX +XXX,XX @@ static void qed_read_l2_table_cb(void *opaque, int ret)
     CachedL2Table *l2_table = request->l2_table;
     uint64_t l2_offset = read_l2_table_cb->l2_offset;
 
+    qed_acquire(s);
     if (ret) {
         /* can't trust loaded L2 table anymore */
         qed_unref_l2_cache_entry(l2_table);
@@ -XXX,XX +XXX,XX @@ static void qed_read_l2_table_cb(void *opaque, int ret)
         request->l2_table = qed_find_l2_cache_entry(&s->l2_cache, l2_offset);
         assert(request->l2_table != NULL);
     }
+    qed_release(s);
 
     gencb_complete(&read_l2_table_cb->gencb, ret);
 }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void qed_is_allocated_cb(void *opaque, int ret, uint64_t offset, size_t l
     }
 
     if (cb->co) {
-        qemu_coroutine_enter(cb->co);
+        aio_co_wake(cb->co);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qed_co_pwrite_zeroes_cb(void *opaque, int ret)
     cb->done = true;
     cb->ret = ret;
     if (cb->co) {
-        qemu_coroutine_enter(cb->co);
+        aio_co_wake(cb->co);
     }
 }
 
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ shutdown:
 static void qemu_rbd_complete_aio(RADOSCB *rcb)
 {
     RBDAIOCB *acb = rcb->acb;
-    AioContext *ctx = bdrv_get_aio_context(acb->common.bs);
     int64_t r;
 
     r = rcb->ret;
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_complete_aio(RADOSCB *rcb)
         qemu_iovec_from_buf(acb->qiov, 0, acb->bounce, acb->qiov->size);
     }
     qemu_vfree(acb->bounce);
-
-    aio_context_acquire(ctx);
     acb->common.cb(acb->common.opaque, (acb->ret > 0 ? 0 : acb->ret));
-    aio_context_release(ctx);
 
     qemu_aio_unref(acb);
 }
diff --git a/block/win32-aio.c b/block/win32-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/win32-aio.c
+++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ static void win32_aio_process_completion(QEMUWin32AIOState *s,
         qemu_vfree(waiocb->buf);
     }
 
-
-    aio_context_acquire(s->aio_ctx);
     waiocb->common.cb(waiocb->common.opaque, ret);
-    aio_context_release(s->aio_ctx);
     qemu_aio_unref(waiocb);
 }
 
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_rw_error(VirtIOBlockReq *req, int error,
 static void virtio_blk_rw_complete(void *opaque, int ret)
 {
     VirtIOBlockReq *next = opaque;
+    VirtIOBlock *s = next->dev;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     while (next) {
         VirtIOBlockReq *req = next;
         next = req->mr_next;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_rw_complete(void *opaque, int ret)
         block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
         virtio_blk_free_request(req);
     }
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
 }
 
 static void virtio_blk_flush_complete(void *opaque, int ret)
 {
     VirtIOBlockReq *req = opaque;
+    VirtIOBlock *s = req->dev;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     if (ret) {
         if (virtio_blk_handle_rw_error(req, -ret, 0)) {
-            return;
+            goto out;
         }
     }
 
     virtio_blk_req_complete(req, VIRTIO_BLK_S_OK);
     block_acct_done(blk_get_stats(req->dev->blk), &req->acct);
     virtio_blk_free_request(req);
+
+out:
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
 }
 
 #ifdef __linux__
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_ioctl_complete(void *opaque, int status)
     virtio_stl_p(vdev, &scsi->data_len, hdr->dxfer_len);
 
 out:
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
     virtio_blk_req_complete(req, status);
     virtio_blk_free_request(req);
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
     g_free(ioctl_req);
 }
 
diff --git a/hw/scsi/scsi-disk.c b/hw/scsi/scsi-disk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/scsi-disk.c
+++ b/hw/scsi/scsi-disk.c
@@ -XXX,XX +XXX,XX @@ static void scsi_aio_complete(void *opaque, int ret)
 
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (scsi_disk_req_check_error(r, ret, true)) {
         goto done;
     }
@@ -XXX,XX +XXX,XX @@ static void scsi_aio_complete(void *opaque, int ret)
     scsi_req_complete(&r->req, GOOD);
 
 done:
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
     scsi_req_unref(&r->req);
 }
 
@@ -XXX,XX +XXX,XX @@ static void scsi_dma_complete(void *opaque, int ret)
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (ret < 0) {
         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
     } else {
         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
     }
     scsi_dma_complete_noio(r, ret);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 static void scsi_read_complete(void * opaque, int ret)
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
 
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (scsi_disk_req_check_error(r, ret, true)) {
         goto done;
     }
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
 
 done:
     scsi_req_unref(&r->req);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 /* Actually issue a read to the block device.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_do_read_cb(void *opaque, int ret)
     assert (r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (ret < 0) {
         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
     } else {
         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
     }
     scsi_do_read(opaque, ret);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 /* Read more data from scsi device into buffer.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
     assert (r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (ret < 0) {
         block_acct_failed(blk_get_stats(s->qdev.conf.blk), &r->acct);
     } else {
         block_acct_done(blk_get_stats(s->qdev.conf.blk), &r->acct);
     }
     scsi_write_complete_noio(r, ret);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 static void scsi_write_data(SCSIRequest *req)
@@ -XXX,XX +XXX,XX @@ static void scsi_unmap_complete(void *opaque, int ret)
 {
     UnmapCBData *data = opaque;
     SCSIDiskReq *r = data->r;
+    SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
 
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     scsi_unmap_complete_noio(data, ret);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 static void scsi_disk_emulate_unmap(SCSIDiskReq *r, uint8_t *inbuf)
@@ -XXX,XX +XXX,XX @@ static void scsi_write_same_complete(void *opaque, int ret)
 
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
+    aio_context_acquire(blk_get_aio_context(s->qdev.conf.blk));
     if (scsi_disk_req_check_error(r, ret, true)) {
         goto done;
     }
@@ -XXX,XX +XXX,XX @@ done:
     scsi_req_unref(&r->req);
     qemu_vfree(data->iov.iov_base);
     g_free(data);
+    aio_context_release(blk_get_aio_context(s->qdev.conf.blk));
 }
 
 static void scsi_disk_emulate_write_same(SCSIDiskReq *r, uint8_t *inbuf)
diff --git a/hw/scsi/scsi-generic.c b/hw/scsi/scsi-generic.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/scsi-generic.c
+++ b/hw/scsi/scsi-generic.c
@@ -XXX,XX +XXX,XX @@ done:
 static void scsi_command_complete(void *opaque, int ret)
 {
     SCSIGenericReq *r = (SCSIGenericReq *)opaque;
+    SCSIDevice *s = r->req.dev;
 
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
+
+    aio_context_acquire(blk_get_aio_context(s->conf.blk));
     scsi_command_complete_noio(r, ret);
+    aio_context_release(blk_get_aio_context(s->conf.blk));
 }
 
 static int execute_command(BlockBackend *blk,
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.blk));
+
     if (ret || r->req.io_canceled) {
         scsi_command_complete_noio(r, ret);
-        return;
+        goto done;
     }
 
     len = r->io_header.dxfer_len - r->io_header.resid;
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
     r->len = -1;
     if (len == 0) {
         scsi_command_complete_noio(r, 0);
-        return;
+        goto done;
     }
 
     /* Snoop READ CAPACITY output to set the blocksize.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_read_complete(void * opaque, int ret)
     }
     scsi_req_data(&r->req, len);
     scsi_req_unref(&r->req);
+
+done:
+    aio_context_release(blk_get_aio_context(s->conf.blk));
 }
 
 /* Read more data from scsi device into buffer.  */
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
     assert(r->req.aiocb != NULL);
     r->req.aiocb = NULL;
 
+    aio_context_acquire(blk_get_aio_context(s->conf.blk));
+
     if (ret || r->req.io_canceled) {
         scsi_command_complete_noio(r, ret);
-        return;
+        goto done;
     }
 
     if (r->req.cmd.buf[0] == MODE_SELECT && r->req.cmd.buf[4] == 12 &&
@@ -XXX,XX +XXX,XX @@ static void scsi_write_complete(void * opaque, int ret)
     }
 
     scsi_command_complete_noio(r, ret);
+
+done:
+    aio_context_release(blk_get_aio_context(s->conf.blk));
 }
 
 /* Write data to a scsi device.  Returns nonzero on failure.
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ restart:
              */
             qemu_bh_schedule(pool->completion_bh);
 
+            aio_context_release(pool->ctx);
             elem->common.cb(elem->common.opaque, elem->ret);
+            aio_context_acquire(pool->ctx);
             qemu_aio_unref(elem);
             goto restart;
         } else {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_co_cb(void *opaque, int ret)
     ThreadPoolCo *co = opaque;
 
     co->ret = ret;
-    qemu_coroutine_enter(co->co);
+    aio_co_wake(co->co);
 }
 
 int coroutine_fn thread_pool_submit_co(ThreadPool *pool, ThreadPoolFunc *func,
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This patch prepares for the removal of unnecessary lockcnt inc/dec pairs.
Extract the dispatching loop for file descriptor handlers into a new
function aio_dispatch_handlers, and then inline aio_dispatch into
aio_poll.

aio_dispatch can now become void.

diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ bool aio_pending(AioContext *ctx);
 /* Dispatch any pending callbacks from the GSource attached to the AioContext.
  *
  * This is used internally in the implementation of the GSource.
- *
- * @dispatch_fds: true to process fds, false to skip them
- *                (can be used as an optimization by callers that know there
- *                are no fds ready)
  */
-bool aio_dispatch(AioContext *ctx, bool dispatch_fds);
+void aio_dispatch(AioContext *ctx);
 
 /* Progress in completing AIO work to occur.  This can issue new pending
  * aio as a result of executing I/O completion or bh callbacks.
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
     AioHandler *node, *tmp;
     bool progress = false;
 
-    /*
-     * We have to walk very carefully in case aio_set_fd_handler is
-     * called while we're walking.
-     */
-    qemu_lockcnt_inc(&ctx->list_lock);
-
     QLIST_FOREACH_SAFE_RCU(node, &ctx->aio_handlers, node, tmp) {
         int revents;
 
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
         }
     }
 
-    qemu_lockcnt_dec(&ctx->list_lock);
     return progress;
 }
 
-/*
- * Note that dispatch_fds == false has the side-effect of post-poning the
- * freeing of deleted handlers.
- */
-bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
+void aio_dispatch(AioContext *ctx)
 {
-    bool progress;
+    aio_bh_poll(ctx);
 
-    /*
-     * If there are callbacks left that have been queued, we need to call them.
-     * Do not call select in this case, because it is possible that the caller
-     * does not need a complete flush (as is the case for aio_poll loops).
-     */
-    progress = aio_bh_poll(ctx);
+    qemu_lockcnt_inc(&ctx->list_lock);
+    aio_dispatch_handlers(ctx);
+    qemu_lockcnt_dec(&ctx->list_lock);
 
-    if (dispatch_fds) {
-        progress |= aio_dispatch_handlers(ctx);
-    }
-
-    /* Run our timers */
-    progress |= timerlistgroup_run_timers(&ctx->tlg);
-
-    return progress;
+    timerlistgroup_run_timers(&ctx->tlg);
 }
 
 /* These thread-local variables are used only in a small part of aio_poll
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     npfd = 0;
     qemu_lockcnt_dec(&ctx->list_lock);
 
-    /* Run dispatch even if there were no readable fds to run timers */
-    if (aio_dispatch(ctx, ret > 0)) {
-        progress = true;
+    progress |= aio_bh_poll(ctx);
+
+    if (ret > 0) {
+        qemu_lockcnt_inc(&ctx->list_lock);
+        progress |= aio_dispatch_handlers(ctx);
+        qemu_lockcnt_dec(&ctx->list_lock);
     }
 
+    progress |= timerlistgroup_run_timers(&ctx->tlg);
+
     return progress;
 }
 
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
     return progress;
 }
 
-bool aio_dispatch(AioContext *ctx, bool dispatch_fds)
+void aio_dispatch(AioContext *ctx)
 {
-    bool progress;
-
-    progress = aio_bh_poll(ctx);
-    if (dispatch_fds) {
-        progress |= aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
-    }
-    progress |= timerlistgroup_run_timers(&ctx->tlg);
-    return progress;
+    aio_bh_poll(ctx);
+    aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
+    timerlistgroup_run_timers(&ctx->tlg);
 }
 
 bool aio_poll(AioContext *ctx, bool blocking)
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_dispatch(GSource     *source,
     AioContext *ctx = (AioContext *) source;
 
     assert(callback == NULL);
-    aio_dispatch(ctx, true);
+    aio_dispatch(ctx);
     return true;
 }
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Pull the increment/decrement pair out of aio_bh_poll and into the
callers.

diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx)
 
 void aio_dispatch(AioContext *ctx)
 {
+    qemu_lockcnt_inc(&ctx->list_lock);
     aio_bh_poll(ctx);
-
-    qemu_lockcnt_inc(&ctx->list_lock);
     aio_dispatch_handlers(ctx);
     qemu_lockcnt_dec(&ctx->list_lock);
 
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     }
 
     npfd = 0;
-    qemu_lockcnt_dec(&ctx->list_lock);
 
     progress |= aio_bh_poll(ctx);
 
     if (ret > 0) {
-        qemu_lockcnt_inc(&ctx->list_lock);
         progress |= aio_dispatch_handlers(ctx);
-        qemu_lockcnt_dec(&ctx->list_lock);
     }
 
+    qemu_lockcnt_dec(&ctx->list_lock);
+
     progress |= timerlistgroup_run_timers(&ctx->tlg);
 
     return progress;
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
     bool progress = false;
     AioHandler *tmp;
 
-    qemu_lockcnt_inc(&ctx->list_lock);
-
     /*
      * We have to walk very carefully in case aio_set_fd_handler is
      * called while we're walking.
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handlers(AioContext *ctx, HANDLE event)
         }
     }
 
-    qemu_lockcnt_dec(&ctx->list_lock);
     return progress;
 }
 
 void aio_dispatch(AioContext *ctx)
 {
+    qemu_lockcnt_inc(&ctx->list_lock);
     aio_bh_poll(ctx);
     aio_dispatch_handlers(ctx, INVALID_HANDLE_VALUE);
+    qemu_lockcnt_dec(&ctx->list_lock);
     timerlistgroup_run_timers(&ctx->tlg);
 }
 
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         }
     }
 
-    qemu_lockcnt_dec(&ctx->list_lock);
     first = true;
 
     /* ctx->notifier is always registered.  */
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
         progress |= aio_dispatch_handlers(ctx, event);
     } while (count > 0);
 
+    qemu_lockcnt_dec(&ctx->list_lock);
+
     progress |= timerlistgroup_run_timers(&ctx->tlg);
     return progress;
 }
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ void aio_bh_call(QEMUBH *bh)
     bh->cb(bh->opaque);
 }
 
-/* Multiple occurrences of aio_bh_poll cannot be called concurrently */
+/* Multiple occurrences of aio_bh_poll cannot be called concurrently.
+ * The count in ctx->list_lock is incremented before the call, and is
+ * not affected by the call.
+ */
 int aio_bh_poll(AioContext *ctx)
 {
     QEMUBH *bh, **bhp, *next;
     int ret;
     bool deleted = false;
 
-    qemu_lockcnt_inc(&ctx->list_lock);
-
     ret = 0;
     for (bh = atomic_rcu_read(&ctx->first_bh); bh; bh = next) {
         next = atomic_rcu_read(&bh->next);
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
 
     /* remove deleted bhs */
     if (!deleted) {
-        qemu_lockcnt_dec(&ctx->list_lock);
         return ret;
     }
 
-    if (qemu_lockcnt_dec_and_lock(&ctx->list_lock)) {
+    if (qemu_lockcnt_dec_if_lock(&ctx->list_lock)) {
         bhp = &ctx->first_bh;
         while (*bhp) {
             bh = *bhp;
@@ -XXX,XX +XXX,XX @@ int aio_bh_poll(AioContext *ctx)
                 bhp = &bh->next;
             }
         }
-        qemu_lockcnt_unlock(&ctx->list_lock);
+        qemu_lockcnt_inc_and_unlock(&ctx->list_lock);
     }
     return ret;
 }
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BdrvChild {
  * copied as well.
  */
 struct BlockDriverState {
-    int64_t total_sectors; /* if we are reading a disk image, give its
-                              size in sectors */
+    /* Protected by big QEMU lock or read-only after opening.  No special
+     * locking needed during I/O...
+     */
     int open_flags; /* flags used to open the file, re-used for re-open */
     bool read_only; /* if true, the media is read only */
     bool encrypted; /* if true, the media is encrypted */
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     bool sg;        /* if true, the device is a /dev/sg* */
     bool probed;    /* if true, format was probed rather than specified */
 
-    int copy_on_read; /* if nonzero, copy read backing sectors into image.
-                         note this is a reference count */
-
-    CoQueue flush_queue;            /* Serializing flush queue */
-    bool active_flush_req;          /* Flush request in flight? */
-    unsigned int write_gen;         /* Current data generation */
-    unsigned int flushed_gen;       /* Flushed write generation */
-
     BlockDriver *drv; /* NULL means no media */
     void *opaque;
 
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     BdrvChild *backing;
     BdrvChild *file;
 
-    /* Callback before write request is processed */
-    NotifierWithReturnList before_write_notifiers;
-
-    /* number of in-flight requests; overall and serialising */
-    unsigned int in_flight;
-    unsigned int serialising_in_flight;
-
-    bool wakeup;
-
-    /* Offset after the highest byte written to */
-    uint64_t wr_highest_offset;
-
     /* I/O Limits */
     BlockLimits bl;
 
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     QTAILQ_ENTRY(BlockDriverState) bs_list;
     /* element of the list of monitor-owned BDS */
     QTAILQ_ENTRY(BlockDriverState) monitor_list;
-    QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
     int refcnt;
 
-    QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
-
     /* operation blockers */
     QLIST_HEAD(, BdrvOpBlocker) op_blockers[BLOCK_OP_TYPE_MAX];
 
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     /* The error object in use for blocking operations on backing_hd */
     Error *backing_blocker;
 
+    /* Protected by AioContext lock */
+
+    /* If true, copy read backing sectors into image.  Can be >1 if more
+     * than one client has requested copy-on-read.
+     */
+    int copy_on_read;
+
+    /* If we are reading a disk image, give its size in sectors.
+     * Generally read-only; it is written to by load_vmstate and save_vmstate,
+     * but the block layer is quiescent during those.
+     */
+    int64_t total_sectors;
+
+    /* Callback before write request is processed */
+    NotifierWithReturnList before_write_notifiers;
+
+    /* number of in-flight requests; overall and serialising */
+    unsigned int in_flight;
+    unsigned int serialising_in_flight;
+
+    bool wakeup;
+
+    /* Offset after the highest byte written to */
+    uint64_t wr_highest_offset;
+
     /* threshold limit for writes, in bytes. "High water mark". */
     uint64_t write_threshold_offset;
     NotifierWithReturn write_threshold_notifier;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     /* counter for nested bdrv_io_plug */
     unsigned io_plugged;
 
+    QLIST_HEAD(, BdrvTrackedRequest) tracked_requests;
+    CoQueue flush_queue;                  /* Serializing flush queue */
+    bool active_flush_req;                /* Flush request in flight? */
+    unsigned int write_gen;               /* Current data generation */
+    unsigned int flushed_gen;             /* Flushed write generation */
+
+    QLIST_HEAD(, BdrvDirtyBitmap) dirty_bitmaps;
+
+    /* do we need to tell the quest if we have a volatile write cache? */
+    int enable_write_cache;
+
     int quiesce_counter;
 };
 
diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend.h
+++ b/include/sysemu/block-backend.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockDevOps {
  * fields that must be public. This is in particular for QLIST_ENTRY() and
  * friends so that BlockBackends can be kept in lists outside block-backend.c */
 typedef struct BlockBackendPublic {
-    /* I/O throttling.
-     * throttle_state tells us if this BlockBackend has I/O limits configured.
-     * io_limits_disabled tells us if they are currently being enforced */
+    /* I/O throttling has its own locking, but also some fields are
+     * protected by the AioContext lock.
+     */
+
+    /* Protected by AioContext lock.  */
     CoQueue      throttled_reqs[2];
+
+    /* Nonzero if the I/O limits are currently being ignored; generally
+     * it is zero.  */
     unsigned int io_limits_disabled;
 
     /* The following fields are protected by the ThrottleGroup lock.
-     * See the ThrottleGroup documentation for details. */
+     * See the ThrottleGroup documentation for details.
+     * throttle_state tells us if I/O limits are configured. */
     ThrottleState *throttle_state;
     ThrottleTimers throttle_timers;
     unsigned       pending_reqs[2];
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This uses the lock-free mutex described in the paper '"Blocking without
Locking", or LFTHREADS: A lock-free thread library' by Gidenstam and
Papatriantafilou.  The same technique is used in OSv, and in fact
the code is essentially a conversion to C of OSv's code.

[Added missing coroutine_fn in tests/test-aio-multithread.c.
--Stefan]

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-2-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h     |  17 ++++-
 tests/test-aio-multithread.c |  86 ++++++++++++++++++++++++
 util/qemu-coroutine-lock.c   | 155 ++++++++++++++++++++++++++++++++++++++++---
 util/trace-events            |   1 +
 4 files changed, 246 insertions(+), 13 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue);
 /**
  * Provides a mutex that can be used to synchronise coroutines
  */
+struct CoWaitRecord;
 typedef struct CoMutex {
-    bool locked;
+    /* Count of pending lockers; 0 for a free mutex, 1 for an
+     * uncontended mutex.
+     */
+    unsigned locked;
+
+    /* A queue of waiters.  Elements are added atomically in front of
+     * from_push.  to_pop is only populated, and popped from, by whoever
+     * is in charge of the next wakeup.  This can be an unlocker or,
+     * through the handoff protocol, a locker that is about to go to sleep.
+     */
+    QSLIST_HEAD(, CoWaitRecord) from_push, to_pop;
+
+    unsigned handoff, sequence;
+
     Coroutine *holder;
-    CoQueue queue;
 } CoMutex;
 
 /**
diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-aio-multithread.c
+++ b/tests/test-aio-multithread.c
@@ -XXX,XX +XXX,XX @@ static void test_multi_co_schedule_10(void)
     test_multi_co_schedule(10);
 }
 
+/* CoMutex thread-safety.  */
+
+static uint32_t atomic_counter;
+static uint32_t running;
+static uint32_t counter;
+static CoMutex comutex;
+
+static void coroutine_fn test_multi_co_mutex_entry(void *opaque)
+{
+    while (!atomic_mb_read(&now_stopping)) {
+        qemu_co_mutex_lock(&comutex);
+        counter++;
+        qemu_co_mutex_unlock(&comutex);
+
+        /* Increase atomic_counter *after* releasing the mutex.  Otherwise
+         * there is a chance (it happens about 1 in 3 runs) that the iothread
+         * exits before the coroutine is woken up, causing a spurious
+         * assertion failure.
+         */
+        atomic_inc(&atomic_counter);
+    }
+    atomic_dec(&running);
+}
+
+static void test_multi_co_mutex(int threads, int seconds)
+{
+    int i;
+
+    qemu_co_mutex_init(&comutex);
+    counter = 0;
+    atomic_counter = 0;
+    now_stopping = false;
+
+    create_aio_contexts();
+    assert(threads <= NUM_CONTEXTS);
+    running = threads;
+    for (i = 0; i < threads; i++) {
+        Coroutine *co1 = qemu_coroutine_create(test_multi_co_mutex_entry, NULL);
+        aio_co_schedule(ctx[i], co1);
+    }
+
+    g_usleep(seconds * 1000000);
+
+    atomic_mb_set(&now_stopping, true);
+    while (running > 0) {
+        g_usleep(100000);
+    }
+
+    join_aio_contexts();
+    g_test_message("%d iterations/second\n", counter / seconds);
+    g_assert_cmpint(counter, ==, atomic_counter);
+}
+
+/* Testing with NUM_CONTEXTS threads focuses on the queue.  The mutex however
+ * is too contended (and the threads spend too much time in aio_poll)
+ * to actually stress the handoff protocol.
+ */
+static void test_multi_co_mutex_1(void)
+{
+    test_multi_co_mutex(NUM_CONTEXTS, 1);
+}
+
+static void test_multi_co_mutex_10(void)
+{
+    test_multi_co_mutex(NUM_CONTEXTS, 10);
+}
+
+/* Testing with fewer threads stresses the handoff protocol too.  Still, the
+ * case where the locker _can_ pick up a handoff is very rare, happening
+ * about 10 times in 1 million, so increase the runtime a bit compared to
+ * other "quick" testcases that only run for 1 second.
+ */
+static void test_multi_co_mutex_2_3(void)
+{
+    test_multi_co_mutex(2, 3);
+}
+
+static void test_multi_co_mutex_2_30(void)
+{
+    test_multi_co_mutex(2, 30);
+}
+
 /* End of tests.  */
 
 int main(int argc, char **argv)
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/aio/multi/lifecycle", test_lifecycle);
     if (g_test_quick()) {
         g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
+        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
+        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
     } else {
         g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
+        g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
+        g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
     }
     return g_test_run();
 }
diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-lock.c
+++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  * THE SOFTWARE.
+ *
+ * The lock-free mutex implementation is based on OSv
+ * (core/lfmutex.cc, include/lockfree/mutex.hh).
+ * Copyright (C) 2013 Cloudius Systems, Ltd.
  */
 
 #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue)
     return QSIMPLEQ_FIRST(&queue->entries) == NULL;
 }
 
+/* The wait records are handled with a multiple-producer, single-consumer
+ * lock-free queue.  There cannot be two concurrent pop_waiter() calls
+ * because pop_waiter() can only be called while mutex->handoff is zero.
+ * This can happen in three cases:
+ * - in qemu_co_mutex_unlock, before the hand-off protocol has started.
+ *   In this case, qemu_co_mutex_lock will see mutex->handoff == 0 and
+ *   not take part in the handoff.
+ * - in qemu_co_mutex_lock, if it steals the hand-off responsibility from
+ *   qemu_co_mutex_unlock.  In this case, qemu_co_mutex_unlock will fail
+ *   the cmpxchg (it will see either 0 or the next sequence value) and
+ *   exit.  The next hand-off cannot begin until qemu_co_mutex_lock has
+ *   woken up someone.
+ * - in qemu_co_mutex_unlock, if it takes the hand-off token itself.
+ *   In this case another iteration starts with mutex->handoff == 0;
+ *   a concurrent qemu_co_mutex_lock will fail the cmpxchg, and
+ *   qemu_co_mutex_unlock will go back to case (1).
+ *
+ * The following functions manage this queue.
+ */
+typedef struct CoWaitRecord {
+    Coroutine *co;
+    QSLIST_ENTRY(CoWaitRecord) next;
+} CoWaitRecord;
+
+static void push_waiter(CoMutex *mutex, CoWaitRecord *w)
+{
+    w->co = qemu_coroutine_self();
+    QSLIST_INSERT_HEAD_ATOMIC(&mutex->from_push, w, next);
+}
+
+static void move_waiters(CoMutex *mutex)
+{
+    QSLIST_HEAD(, CoWaitRecord) reversed;
+    QSLIST_MOVE_ATOMIC(&reversed, &mutex->from_push);
+    while (!QSLIST_EMPTY(&reversed)) {
+        CoWaitRecord *w = QSLIST_FIRST(&reversed);
+        QSLIST_REMOVE_HEAD(&reversed, next);
+        QSLIST_INSERT_HEAD(&mutex->to_pop, w, next);
+    }
+}
+
+static CoWaitRecord *pop_waiter(CoMutex *mutex)
+{
+    CoWaitRecord *w;
+
+    if (QSLIST_EMPTY(&mutex->to_pop)) {
+        move_waiters(mutex);
+        if (QSLIST_EMPTY(&mutex->to_pop)) {
+            return NULL;
+        }
+    }
+    w = QSLIST_FIRST(&mutex->to_pop);
+    QSLIST_REMOVE_HEAD(&mutex->to_pop, next);
+    return w;
+}
+
+static bool has_waiters(CoMutex *mutex)
+{
+    return QSLIST_EMPTY(&mutex->to_pop) || QSLIST_EMPTY(&mutex->from_push);
+}
+
 void qemu_co_mutex_init(CoMutex *mutex)
 {
     memset(mutex, 0, sizeof(*mutex));
-    qemu_co_queue_init(&mutex->queue);
 }
 
-void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
+static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
 {
     Coroutine *self = qemu_coroutine_self();
+    CoWaitRecord w;
+    unsigned old_handoff;
 
     trace_qemu_co_mutex_lock_entry(mutex, self);
+    w.co = self;
+    push_waiter(mutex, &w);
 
-    while (mutex->locked) {
-        qemu_co_queue_wait(&mutex->queue);
+    /* This is the "Responsibility Hand-Off" protocol; a lock() picks from
+     * a concurrent unlock() the responsibility of waking somebody up.
+     */
+    old_handoff = atomic_mb_read(&mutex->handoff);
+    if (old_handoff &&
+        has_waiters(mutex) &&
+        atomic_cmpxchg(&mutex->handoff, old_handoff, 0) == old_handoff) {
+        /* There can be no concurrent pops, because there can be only
+         * one active handoff at a time.
+         */
+        CoWaitRecord *to_wake = pop_waiter(mutex);
+        Coroutine *co = to_wake->co;
+        if (co == self) {
+            /* We got the lock ourselves!  */
+            assert(to_wake == &w);
+            return;
+        }
+
+        aio_co_wake(co);
     }
 
-    mutex->locked = true;
-    mutex->holder = self;
-    self->locks_held++;
-
+    qemu_coroutine_yield();
     trace_qemu_co_mutex_lock_return(mutex, self);
 }
 
+void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
+{
+    Coroutine *self = qemu_coroutine_self();
+
+    if (atomic_fetch_inc(&mutex->locked) == 0) {
+        /* Uncontended.  */
+        trace_qemu_co_mutex_lock_uncontended(mutex, self);
+    } else {
+        qemu_co_mutex_lock_slowpath(mutex);
+    }
+    mutex->holder = self;
+    self->locks_held++;
+}
+
 void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
 {
     Coroutine *self = qemu_coroutine_self();
 
     trace_qemu_co_mutex_unlock_entry(mutex, self);
 
-    assert(mutex->locked == true);
+    assert(mutex->locked);
     assert(mutex->holder == self);
     assert(qemu_in_coroutine());
 
-    mutex->locked = false;
     mutex->holder = NULL;
     self->locks_held--;
-    qemu_co_queue_next(&mutex->queue);
+    if (atomic_fetch_dec(&mutex->locked) == 1) {
+        /* No waiting qemu_co_mutex_lock().  Pfew, that was easy!  */
+        return;
+    }
+
+    for (;;) {
+        CoWaitRecord *to_wake = pop_waiter(mutex);
+        unsigned our_handoff;
+
+        if (to_wake) {
+            Coroutine *co = to_wake->co;
+            aio_co_wake(co);
+            break;
+        }
+
+        /* Some concurrent lock() is in progress (we know this because
+         * mutex->locked was >1) but it hasn't yet put itself on the wait
+         * queue.  Pick a sequence number for the handoff protocol (not 0).
+         */
+        if (++mutex->sequence == 0) {
+            mutex->sequence = 1;
+        }
+
+        our_handoff = mutex->sequence;
+        atomic_mb_set(&mutex->handoff, our_handoff);
+        if (!has_waiters(mutex)) {
+            /* The concurrent lock has not added itself yet, so it
+             * will be able to pick our handoff.
+             */
+            break;
+        }
+
+        /* Try to do the handoff protocol ourselves; if somebody else has
+         * already taken it, however, we're done and they're responsible.
+         */
+        if (atomic_cmpxchg(&mutex->handoff, our_handoff, 0) != our_handoff) {
+            break;
+        }
+    }
 
     trace_qemu_co_mutex_unlock_return(mutex, self);
 }
diff --git a/util/trace-events b/util/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/util/trace-events
+++ b/util/trace-events
@@ -XXX,XX +XXX,XX @@ qemu_coroutine_terminate(void *co) "self %p"
 
 # util/qemu-coroutine-lock.c
 qemu_co_queue_run_restart(void *co) "co %p"
+qemu_co_mutex_lock_uncontended(void *mutex, void *self) "mutex %p self %p"
 qemu_co_mutex_lock_entry(void *mutex, void *self) "mutex %p self %p"
 qemu_co_mutex_lock_return(void *mutex, void *self) "mutex %p self %p"
 qemu_co_mutex_unlock_entry(void *mutex, void *self) "mutex %p self %p"
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Running a very small critical section on pthread_mutex_t and CoMutex
shows that pthread_mutex_t is much faster because it doesn't actually
go to sleep.  What happens is that the critical section is shorter
than the latency of entering the kernel and thus FUTEX_WAIT always
fails.  With CoMutex there is no such latency but you still want to
avoid wait and wakeup.  So introduce it artificially.

This only works with one waiters; because CoMutex is fair, it will
always have more waits and wakeups than a pthread_mutex_t.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-3-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h   |  5 +++++
 util/qemu-coroutine-lock.c | 51 ++++++++++++++++++++++++++++++++++++++++------
 util/qemu-coroutine.c      |  2 +-
 3 files changed, 51 insertions(+), 7 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ typedef struct CoMutex {
      */
     unsigned locked;
 
+    /* Context that is holding the lock.  Useful to avoid spinning
+     * when two coroutines on the same AioContext try to get the lock. :)
+     */
+    AioContext *ctx;
+
     /* A queue of waiters.  Elements are added atomically in front of
      * from_push.  to_pop is only populated, and popped from, by whoever
      * is in charge of the next wakeup.  This can be an unlocker or,
diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-lock.c
+++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu-common.h"
 #include "qemu/coroutine.h"
 #include "qemu/coroutine_int.h"
+#include "qemu/processor.h"
 #include "qemu/queue.h"
 #include "block/aio.h"
 #include "trace.h"
@@ -XXX,XX +XXX,XX @@ void qemu_co_mutex_init(CoMutex *mutex)
     memset(mutex, 0, sizeof(*mutex));
 }
 
-static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
+static void coroutine_fn qemu_co_mutex_wake(CoMutex *mutex, Coroutine *co)
+{
+    /* Read co before co->ctx; pairs with smp_wmb() in
+     * qemu_coroutine_enter().
+     */
+    smp_read_barrier_depends();
+    mutex->ctx = co->ctx;
+    aio_co_wake(co);
+}
+
+static void coroutine_fn qemu_co_mutex_lock_slowpath(AioContext *ctx,
+                                                     CoMutex *mutex)
 {
     Coroutine *self = qemu_coroutine_self();
     CoWaitRecord w;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
         if (co == self) {
             /* We got the lock ourselves!  */
             assert(to_wake == &w);
+            mutex->ctx = ctx;
             return;
         }
 
-        aio_co_wake(co);
+        qemu_co_mutex_wake(mutex, co);
     }
 
     qemu_coroutine_yield();
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex)
 
 void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex)
 {
+    AioContext *ctx = qemu_get_current_aio_context();
     Coroutine *self = qemu_coroutine_self();
+    int waiters, i;
 
-    if (atomic_fetch_inc(&mutex->locked) == 0) {
+    /* Running a very small critical section on pthread_mutex_t and CoMutex
+     * shows that pthread_mutex_t is much faster because it doesn't actually
+     * go to sleep.  What happens is that the critical section is shorter
+     * than the latency of entering the kernel and thus FUTEX_WAIT always
+     * fails.  With CoMutex there is no such latency but you still want to
+     * avoid wait and wakeup.  So introduce it artificially.
+     */
+    i = 0;
+retry_fast_path:
+    waiters = atomic_cmpxchg(&mutex->locked, 0, 1);
+    if (waiters != 0) {
+        while (waiters == 1 && ++i < 1000) {
+            if (atomic_read(&mutex->ctx) == ctx) {
+                break;
+            }
+            if (atomic_read(&mutex->locked) == 0) {
+                goto retry_fast_path;
+            }
+            cpu_relax();
+        }
+        waiters = atomic_fetch_inc(&mutex->locked);
+    }
+
+    if (waiters == 0) {
         /* Uncontended.  */
         trace_qemu_co_mutex_lock_uncontended(mutex, self);
+        mutex->ctx = ctx;
     } else {
-        qemu_co_mutex_lock_slowpath(mutex);
+        qemu_co_mutex_lock_slowpath(ctx, mutex);
     }
     mutex->holder = self;
     self->locks_held++;
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
     assert(mutex->holder == self);
     assert(qemu_in_coroutine());
 
+    mutex->ctx = NULL;
     mutex->holder = NULL;
     self->locks_held--;
     if (atomic_fetch_dec(&mutex->locked) == 1) {
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex)
         unsigned our_handoff;
 
         if (to_wake) {
-            Coroutine *co = to_wake->co;
-            aio_co_wake(co);
+            qemu_co_mutex_wake(mutex, to_wake->co);
             break;
         }
 
diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine.c
+++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@ void qemu_coroutine_enter(Coroutine *co)
     co->ctx = qemu_get_current_aio_context();
 
     /* Store co->ctx before anything that stores co.  Matches
-     * barrier in aio_co_wake.
+     * barrier in aio_co_wake and qemu_co_mutex_wake.
      */
     smp_wmb();
 
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

Add two implementations of the same benchmark as the previous patch,
but using pthreads.  One uses a normal QemuMutex, the other is Linux
only and implements a fair mutex based on MCS locks and futexes.
This shows that the slower performance of the 5-thread case is due to
the fairness of CoMutex, rather than to coroutines.  If fairness does
not matter, as is the case with two threads, CoMutex can actually be
faster than pthreads.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-4-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/test-aio-multithread.c | 164 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 164 insertions(+)

diff --git a/tests/test-aio-multithread.c b/tests/test-aio-multithread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-aio-multithread.c
+++ b/tests/test-aio-multithread.c
@@ -XXX,XX +XXX,XX @@ static void test_multi_co_mutex_2_30(void)
     test_multi_co_mutex(2, 30);
 }
 
+/* Same test with fair mutexes, for performance comparison.  */
+
+#ifdef CONFIG_LINUX
+#include "qemu/futex.h"
+
+/* The nodes for the mutex reside in this structure (on which we try to avoid
+ * false sharing).  The head of the mutex is in the "mutex_head" variable.
+ */
+static struct {
+    int next, locked;
+    int padding[14];
+} nodes[NUM_CONTEXTS] __attribute__((__aligned__(64)));
+
+static int mutex_head = -1;
+
+static void mcs_mutex_lock(void)
+{
+    int prev;
+
+    nodes[id].next = -1;
+    nodes[id].locked = 1;
+    prev = atomic_xchg(&mutex_head, id);
+    if (prev != -1) {
+        atomic_set(&nodes[prev].next, id);
+        qemu_futex_wait(&nodes[id].locked, 1);
+    }
+}
+
+static void mcs_mutex_unlock(void)
+{
+    int next;
+    if (nodes[id].next == -1) {
+        if (atomic_read(&mutex_head) == id &&
+            atomic_cmpxchg(&mutex_head, id, -1) == id) {
+            /* Last item in the list, exit.  */
+            return;
+        }
+        while (atomic_read(&nodes[id].next) == -1) {
+            /* mcs_mutex_lock did the xchg, but has not updated
+             * nodes[prev].next yet.
+             */
+        }
+    }
+
+    /* Wake up the next in line.  */
+    next = nodes[id].next;
+    nodes[next].locked = 0;
+    qemu_futex_wake(&nodes[next].locked, 1);
+}
+
+static void test_multi_fair_mutex_entry(void *opaque)
+{
+    while (!atomic_mb_read(&now_stopping)) {
+        mcs_mutex_lock();
+        counter++;
+        mcs_mutex_unlock();
+        atomic_inc(&atomic_counter);
+    }
+    atomic_dec(&running);
+}
+
+static void test_multi_fair_mutex(int threads, int seconds)
+{
+    int i;
+
+    assert(mutex_head == -1);
+    counter = 0;
+    atomic_counter = 0;
+    now_stopping = false;
+
+    create_aio_contexts();
+    assert(threads <= NUM_CONTEXTS);
+    running = threads;
+    for (i = 0; i < threads; i++) {
+        Coroutine *co1 = qemu_coroutine_create(test_multi_fair_mutex_entry, NULL);
+        aio_co_schedule(ctx[i], co1);
+    }
+
+    g_usleep(seconds * 1000000);
+
+    atomic_mb_set(&now_stopping, true);
+    while (running > 0) {
+        g_usleep(100000);
+    }
+
+    join_aio_contexts();
+    g_test_message("%d iterations/second\n", counter / seconds);
+    g_assert_cmpint(counter, ==, atomic_counter);
+}
+
+static void test_multi_fair_mutex_1(void)
+{
+    test_multi_fair_mutex(NUM_CONTEXTS, 1);
+}
+
+static void test_multi_fair_mutex_10(void)
+{
+    test_multi_fair_mutex(NUM_CONTEXTS, 10);
+}
+#endif
+
+/* Same test with pthread mutexes, for performance comparison and
+ * portability.  */
+
+static QemuMutex mutex;
+
+static void test_multi_mutex_entry(void *opaque)
+{
+    while (!atomic_mb_read(&now_stopping)) {
+        qemu_mutex_lock(&mutex);
+        counter++;
+        qemu_mutex_unlock(&mutex);
+        atomic_inc(&atomic_counter);
+    }
+    atomic_dec(&running);
+}
+
+static void test_multi_mutex(int threads, int seconds)
+{
+    int i;
+
+    qemu_mutex_init(&mutex);
+    counter = 0;
+    atomic_counter = 0;
+    now_stopping = false;
+
+    create_aio_contexts();
+    assert(threads <= NUM_CONTEXTS);
+    running = threads;
+    for (i = 0; i < threads; i++) {
+        Coroutine *co1 = qemu_coroutine_create(test_multi_mutex_entry, NULL);
+        aio_co_schedule(ctx[i], co1);
+    }
+
+    g_usleep(seconds * 1000000);
+
+    atomic_mb_set(&now_stopping, true);
+    while (running > 0) {
+        g_usleep(100000);
+    }
+
+    join_aio_contexts();
+    g_test_message("%d iterations/second\n", counter / seconds);
+    g_assert_cmpint(counter, ==, atomic_counter);
+}
+
+static void test_multi_mutex_1(void)
+{
+    test_multi_mutex(NUM_CONTEXTS, 1);
+}
+
+static void test_multi_mutex_10(void)
+{
+    test_multi_mutex(NUM_CONTEXTS, 10);
+}
+
 /* End of tests.  */
 
 int main(int argc, char **argv)
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
         g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_1);
         g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_1);
         g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_3);
+#ifdef CONFIG_LINUX
+        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_1);
+#endif
+        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_1);
     } else {
         g_test_add_func("/aio/multi/schedule", test_multi_co_schedule_10);
         g_test_add_func("/aio/multi/mutex/contended", test_multi_co_mutex_10);
         g_test_add_func("/aio/multi/mutex/handoff", test_multi_co_mutex_2_30);
+#ifdef CONFIG_LINUX
+        g_test_add_func("/aio/multi/mutex/mcs", test_multi_fair_mutex_10);
+#endif
+        g_test_add_func("/aio/multi/mutex/pthread", test_multi_mutex_10);
     }
     return g_test_run();
 }
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This will avoid forward references in the next patch.  It is also
more logical because CoQueue is not anymore the basic primitive.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-5-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h | 89 ++++++++++++++++++++++++------------------------
 1 file changed, 44 insertions(+), 45 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ bool qemu_in_coroutine(void);
  */
 bool qemu_coroutine_entered(Coroutine *co);
 
-
-/**
- * CoQueues are a mechanism to queue coroutines in order to continue executing
- * them later. They provide the fundamental primitives on which coroutine locks
- * are built.
- */
-typedef struct CoQueue {
-    QSIMPLEQ_HEAD(, Coroutine) entries;
-} CoQueue;
-
-/**
- * Initialise a CoQueue. This must be called before any other operation is used
- * on the CoQueue.
- */
-void qemu_co_queue_init(CoQueue *queue);
-
-/**
- * Adds the current coroutine to the CoQueue and transfers control to the
- * caller of the coroutine.
- */
-void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
-
-/**
- * Restarts the next coroutine in the CoQueue and removes it from the queue.
- *
- * Returns true if a coroutine was restarted, false if the queue is empty.
- */
-bool coroutine_fn qemu_co_queue_next(CoQueue *queue);
-
-/**
- * Restarts all coroutines in the CoQueue and leaves the queue empty.
- */
-void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue);
-
-/**
- * Enter the next coroutine in the queue
- */
-bool qemu_co_enter_next(CoQueue *queue);
-
-/**
- * Checks if the CoQueue is empty.
- */
-bool qemu_co_queue_empty(CoQueue *queue);
-
-
 /**
  * Provides a mutex that can be used to synchronise coroutines
  */
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_lock(CoMutex *mutex);
  */
 void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex);
 
+
+/**
+ * CoQueues are a mechanism to queue coroutines in order to continue executing
+ * them later.
+ */
+typedef struct CoQueue {
+    QSIMPLEQ_HEAD(, Coroutine) entries;
+} CoQueue;
+
+/**
+ * Initialise a CoQueue. This must be called before any other operation is used
+ * on the CoQueue.
+ */
+void qemu_co_queue_init(CoQueue *queue);
+
+/**
+ * Adds the current coroutine to the CoQueue and transfers control to the
+ * caller of the coroutine.
+ */
+void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
+
+/**
+ * Restarts the next coroutine in the CoQueue and removes it from the queue.
+ *
+ * Returns true if a coroutine was restarted, false if the queue is empty.
+ */
+bool coroutine_fn qemu_co_queue_next(CoQueue *queue);
+
+/**
+ * Restarts all coroutines in the CoQueue and leaves the queue empty.
+ */
+void coroutine_fn qemu_co_queue_restart_all(CoQueue *queue);
+
+/**
+ * Enter the next coroutine in the queue
+ */
+bool qemu_co_enter_next(CoQueue *queue);
+
+/**
+ * Checks if the CoQueue is empty.
+ */
+bool qemu_co_queue_empty(CoQueue *queue);
+
+
 typedef struct CoRwlock {
     bool writer;
     int reader;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

All that CoQueue needs in order to become thread-safe is help
from an external mutex.  Add this to the API.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-6-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h   |  8 +++++---
 block/backup.c             |  2 +-
 block/io.c                 |  4 ++--
 block/nbd-client.c         |  2 +-
 block/qcow2-cluster.c      |  4 +---
 block/sheepdog.c           |  2 +-
 block/throttle-groups.c    |  2 +-
 hw/9pfs/9p.c               |  2 +-
 util/qemu-coroutine-lock.c | 24 +++++++++++++++++++++---
 9 files changed, 34 insertions(+), 16 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex);
 
 /**
  * CoQueues are a mechanism to queue coroutines in order to continue executing
- * them later.
+ * them later.  They are similar to condition variables, but they need help
+ * from an external mutex in order to maintain thread-safety.
  */
 typedef struct CoQueue {
     QSIMPLEQ_HEAD(, Coroutine) entries;
@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_init(CoQueue *queue);
 
 /**
  * Adds the current coroutine to the CoQueue and transfers control to the
- * caller of the coroutine.
+ * caller of the coroutine.  The mutex is unlocked during the wait and
+ * locked again afterwards.
  */
-void coroutine_fn qemu_co_queue_wait(CoQueue *queue);
+void coroutine_fn qemu_co_queue_wait(CoQueue *queue, CoMutex *mutex);
 
 /**
  * Restarts the next coroutine in the CoQueue and removes it from the queue.
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn wait_for_overlapping_requests(BackupBlockJob *job,
         retry = false;
         QLIST_FOREACH(req, &job->inflight_reqs, list) {
             if (end > req->start && start < req->end) {
-                qemu_co_queue_wait(&req->wait_queue);
+                qemu_co_queue_wait(&req->wait_queue, NULL);
                 retry = true;
                 break;
             }
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static bool coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
                  * (instead of producing a deadlock in the former case). */
                 if (!req->waiting_for) {
                     self->waiting_for = req;
-                    qemu_co_queue_wait(&req->wait_queue);
+                    qemu_co_queue_wait(&req->wait_queue, NULL);
                     self->waiting_for = NULL;
                     retry = true;
                     waited = true;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
 
     /* Wait until any previous flushes are completed */
     while (bs->active_flush_req) {
-        qemu_co_queue_wait(&bs->flush_queue);
+        qemu_co_queue_wait(&bs->flush_queue, NULL);
     }
 
     bs->active_flush_req = true;
diff --git a/block/nbd-client.c b/block/nbd-client.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd-client.c
+++ b/block/nbd-client.c
@@ -XXX,XX +XXX,XX @@ static void nbd_coroutine_start(NBDClientSession *s,
     /* Poor man semaphore.  The free_sema is locked when no other request
      * can be accepted, and unlocked after receiving one reply.  */
     if (s->in_flight == MAX_NBD_REQUESTS) {
-        qemu_co_queue_wait(&s->free_sema);
+        qemu_co_queue_wait(&s->free_sema, NULL);
         assert(s->in_flight < MAX_NBD_REQUESTS);
     }
     s->in_flight++;
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int handle_dependencies(BlockDriverState *bs, uint64_t guest_offset,
             if (bytes == 0) {
                 /* Wait for the dependency to complete. We need to recheck
                  * the free/allocated clusters when we continue. */
-                qemu_co_mutex_unlock(&s->lock);
-                qemu_co_queue_wait(&old_alloc->dependent_requests);
-                qemu_co_mutex_lock(&s->lock);
+                qemu_co_queue_wait(&old_alloc->dependent_requests, &s->lock);
                 return -EAGAIN;
             }
         }
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static void wait_for_overlapping_aiocb(BDRVSheepdogState *s, SheepdogAIOCB *acb)
 retry:
     QLIST_FOREACH(cb, &s->inflight_aiocb_head, aiocb_siblings) {
         if (AIOCBOverlapping(acb, cb)) {
-            qemu_co_queue_wait(&s->overlapping_queue);
+            qemu_co_queue_wait(&s->overlapping_queue, NULL);
             goto retry;
         }
     }
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ void coroutine_fn throttle_group_co_io_limits_intercept(BlockBackend *blk,
     if (must_wait || blkp->pending_reqs[is_write]) {
         blkp->pending_reqs[is_write]++;
         qemu_mutex_unlock(&tg->lock);
-        qemu_co_queue_wait(&blkp->throttled_reqs[is_write]);
+        qemu_co_queue_wait(&blkp->throttled_reqs[is_write], NULL);
         qemu_mutex_lock(&tg->lock);
         blkp->pending_reqs[is_write]--;
     }
diff --git a/hw/9pfs/9p.c b/hw/9pfs/9p.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/9pfs/9p.c
+++ b/hw/9pfs/9p.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn v9fs_flush(void *opaque)
         /*
          * Wait for pdu to complete.
          */
-        qemu_co_queue_wait(&cancel_pdu->complete);
+        qemu_co_queue_wait(&cancel_pdu->complete, NULL);
         cancel_pdu->cancelled = 0;
         pdu_free(cancel_pdu);
     }
diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-lock.c
+++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@ void qemu_co_queue_init(CoQueue *queue)
     QSIMPLEQ_INIT(&queue->entries);
 }
 
-void coroutine_fn qemu_co_queue_wait(CoQueue *queue)
+void coroutine_fn qemu_co_queue_wait(CoQueue *queue, CoMutex *mutex)
 {
     Coroutine *self = qemu_coroutine_self();
     QSIMPLEQ_INSERT_TAIL(&queue->entries, self, co_queue_next);
+
+    if (mutex) {
+        qemu_co_mutex_unlock(mutex);
+    }
+
+    /* There is no race condition here.  Other threads will call
+     * aio_co_schedule on our AioContext, which can reenter this
+     * coroutine but only after this yield and after the main loop
+     * has gone through the next iteration.
+     */
     qemu_coroutine_yield();
     assert(qemu_in_coroutine());
+
+    /* TODO: OSv implements wait morphing here, where the wakeup
+     * primitive automatically places the woken coroutine on the
+     * mutex's queue.  This avoids the thundering herd effect.
+     */
+    if (mutex) {
+        qemu_co_mutex_lock(mutex);
+    }
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_rdlock(CoRwlock *lock)
     Coroutine *self = qemu_coroutine_self();
 
     while (lock->writer) {
-        qemu_co_queue_wait(&lock->queue);
+        qemu_co_queue_wait(&lock->queue, NULL);
     }
     lock->reader++;
     self->locks_held++;
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_wrlock(CoRwlock *lock)
     Coroutine *self = qemu_coroutine_self();
 
     while (lock->writer || lock->reader) {
-        qemu_co_queue_wait(&lock->queue);
+        qemu_co_queue_wait(&lock->queue, NULL);
     }
     lock->writer = true;
     self->locks_held++;
-- 
2.9.3

From: Paolo Bonzini <pbonzini@redhat.com>

This adds a CoMutex around the existing CoQueue.  Because the write-side
can just take CoMutex, the old "writer" field is not necessary anymore.
Instead of removing it altogether, count the number of pending writers
during a read-side critical section and forbid further readers from
entering.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Message-id: 20170213181244.16297-7-pbonzini@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/coroutine.h   |  3 ++-
 util/qemu-coroutine-lock.c | 35 ++++++++++++++++++++++++-----------
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ bool qemu_co_queue_empty(CoQueue *queue);
 
 
 typedef struct CoRwlock {
-    bool writer;
+    int pending_writer;
     int reader;
+    CoMutex mutex;
     CoQueue queue;
 } CoRwlock;
 
diff --git a/util/qemu-coroutine-lock.c b/util/qemu-coroutine-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-lock.c
+++ b/util/qemu-coroutine-lock.c
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_init(CoRwlock *lock)
 {
     memset(lock, 0, sizeof(*lock));
     qemu_co_queue_init(&lock->queue);
+    qemu_co_mutex_init(&lock->mutex);
 }
 
 void qemu_co_rwlock_rdlock(CoRwlock *lock)
 {
     Coroutine *self = qemu_coroutine_self();
 
-    while (lock->writer) {
-        qemu_co_queue_wait(&lock->queue, NULL);
+    qemu_co_mutex_lock(&lock->mutex);
+    /* For fairness, wait if a writer is in line.  */
+    while (lock->pending_writer) {
+        qemu_co_queue_wait(&lock->queue, &lock->mutex);
     }
     lock->reader++;
+    qemu_co_mutex_unlock(&lock->mutex);
+
+    /* The rest of the read-side critical section is run without the mutex.  */
     self->locks_held++;
 }
 
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_unlock(CoRwlock *lock)
     Coroutine *self = qemu_coroutine_self();
 
     assert(qemu_in_coroutine());
-    if (lock->writer) {
-        lock->writer = false;
+    if (!lock->reader) {
+        /* The critical section started in qemu_co_rwlock_wrlock.  */
         qemu_co_queue_restart_all(&lock->queue);
     } else {
+        self->locks_held--;
+
+        qemu_co_mutex_lock(&lock->mutex);
         lock->reader--;
         assert(lock->reader >= 0);
         /* Wakeup only one waiting writer */
@@ -XXX,XX +XXX,XX @@ void qemu_co_rwlock_unlock(CoRwlock *lock)
             qemu_co_queue_next(&lock->queue);
         }
     }
-    self->locks_held--;
+    qemu_co_mutex_unlock(&lock->mutex);
 }
 
 void qemu_co_rwlock_wrlock(CoRwlock *lock)
 {
-    Coroutine *self = qemu_coroutine_self();
-
-    while (lock->writer || lock->reader) {
-        qemu_co_queue_wait(&lock->queue, NULL);
+    qemu_co_mutex_lock(&lock->mutex);
+    lock->pending_writer++;
+    while (lock->reader) {
+        qemu_co_queue_wait(&lock->queue, &lock->mutex);
     }
-    lock->writer = true;
-    self->locks_held++;
+    lock->pending_writer--;
+
+    /* The rest of the write-side critical section is run with
+     * the mutex taken, so that lock->reader remains zero.
+     * There is no need to update self->locks_held.
+     */
 }
-- 
2.9.3

The following changes since commit 928173659d6e5dc368284f73f90ea1d129e1f57d:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200130' into staging (2020-01-30 16:19:04 +0000)

are available in the Git repository at:

https://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 8dff69b9415b4287e900358744b732195e1ab2e2:

tests/qemu-iotests: use AIOMODE with various tests (2020-01-30 21:01:40 +0000)

----------------------------------------------------------------
Pull request

----------------------------------------------------------------

Aarushi Mehta (15):
  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: adds bdrv_parse_aio to use io_uring
  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 for benchmarking
  qemu-nbd: adds option for aio engines
  tests/qemu-iotests: enable testing with aio options
  tests/qemu-iotests: use AIOMODE with various tests

Paolo Bonzini (3):
  block: eliminate BDRV_REQ_NO_SERIALISING
  block/io: wait for serialising requests when a request becomes
    serialising
  block/io: take bs->reqs_lock in bdrv_mark_request_serialising

-- 
2.24.1

From: Paolo Bonzini <pbonzini@redhat.com>

It is unused since commit 00e30f0 ("block/backup: use backup-top instead
of write notifiers", 2019-10-01), drop it to simplify the code.

While at it, drop redundant assertions on flags.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1578495356-46219-2-git-send-email-pbonzini@redhat.com
Message-Id: <1578495356-46219-2-git-send-email-pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c            | 18 ++++--------------
 include/block/block.h | 12 ------------
 2 files changed, 4 insertions(+), 26 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
      * potential fallback support, if we ever implement any read flags
      * to pass through to drivers.  For now, there aren't any
      * passthrough flags.  */
-    assert(!(flags & ~(BDRV_REQ_NO_SERIALISING | BDRV_REQ_COPY_ON_READ |
-                       BDRV_REQ_PREFETCH)));
+    assert(!(flags & ~(BDRV_REQ_COPY_ON_READ | BDRV_REQ_PREFETCH)));
 
     /* Handle Copy on Read and associated serialisation */
     if (flags & BDRV_REQ_COPY_ON_READ) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
         bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
     }
 
-    /* BDRV_REQ_SERIALISING is only for write operation */
-    assert(!(flags & BDRV_REQ_SERIALISING));
-
-    if (!(flags & BDRV_REQ_NO_SERIALISING)) {
-        bdrv_wait_serialising_requests(req);
-    }
+    bdrv_wait_serialising_requests(req);
 
     if (flags & BDRV_REQ_COPY_ON_READ) {
         int64_t pnum;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
     bdrv_inc_in_flight(bs);
 
     /* Don't do copy-on-read if we read data before write operation */
-    if (atomic_read(&bs->copy_on_read) && !(flags & BDRV_REQ_NO_SERIALISING)) {
+    if (atomic_read(&bs->copy_on_read)) {
         flags |= BDRV_REQ_COPY_ON_READ;
     }
 
@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_prepare(BdrvChild *child, int64_t offset, uint64_t bytes,
         return -EPERM;
     }
 
-    /* BDRV_REQ_NO_SERIALISING is only for read operation */
-    assert(!(flags & BDRV_REQ_NO_SERIALISING));
     assert(!(bs->open_flags & BDRV_O_INACTIVE));
     assert((bs->open_flags & BDRV_O_NO_IO) == 0);
     assert(!(flags & ~BDRV_REQ_MASK));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_copy_range_internal(
 
         /* BDRV_REQ_SERIALISING is only for write operation */
         assert(!(read_flags & BDRV_REQ_SERIALISING));
-        if (!(read_flags & BDRV_REQ_NO_SERIALISING)) {
-            bdrv_wait_serialising_requests(&req);
-        }
+        bdrv_wait_serialising_requests(&req);
 
         ret = src->bs->drv->bdrv_co_copy_range_from(src->bs,
                                                     src, src_offset,
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
      */
     BDRV_REQ_MAY_UNMAP          = 0x4,
 
-    /*
-     * The BDRV_REQ_NO_SERIALISING flag is only valid for reads and means that
-     * we don't want wait_serialising_requests() during the read operation.
-     *
-     * This flag is used for backup copy-on-write operations, when we need to
-     * read old data before write (write notifier triggered). It is okay since
-     * we already waited for other serializing requests in the initiating write
-     * (see bdrv_aligned_pwritev), and it is necessary if the initiating write
-     * is already serializing (without the flag, the read would deadlock
-     * waiting for the serialising write to complete).
-     */
-    BDRV_REQ_NO_SERIALISING     = 0x8,
     BDRV_REQ_FUA                = 0x10,
     BDRV_REQ_WRITE_COMPRESSED   = 0x20,
 
-- 
2.24.1

From: Paolo Bonzini <pbonzini@redhat.com>

Marking without waiting would not result in actual serialising behavior.
Thus, make a call bdrv_mark_request_serialising sufficient for
serialisation to happen.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1578495356-46219-3-git-send-email-pbonzini@redhat.com
Message-Id: <1578495356-46219-3-git-send-email-pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c        |  1 -
 block/io.c                | 40 +++++++++++++++++----------------------
 include/block/block_int.h |  3 +--
 3 files changed, 18 insertions(+), 26 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ raw_do_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int bytes,
         req->overlap_bytes = req->bytes;
 
         bdrv_mark_request_serialising(req, bs->bl.request_alignment);
-        bdrv_wait_serialising_requests(req);
     }
 #endif
 
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@
 #define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
 
 static void bdrv_parent_cb_resize(BlockDriverState *bs);
+static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
 static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
     int64_t offset, int bytes, BdrvRequestFlags flags);
 
@@ -XXX,XX +XXX,XX @@ static void tracked_request_begin(BdrvTrackedRequest *req,
     qemu_co_mutex_unlock(&bs->reqs_lock);
 }
 
-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
+bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
 {
     int64_t overlap_offset = req->offset & ~(align - 1);
     uint64_t overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
@@ -XXX,XX +XXX,XX @@ void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
 
     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
-}
-
-static bool is_request_serialising_and_aligned(BdrvTrackedRequest *req)
-{
-    /*
-     * If the request is serialising, overlap_offset and overlap_bytes are set,
-     * so we can check if the request is aligned. Otherwise, don't care and
-     * return false.
-     */
-
-    return req->serialising && (req->offset == req->overlap_offset) &&
-           (req->bytes == req->overlap_bytes);
+    return bdrv_wait_serialising_requests(req);
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ void bdrv_dec_in_flight(BlockDriverState *bs)
     bdrv_wakeup(bs);
 }
 
-bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
+static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
 {
     BlockDriverState *bs = self->bs;
     BdrvTrackedRequest *req;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
          * it ensures that the CoR read and write operations are atomic and
          * guest writes cannot interleave between them. */
         bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+    } else {
+        bdrv_wait_serialising_requests(req);
     }
 
-    bdrv_wait_serialising_requests(req);
-
     if (flags & BDRV_REQ_COPY_ON_READ) {
         int64_t pnum;
 
@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_prepare(BdrvChild *child, int64_t offset, uint64_t bytes,
     assert(!(flags & ~BDRV_REQ_MASK));
 
     if (flags & BDRV_REQ_SERIALISING) {
-        bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+        waited = bdrv_mark_request_serialising(req, bdrv_get_cluster_size(bs));
+        /*
+         * For a misaligned request we should have already waited earlier,
+         * because we come after bdrv_padding_rmw_read which must be called
+         * with the request already marked as serialising.
+         */
+        assert(!waited ||
+               (req->offset == req->overlap_offset &&
+                req->bytes == req->overlap_bytes));
+    } else {
+        bdrv_wait_serialising_requests(req);
     }
 
-    waited = bdrv_wait_serialising_requests(req);
-
-    assert(!waited || !req->serialising ||
-           is_request_serialising_and_aligned(req));
     assert(req->overlap_offset <= offset);
     assert(offset + bytes <= req->overlap_offset + req->overlap_bytes);
     assert(end_sector <= bs->total_sectors || child->perm & BLK_PERM_RESIZE);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
     padding = bdrv_init_padding(bs, offset, bytes, &pad);
     if (padding) {
         bdrv_mark_request_serialising(req, align);
-        bdrv_wait_serialising_requests(req);
 
         bdrv_padding_rmw_read(child, req, &pad, true);
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
 
     if (bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad)) {
         bdrv_mark_request_serialising(&req, align);
-        bdrv_wait_serialising_requests(&req);
         bdrv_padding_rmw_read(child, &req, &pad, false);
     }
 
diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ extern unsigned int bdrv_drain_all_count;
 void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
 void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);
 
-bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
-void bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
+bool coroutine_fn bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align);
 BdrvTrackedRequest *coroutine_fn bdrv_co_get_self_request(BlockDriverState *bs);
 
 int get_tmp_filename(char *filename, int size);
-- 
2.24.1

From: Paolo Bonzini <pbonzini@redhat.com>

bdrv_mark_request_serialising is writing the overlap_offset and
overlap_bytes fields of BdrvTrackedRequest.  Take bs->reqs_lock
for the whole duration of it, and not just when waiting for
serialising requests, so that tracked_request_overlaps does not
look at a half-updated request.

The new code does not unlock/relock around retries.  This is unnecessary
because a retry is always preceded by a CoQueue wait, which already
releases and reacquires bs->reqs_lock.

Reported-by: Peter Lieven <pl@kamp.de>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 1578495356-46219-4-git-send-email-pbonzini@redhat.com
Message-Id: <1578495356-46219-4-git-send-email-pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 112 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 63 insertions(+), 49 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@
 #define MAX_BOUNCE_BUFFER (32768 << BDRV_SECTOR_BITS)
 
 static void bdrv_parent_cb_resize(BlockDriverState *bs);
-static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self);
 static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
     int64_t offset, int bytes, BdrvRequestFlags flags);
 
@@ -XXX,XX +XXX,XX @@ static void tracked_request_begin(BdrvTrackedRequest *req,
     qemu_co_mutex_unlock(&bs->reqs_lock);
 }
 
+static bool tracked_request_overlaps(BdrvTrackedRequest *req,
+                                     int64_t offset, uint64_t bytes)
+{
+    /*        aaaa   bbbb */
+    if (offset >= req->overlap_offset + req->overlap_bytes) {
+        return false;
+    }
+    /* bbbb   aaaa        */
+    if (req->overlap_offset >= offset + bytes) {
+        return false;
+    }
+    return true;
+}
+
+static bool coroutine_fn
+bdrv_wait_serialising_requests_locked(BlockDriverState *bs,
+                                      BdrvTrackedRequest *self)
+{
+    BdrvTrackedRequest *req;
+    bool retry;
+    bool waited = false;
+
+    do {
+        retry = false;
+        QLIST_FOREACH(req, &bs->tracked_requests, list) {
+            if (req == self || (!req->serialising && !self->serialising)) {
+                continue;
+            }
+            if (tracked_request_overlaps(req, self->overlap_offset,
+                                         self->overlap_bytes))
+            {
+                /* Hitting this means there was a reentrant request, for
+                 * example, a block driver issuing nested requests.  This must
+                 * never happen since it means deadlock.
+                 */
+                assert(qemu_coroutine_self() != req->co);
+
+                /* If the request is already (indirectly) waiting for us, or
+                 * will wait for us as soon as it wakes up, then just go on
+                 * (instead of producing a deadlock in the former case). */
+                if (!req->waiting_for) {
+                    self->waiting_for = req;
+                    qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);
+                    self->waiting_for = NULL;
+                    retry = true;
+                    waited = true;
+                    break;
+                }
+            }
+        }
+    } while (retry);
+    return waited;
+}
+
 bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
 {
+    BlockDriverState *bs = req->bs;
     int64_t overlap_offset = req->offset & ~(align - 1);
     uint64_t overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
                                - overlap_offset;
+    bool waited;
 
+    qemu_co_mutex_lock(&bs->reqs_lock);
     if (!req->serialising) {
         atomic_inc(&req->bs->serialising_in_flight);
         req->serialising = true;
@@ -XXX,XX +XXX,XX @@ bool bdrv_mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
 
     req->overlap_offset = MIN(req->overlap_offset, overlap_offset);
     req->overlap_bytes = MAX(req->overlap_bytes, overlap_bytes);
-    return bdrv_wait_serialising_requests(req);
+    waited = bdrv_wait_serialising_requests_locked(bs, req);
+    qemu_co_mutex_unlock(&bs->reqs_lock);
+    return waited;
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ static int bdrv_get_cluster_size(BlockDriverState *bs)
     }
 }
 
-static bool tracked_request_overlaps(BdrvTrackedRequest *req,
-                                     int64_t offset, uint64_t bytes)
-{
-    /*        aaaa   bbbb */
-    if (offset >= req->overlap_offset + req->overlap_bytes) {
-        return false;
-    }
-    /* bbbb   aaaa        */
-    if (req->overlap_offset >= offset + bytes) {
-        return false;
-    }
-    return true;
-}
-
 void bdrv_inc_in_flight(BlockDriverState *bs)
 {
     atomic_inc(&bs->in_flight);
@@ -XXX,XX +XXX,XX @@ void bdrv_dec_in_flight(BlockDriverState *bs)
 static bool coroutine_fn bdrv_wait_serialising_requests(BdrvTrackedRequest *self)
 {
     BlockDriverState *bs = self->bs;
-    BdrvTrackedRequest *req;
-    bool retry;
     bool waited = false;
 
     if (!atomic_read(&bs->serialising_in_flight)) {
         return false;
     }
 
-    do {
-        retry = false;
-        qemu_co_mutex_lock(&bs->reqs_lock);
-        QLIST_FOREACH(req, &bs->tracked_requests, list) {
-            if (req == self || (!req->serialising && !self->serialising)) {
-                continue;
-            }
-            if (tracked_request_overlaps(req, self->overlap_offset,
-                                         self->overlap_bytes))
-            {
-                /* Hitting this means there was a reentrant request, for
-                 * example, a block driver issuing nested requests.  This must
-                 * never happen since it means deadlock.
-                 */
-                assert(qemu_coroutine_self() != req->co);
-
-                /* If the request is already (indirectly) waiting for us, or
-                 * will wait for us as soon as it wakes up, then just go on
-                 * (instead of producing a deadlock in the former case). */
-                if (!req->waiting_for) {
-                    self->waiting_for = req;
-                    qemu_co_queue_wait(&req->wait_queue, &bs->reqs_lock);
-                    self->waiting_for = NULL;
-                    retry = true;
-                    waited = true;
-                    break;
-                }
-            }
-        }
-        qemu_co_mutex_unlock(&bs->reqs_lock);
-    } while (retry);
+    qemu_co_mutex_lock(&bs->reqs_lock);
+    waited = bdrv_wait_serialising_requests_locked(bs, self);
+    qemu_co_mutex_unlock(&bs->reqs_lock);
 
     return waited;
 }
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-2-stefanha@redhat.com
Message-Id: <20200120141858.587874-2-stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 configure | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/configure b/configure
index XXXXXXX..XXXXXXX 100755
--- a/configure
+++ b/configure
@@ -XXX,XX +XXX,XX @@ xen=""
 xen_ctrl_version=""
 xen_pci_passthrough=""
 linux_aio=""
+linux_io_uring=""
 cap_ng=""
 attr=""
 libattr=""
@@ -XXX,XX +XXX,XX @@ 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"
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ 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"
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Since io_uring is the actual name of the Linux API, we use it as enum
value even though the QAPI schema conventions would prefer io-uring.

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-3-stefanha@redhat.com
Message-Id: <20200120141858.587874-3-stefanha@redhat.com>
Signed-off-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 XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # @threads:     Use qemu's thread pool
 # @native:      Use native AIO backend (only Linux and Windows)
+# @io_uring:    Use linux io_uring (since 5.0)
 #
 # Since: 2.9
 ##
 { 'enum': 'BlockdevAioOptions',
-  'data': [ 'threads', 'native' ] }
+  'data': [ 'threads', 'native',
+            { 'name': 'io_uring', 'if': 'defined(CONFIG_LINUX_IO_URING)' } ] }
 
 ##
 # @BlockdevCacheOptions:
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

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

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

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>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-5-stefanha@redhat.com
Message-Id: <20200120141858.587874-5-stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS             |   8 +
 block/Makefile.objs     |   3 +
 block/io_uring.c        | 401 ++++++++++++++++++++++++++++++++++++++++
 include/block/aio.h     |  16 +-
 include/block/raw-aio.h |  12 ++
 5 files changed, 439 insertions(+), 1 deletion(-)
 create mode 100644 block/io_uring.c

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ 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>
+M: Julia Suvorova <jusual@redhat.com>
+M: Stefan Hajnoczi <stefanha@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/Makefile.objs b/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * 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"
+
+/* io_uring ring size */
+#define MAX_ENTRIES 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) submit_queue;
+} 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;
+
+/**
+ * luring_resubmit:
+ *
+ * Resubmit a request by appending it to submit_queue.  The caller must ensure
+ * that ioq_submit() is called later so that submit_queue requests are started.
+ */
+static void luring_resubmit(LuringState *s, LuringAIOCB *luringcb)
+{
+    QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, 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().
+ *
+ * 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 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.submit_queue, 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.submit_queue, 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;
+}
+
+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->submit_queue);
+    io_q->plugged = 0;
+    io_q->in_queue = 0;
+    io_q->in_flight = 0;
+    io_q->blocked = false;
+}
+
+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, IORING_FSYNC_DATASYNC);
+        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.submit_queue, 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_ENTRIES)) {
+        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 = g_new0(LuringState, 1);
+    struct io_uring *ring = &s->ring;
+
+    rc = io_uring_queue_init(MAX_ENTRIES, 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 XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ typedef void IOHandler(void *opaque);
 struct Coroutine;
 struct ThreadPool;
 struct LinuxAioState;
+struct LuringState;
 
 struct AioContext {
     GSource source;
@@ -XXX,XX +XXX,XX @@ 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.
@@ -XXX,XX +XXX,XX @@ 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/raw-aio.h b/include/block/raw-aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/raw-aio.h
+++ b/include/block/raw-aio.h
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Follow linux-aio.o and stub out the block/io_uring.o APIs that will be
missing when a binary is linked with obj-util-y but without
block-util-y (e.g. vhost-user-gpu).

For example, the stubs are necessary so that a binary using util/async.o
from obj-util-y for qemu_bh_new() links successfully.  In this case
block/io_uring.o from block-util-y isn't needed and we can avoid
dragging in the block layer by linking the stubs instead.  The stub
functions never get called.

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ M: Stefan Hajnoczi <stefanha@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 XXXXXXX..XXXXXXX 100644
--- a/stubs/Makefile.objs
+++ b/stubs/Makefile.objs
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX
--- /dev/null
+++ b/stubs/io_uring.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ 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);
 
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static BlockdevDetectZeroesOptions bdrv_parse_detect_zeroes(QemuOpts *opts,
     return detect_zeroes;
 }
 
+/**
+ * Set open flags for aio engine
+ *
+ * Return 0 on success, -1 if the engine specified 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/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ 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;
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ 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,
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ 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,
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Reviewed-by: Maxim Levitsky <maximlevitsky@gmail.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-9-stefanha@redhat.com
Message-Id: <20200120141858.587874-9-stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c | 98 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 79 insertions(+), 19 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ 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;
@@ -XXX,XX +XXX,XX @@ 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",
@@ -XXX,XX +XXX,XX @@ 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);
@@ -XXX,XX +XXX,XX @@ 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"),
@@ -XXX,XX +XXX,XX @@ 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) {
@@ -XXX,XX +XXX,XX @@ 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) {
@@ -XXX,XX +XXX,XX @@ 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)
@@ -XXX,XX +XXX,XX @@ 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 = NULL;
         if (!aio_setup_linux_aio(new_context, &local_err)) {
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@
 #include "block/raw-aio.h"
 #include "qemu/coroutine.h"
 #include "qapi/error.h"
+#include "trace.h"
 
 /* io_uring ring size */
 #define MAX_ENTRIES 128
@@ -XXX,XX +XXX,XX @@ 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;
@@ -XXX,XX +XXX,XX @@ 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;
@@ -XXX,XX +XXX,XX @@ static int ioq_submit(LuringState *s)
             QSIMPLEQ_REMOVE_HEAD(&s->io_q.submit_queue, 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) {
@@ -XXX,XX +XXX,XX @@ static void ioq_init(LuringQueue *io_q)
 
 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);
@@ -XXX,XX +XXX,XX @@ 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) {
@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
 
     QSIMPLEQ_INSERT_TAIL(&s->io_q.submit_queue, 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_ENTRIES)) {
-        return ioq_submit(s);
+        ret = ioq_submit(s);
+        trace_luring_do_submit_done(s, ret);
+        return ret;
     }
     return 0;
 }
@@ -XXX,XX +XXX,XX @@ 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;
     }
@@ -XXX,XX +XXX,XX @@ LuringState *luring_init(Error **errp)
     LuringState *s = g_new0(LuringState, 1);
     struct io_uring *ring = &s->ring;
 
+    trace_luring_init_state(s, sizeof(*s));
+
     rc = io_uring_queue_init(MAX_ENTRIES, ring, 0);
     if (rc < 0) {
         error_setg_errno(errp, errno, "failed to init linux io_uring ring");
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ 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 %d"
+
 # qcow2.c
 qcow2_add_task(void *co, void *bs, void *pool, const char *action, int cluster_type, uint64_t file_cluster_offset, uint64_t offset, uint64_t bytes, void *qiov, size_t qiov_offset) "co %p bs %p pool %p: %s: cluster_type %d file_cluster_offset %" PRIu64 " offset %" PRIu64 " bytes %" PRIu64 " qiov %p qiov_offset %zu"
 qcow2_writev_start_req(void *co, int64_t offset, int bytes) "co %p offset 0x%" PRIx64 " bytes %d"
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@ 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->submit_queue);
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/qemu-io.c b/qemu-io.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io.c
+++ b/qemu-io.c
@@ -XXX,XX +XXX,XX @@ 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"
+" -k, -- use kernel AIO implementation (Linux only, prefer use of -i)\n"
+" -i, -- use AIO mode (threads, native or io_uring)\n"
 " -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"
@@ -XXX,XX +XXX,XX @@ static int open_f(BlockBackend *blk, int argc, char **argv)
     QDict *opts;
     bool force_share = false;
 
-    while ((c = getopt(argc, argv, "snCro:kt:d:U")) != -1) {
+    while ((c = getopt(argc, argv, "snCro:ki:t:d:U")) != -1) {
         switch (c) {
         case 's':
             flags |= BDRV_O_SNAPSHOT;
@@ -XXX,XX +XXX,XX @@ 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");
@@ -XXX,XX +XXX,XX @@ 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"
+"  -k, --native-aio     use kernel AIO implementation\n"
+"                       (Linux only, prefer use of -i)\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"
@@ -XXX,XX +XXX,XX @@ 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:rsnCmki:t:T:U";
     const struct option lopt[] = {
         { "help", no_argument, NULL, 'h' },
         { "version", no_argument, NULL, 'V' },
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
         { "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' },
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
         case 'k':
             flags |= BDRV_O_NATIVE_AIO;
             break;
+        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) {
                 error_report("Invalid cache option: %s", optarg);
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img-cmds.hx
+++ b/qemu-img-cmds.hx
@@ -XXX,XX +XXX,XX @@ STEXI
 ETEXI
 
 DEF("bench", img_bench,
-    "bench [-c count] [-d depth] [-f fmt] [--flush-interval=flush_interval] [-n] [--no-drain] [-o offset] [--pattern=pattern] [-q] [-s buffer_size] [-S step_size] [-t cache] [-w] [-U] filename")
+    "bench [-c count] [-d depth] [-f fmt] [--flush-interval=flush_interval] [-n] [--no-drain] [-o offset] [--pattern=pattern] [-q] [-s buffer_size] [-S step_size] [-t cache] [-i aio] [-w] [-U] filename")
 STEXI
-@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
+@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-i @var{aio}] [-w] [-U] @var{filename}
 ETEXI
 
 DEF("check", img_check,
diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ 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:ni:o:qs:S:t:wU", long_options,
+                        NULL);
         if (c == -1) {
             break;
         }
@@ -XXX,XX +XXX,XX @@ static int img_bench(int argc, char **argv)
         case 'n':
             flags |= BDRV_O_NATIVE_AIO;
             break;
+        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':
         {
             offset = cvtnum(optarg);
diff --git a/qemu-img.texi b/qemu-img.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.texi
+++ b/qemu-img.texi
@@ -XXX,XX +XXX,XX @@ Command description:
 Amends the image format specific @var{options} for the image file
 @var{filename}. Not all file formats support this operation.
 
-@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
+@item bench [-c @var{count}] [-d @var{depth}] [-f @var{fmt}] [--flush-interval=@var{flush_interval}] [-n] [-i @var{aio}] [--no-drain] [-o @var{offset}] [--pattern=@var{pattern}] [-q] [-s @var{buffer_size}] [-S @var{step_size}] [-t @var{cache}] [-w] [-U] @var{filename}
 
 Run a simple sequential I/O benchmark on the specified image. If @code{-w} is
 specified, a write test is performed, otherwise a read test is performed.
@@ -XXX,XX +XXX,XX @@ If @code{-n} is specified, the native AIO backend is used if possible. On
 Linux, this option only works if @code{-t none} or @code{-t directsync} is
 specified as well.
 
+If @code{-i} is specified, aio option can be used to specify different AIO
+backends: @var{threads}, @var{native} or @var{io_uring}.
+
 For write tests, by default a buffer filled with zeros is written. This can be
 overridden with a pattern byte specified by @var{pattern}.
 
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Acked-by: Eric Blake <eblake@redhat.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-14-stefanha@redhat.com
Message-Id: <20200120141858.587874-14-stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 docs/interop/qemu-nbd.rst |  4 ++--
 qemu-nbd.c                | 12 ++++--------
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/docs/interop/qemu-nbd.rst b/docs/interop/qemu-nbd.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qemu-nbd.rst
+++ b/docs/interop/qemu-nbd.rst
@@ -XXX,XX +XXX,XX @@ driver options if ``--image-opts`` is specified.
 
 .. option:: --aio=AIO
 
-  Set the asynchronous I/O mode between ``threads`` (the default)
-  and ``native`` (Linux only).
+  Set the asynchronous I/O mode between ``threads`` (the default),
+  ``native`` (Linux only), and ``io_uring`` (Linux 5.1+).
 
 .. option:: --discard=DISCARD
 
diff --git a/qemu-nbd.c b/qemu-nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -XXX,XX +XXX,XX @@ 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"
@@ -XXX,XX +XXX,XX @@ 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.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ sortme=false
 expunge=true
 have_test_arg=false
 cachemode=false
+aiomode=false
 
 tmp="${TEST_DIR}"/$$
 rm -f $tmp.list $tmp.tmp $tmp.sed
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ s/ .*//p
         CACHEMODE_IS_DEFAULT=false
         cachemode=false
         continue
+    elif $aiomode
+    then
+        AIOMODE="$r"
+        aiomode=false
+        continue
     fi
 
     xpand=true
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ testlist options
             cachemode=true
             xpand=false
             ;;
+        -i)
+            aiomode=true
+            xpand=false
+            ;;
         -T)        # deprecated timestamp option
             xpand=false
             ;;
-
         -v)
             verbose=true
             xpand=false
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _default_cache_mode()
         return
     fi
 }
+_supported_aio_modes()
+{
+    for mode; do
+        if [ "$mode" = "$AIOMODE" ]; then
+            return
+        fi
+    done
+    _notrun "not suitable for aio mode: $AIOMODE"
+}
+_default_aio_mode()
+{
+    AIOMODE="$1"
+    QEMU_IO="$QEMU_IO --aio $1"
+}
 
 _unsupported_imgopts()
 {
diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ test_dir = os.environ.get('TEST_DIR')
 sock_dir = os.environ.get('SOCK_DIR')
 output_dir = os.environ.get('OUTPUT_DIR', '.')
 cachemode = os.environ.get('CACHEMODE')
+aiomode = os.environ.get('AIOMODE')
 qemu_default_machine = os.environ.get('QEMU_DEFAULT_MACHINE')
 
 socket_scm_helper = os.environ.get('SOCKET_SCM_HELPER', 'socket_scm_helper')
@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
             options.append('file=%s' % path)
             options.append('format=%s' % format)
             options.append('cache=%s' % cachemode)
+            options.append('aio=%s' % aiomode)
 
         if opts:
             options.append(opts)
@@ -XXX,XX +XXX,XX @@ def verify_cache_mode(supported_cache_modes=[]):
     if supported_cache_modes and (cachemode not in supported_cache_modes):
         notrun('not suitable for this cache mode: %s' % cachemode)
 
+def verify_aio_mode(supported_aio_modes=[]):
+    if supported_aio_modes and (aiomode not in supported_aio_modes):
+        notrun('not suitable for this aio mode: %s' % aiomode)
+
 def supports_quorum():
     return 'quorum' in qemu_img_pipe('--help')
 
@@ -XXX,XX +XXX,XX @@ def execute_unittest(output, verbosity, debug):
 
 def execute_test(test_function=None,
                  supported_fmts=[], supported_oses=['linux'],
-                 supported_cache_modes=[], unsupported_fmts=[],
-                 supported_protocols=[], unsupported_protocols=[]):
+                 supported_cache_modes=[], supported_aio_modes={},
+                 unsupported_fmts=[], supported_protocols=[],
+                 unsupported_protocols=[]):
     """Run either unittest or script-style tests."""
 
     # We are using TEST_DIR and QEMU_DEFAULT_MACHINE as proxies to
@@ -XXX,XX +XXX,XX @@ def execute_test(test_function=None,
     verify_protocol(supported_protocols, unsupported_protocols)
     verify_platform(supported_oses)
     verify_cache_mode(supported_cache_modes)
+    verify_aio_mode(supported_aio_modes)
 
     if debug:
         output = sys.stdout
-- 
2.24.1

From: Aarushi Mehta <mehta.aaru20@gmail.com>

Signed-off-by: Aarushi Mehta <mehta.aaru20@gmail.com>
Acked-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200120141858.587874-16-stefanha@redhat.com
Message-Id: <20200120141858.587874-16-stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/qemu-iotests/028 |  2 +-
 tests/qemu-iotests/058 |  2 +-
 tests/qemu-iotests/089 |  4 ++--
 tests/qemu-iotests/091 |  4 ++--
 tests/qemu-iotests/109 |  2 +-
 tests/qemu-iotests/147 |  5 +++--
 tests/qemu-iotests/181 |  8 ++++----
 tests/qemu-iotests/183 |  4 ++--
 tests/qemu-iotests/185 | 10 +++++-----
 tests/qemu-iotests/200 |  2 +-
 tests/qemu-iotests/201 |  8 ++++----
 11 files changed, 26 insertions(+), 25 deletions(-)

diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/028
+++ b/tests/qemu-iotests/028
@@ -XXX,XX +XXX,XX @@ echo block-backup
 echo
 
 qemu_comm_method="monitor"
-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk
+_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk
 h=$QEMU_HANDLE
 if [ "${VALGRIND_QEMU}" == "y" ]; then
     QEMU_COMM_TIMEOUT=7
diff --git a/tests/qemu-iotests/058 b/tests/qemu-iotests/058
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/058
+++ b/tests/qemu-iotests/058
@@ -XXX,XX +XXX,XX @@ nbd_snapshot_img="nbd:unix:$nbd_unix_socket"
 converted_image=$TEST_IMG.converted
 
 # Use -f raw instead of -f $IMGFMT for the NBD connection
-QEMU_IO_NBD="$QEMU_IO -f raw --cache=$CACHEMODE"
+QEMU_IO_NBD="$QEMU_IO -f raw --cache=$CACHEMODE --aio=$AIOMODE"
 
 echo
 echo "== preparing image =="
diff --git a/tests/qemu-iotests/089 b/tests/qemu-iotests/089
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/089
+++ b/tests/qemu-iotests/089
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write -P 42 0 512' -c 'write -P 23 512 512' \
 
 $QEMU_IMG convert -f raw -O $IMGFMT "$TEST_IMG.base" "$TEST_IMG"
 
-$QEMU_IO_PROG --cache $CACHEMODE \
+$QEMU_IO_PROG --cache $CACHEMODE --aio $AIOMODE \
          -c 'read -P 42 0 512' -c 'read -P 23 512 512' \
          -c 'read -P 66 1024 512' "json:{
     \"driver\": \"$IMGFMT\",
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write -P 42 0x38000 512' "$TEST_IMG" | _filter_qemu_io
 
 # The "image.filename" part tests whether "a": { "b": "c" } and "a.b": "c" do
 # the same (which they should).
-$QEMU_IO_PROG --cache $CACHEMODE \
+$QEMU_IO_PROG --cache $CACHEMODE --aio $AIOMODE  \
      -c 'read -P 42 0x38000 512' "json:{
     \"driver\": \"$IMGFMT\",
     \"file\": {
diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/091
+++ b/tests/qemu-iotests/091
@@ -XXX,XX +XXX,XX @@ echo === Starting QEMU VM1 ===
 echo
 
 qemu_comm_method="monitor"
-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk
+_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk
 h1=$QEMU_HANDLE
 
 echo
 echo === Starting QEMU VM2 ===
 echo
-_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},id=disk \
+_launch_qemu -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=${AIOMODE},id=disk \
              -incoming "exec: cat '${MIG_FIFO}'"
 h2=$QEMU_HANDLE
 
diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/109
+++ b/tests/qemu-iotests/109
@@ -XXX,XX +XXX,XX @@ run_qemu()
     local qmp_format="$3"
     local qmp_event="$4"
 
-    _launch_qemu -drive file="${source_img}",format=raw,cache=${CACHEMODE},id=src
+    _launch_qemu -drive file="${source_img}",format=raw,cache=${CACHEMODE},aio=${AIOMODE},id=src
     _send_qemu_cmd $QEMU_HANDLE "{ 'execute': 'qmp_capabilities' }" "return"
 
     _send_qemu_cmd $QEMU_HANDLE \
diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/147
+++ b/tests/qemu-iotests/147
@@ -XXX,XX +XXX,XX @@ import socket
 import stat
 import time
 import iotests
-from iotests import cachemode, imgfmt, qemu_img, qemu_nbd, qemu_nbd_early_pipe
+from iotests import cachemode, aiomode, imgfmt, qemu_img, qemu_nbd, qemu_nbd_early_pipe
 
 NBD_PORT_START      = 32768
 NBD_PORT_END        = NBD_PORT_START + 1024
@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):
         self.server.add_drive_raw('if=none,id=nbd-export,' +
                                   'file=%s,' % test_img +
                                   'format=%s,' % imgfmt +
-                                  'cache=%s' % cachemode)
+                                  'cache=%s' % cachemode +
+                                  'aio=%s' % aiomode)
         self.server.launch()
 
     def tearDown(self):
diff --git a/tests/qemu-iotests/181 b/tests/qemu-iotests/181
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/181
+++ b/tests/qemu-iotests/181
@@ -XXX,XX +XXX,XX @@ qemu_comm_method="monitor"
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     _launch_qemu \
-        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
+        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk
 else
     _launch_qemu \
-        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk
 fi
 src=$QEMU_HANDLE
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     _launch_qemu \
-        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
+        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk \
         -incoming "unix:${MIG_SOCKET}"
 else
     _launch_qemu \
-        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk \
         -incoming "unix:${MIG_SOCKET}"
 fi
 dest=$QEMU_HANDLE
diff --git a/tests/qemu-iotests/183 b/tests/qemu-iotests/183
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/183
+++ b/tests/qemu-iotests/183
@@ -XXX,XX +XXX,XX @@ echo
 qemu_comm_method="qmp"
 
 _launch_qemu \
-    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 src=$QEMU_HANDLE
 _send_qemu_cmd $src "{ 'execute': 'qmp_capabilities' }" 'return'
 
 _launch_qemu \
-    -drive file="${TEST_IMG}.dest",cache=$CACHEMODE,driver=$IMGFMT,id=disk \
+    -drive file="${TEST_IMG}.dest",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk \
     -incoming "unix:${MIG_SOCKET}"
 dest=$QEMU_HANDLE
 _send_qemu_cmd $dest "{ 'execute': 'qmp_capabilities' }" 'return'
diff --git a/tests/qemu-iotests/185 b/tests/qemu-iotests/185
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/185
+++ b/tests/qemu-iotests/185
@@ -XXX,XX +XXX,XX @@ echo
 qemu_comm_method="qmp"
 
 _launch_qemu \
-    -drive file="${TEST_IMG}.base",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}.base",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 h=$QEMU_HANDLE
 _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 
@@ -XXX,XX +XXX,XX @@ echo === Start active commit job and exit qemu ===
 echo
 
 _launch_qemu \
-    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 h=$QEMU_HANDLE
 _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 
@@ -XXX,XX +XXX,XX @@ echo === Start mirror job and exit qemu ===
 echo
 
 _launch_qemu \
-    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 h=$QEMU_HANDLE
 _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 
@@ -XXX,XX +XXX,XX @@ echo === Start backup job and exit qemu ===
 echo
 
 _launch_qemu \
-    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 h=$QEMU_HANDLE
 _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 
@@ -XXX,XX +XXX,XX @@ echo === Start streaming job and exit qemu ===
 echo
 
 _launch_qemu \
-    -drive file="${TEST_IMG}",cache=$CACHEMODE,driver=$IMGFMT,id=disk
+    -drive file="${TEST_IMG}",cache=$CACHEMODE,aio=$AIOMODE,driver=$IMGFMT,id=disk
 h=$QEMU_HANDLE
 _send_qemu_cmd $h "{ 'execute': 'qmp_capabilities' }" 'return'
 
diff --git a/tests/qemu-iotests/200 b/tests/qemu-iotests/200
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/200
+++ b/tests/qemu-iotests/200
@@ -XXX,XX +XXX,XX @@ echo === Starting QEMU VM ===
 echo
 qemu_comm_method="qmp"
 _launch_qemu -object iothread,id=iothread0 $virtio_scsi \
-             -drive file="${TEST_IMG}",media=disk,if=none,cache=$CACHEMODE,id=drive_sysdisk,format=$IMGFMT \
+             -drive file="${TEST_IMG}",media=disk,if=none,cache=$CACHEMODE,aio=$AIOMODE,id=drive_sysdisk,format=$IMGFMT \
              -device scsi-hd,drive=drive_sysdisk,bus=scsi0.0,id=sysdisk,bootindex=0
 h1=$QEMU_HANDLE
 
diff --git a/tests/qemu-iotests/201 b/tests/qemu-iotests/201
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/201
+++ b/tests/qemu-iotests/201
@@ -XXX,XX +XXX,XX @@ qemu_comm_method="monitor"
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     _launch_qemu \
-        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
+        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk
 else
     _launch_qemu \
-        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk
 fi
 src=$QEMU_HANDLE
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     _launch_qemu \
-        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
+        -drive "${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,id=disk \
         -incoming "unix:${MIG_SOCKET}"
 else
     _launch_qemu \
-        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},aio=$AIOMODE,driver=$IMGFMT,id=disk \
         -incoming "unix:${MIG_SOCKET}"
 fi
 dest=$QEMU_HANDLE
-- 
2.24.1